fix(viewer): wire Ctrl+A to select all text in the PDF (Stirling-Tools#6517)

# Description of Changes

Allow Ctrl A support in viewer and fix select text to copy issues via a
hovering copy button

---

## Checklist

### General

- [ ] I have read the [Contribution
Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md)
- [ ] I have read the [Stirling-PDF Developer
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/DeveloperGuide.md)
(if applicable)
- [ ] I have read the [How to add new languages to
Stirling-PDF](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md)
(if applicable)
- [ ] I have performed a self-review of my own code
- [ ] My changes generate no new warnings

### Documentation

- [ ] I have updated relevant docs on [Stirling-PDF's doc
repo](https://github.com/Stirling-Tools/Stirling-Tools.github.io/blob/main/docs/)
(if functionality has heavily changed)
- [ ] I have read the section [Add New Translation
Tags](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/HowToAddNewLanguage.md#add-new-translation-tags)
(for new translation tags only)

### Translations (if applicable)

- [ ] I ran
[`scripts/counter_translation.py`](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/docs/counter_translation.md)

### UI Changes (if applicable)

- [ ] Screenshots or videos demonstrating the UI changes are attached
(e.g., as comments or direct attachments in the PR)

### Testing (if applicable)

- [ ] I have run `task check` to verify linters, typechecks, and tests
pass
- [ ] I have tested my changes locally. Refer to the [Testing
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/DeveloperGuide.md#7-testing)
for more details.

---------

Co-authored-by: EthanHealy01 <80844253+EthanHealy01@users.noreply.github.com>
Co-authored-by: James Brunton <jbrunton96@gmail.com>

Author: 3 people

.gitleaksignore

@@ -1,4 +1,4 @@
-# PostHog project-level key — phc_ prefix keys are public/client-side by design
+# PostHog project-level key - phc_ prefix keys are public/client-side by design
 # (PostHog client-side tracking embeds them in the browser bundle). Committed
 # intentionally in #6150 so engine/.env has a working default, with real
 # credentials overridden via engine/.env.local.
@@ -12,6 +12,10 @@ app/proprietary/src/test/java/stirling/software/proprietary/mcp/security/McpApiK
 testing/compose/docker-compose-keycloak-mcp.yml:generic-api-key:25
 testing/compose/validate-mcp-apikey.sh:curl-auth-header:73
 testing/compose/validate-mcp-test.sh:curl-auth-header:92
+testing/compose/validate-mcp-test.sh:curl-auth-header:116
+
+# Storybook example showing curl with a fake Bearer token placeholder (sk_live_a3f8...).
+frontend/shared/components/CodeBlock.stories.tsx:curl-auth-header:4
 
 # Truncated placeholder API key in portal docs example (sk_live_8f2c...e10) - not a real secret.
 frontend/portal/src/components/docs/GettingStartedSection.tsx:generic-api-key:31

frontend/editor/public/locales/en-GB/translation.toml

@@ -7917,6 +7917,7 @@ valid = "Valid"
 
 [viewer]
 cannotPreviewFile = "Cannot Preview File"
+copyText = "Copy"
 disableColorFilter = "Disable Colour Filter"
 dualPageView = "Dual Page View"
 enableDarkFilter = "Enable Dark Filter"

frontend/editor/public/locales/en-US/translation.toml

@@ -7890,6 +7890,7 @@ valid = "Valid"
 
 [viewer]
 cannotPreviewFile = "Cannot Preview File"
+copyText = "Copy"
 disableColorFilter = "Disable Color Filter"
 dualPageView = "Dual Page View"
 enableDarkFilter = "Enable Dark Filter"

frontend/editor/src/core/components/viewer/EmbedPdfViewer.tsx

@@ -173,6 +173,7 @@ const EmbedPdfViewerContent = ({
     isAnnotationsVisible,
     exportActions,
     printActions,
+    selectionActions,
     setApplyChanges,
     applyChanges: viewerApplyChanges,
     pdfRenderMode,
@@ -442,6 +443,17 @@ const EmbedPdfViewerContent = ({
                 event.preventDefault();
                 printActions.print();
                 return;
+              case "a":
+              case "A":
+                // Intercept unconditionally so the browser can't blanket-select the surrounding UI chrome.
+                event.preventDefault();
+                {
+                  const totalPages = getScrollState().totalPages;
+                  if (totalPages > 0) {
+                    void selectionActions.selectAll(totalPages);
+                  }
+                }
+                return;
               case "=":
               case "+":
                 event.preventDefault();
@@ -469,11 +481,6 @@ const EmbedPdfViewerContent = ({
       // Modifier key shortcuts (Ctrl/Cmd + key)
       if (mod) {
         switch (event.key) {
-          case "a":
-          case "A":
-            // Ctrl+A: Prevent browser from selecting all UI text
-            event.preventDefault();
-            return;
           case "f":
           case "F":
             event.preventDefault();
@@ -558,6 +565,8 @@ const EmbedPdfViewerContent = ({
     viewerApplyChanges,
     cyclePdfRenderMode,
     viewerKeyCommand,
+    selectionActions,
+    getScrollState,
   ]);
 
   // Watch the annotation history API to detect when the document becomes "dirty".

frontend/editor/src/core/components/viewer/LocalEmbedPDF.tsx

@@ -81,6 +81,7 @@ import { LinkLayer } from "@app/components/viewer/LinkLayer";
 import { TextSelectionHandler } from "@app/components/viewer/TextSelectionHandler";
 import { RedactionSelectionMenu } from "@app/components/viewer/RedactionSelectionMenu";
 import { AnnotationSelectionMenu } from "@app/components/viewer/AnnotationSelectionMenu";
+import { TextSelectionMenu } from "@app/components/viewer/TextSelectionMenu";
 import {
   RedactionPendingTracker,
   RedactionPendingTrackerAPI,
@@ -995,6 +996,9 @@ export function LocalEmbedPDF({
                                       documentId={documentId}
                                       pageIndex={pageIndex}
                                       background="var(--pdf-selection-bg)"
+                                      selectionMenu={(props) => (
+                                        <TextSelectionMenu {...props} />
+                                      )}
                                     />
                                   </div>
                                   <TextSelectionHandler

frontend/editor/src/core/components/viewer/SelectionAPIBridge.tsx

@@ -1,26 +1,135 @@
 import { useEffect, useRef } from "react";
-import { useSelectionCapability } from "@embedpdf/plugin-selection/react";
+import {
+  useSelectionCapability,
+  useSelectionPlugin,
+  glyphAt,
+} from "@embedpdf/plugin-selection/react";
+import { useDocumentState } from "@embedpdf/core/react";
 import { useViewer } from "@app/contexts/ViewerContext";
 import { useDocumentReady } from "@app/components/viewer/hooks/useDocumentReady";
+import { useActiveDocumentId } from "@app/components/viewer/useActiveDocumentId";
 
 /**
  * Connects the PDF selection plugin to the shared ViewerContext.
  */
 export function SelectionAPIBridge() {
   const { provides: selection } = useSelectionCapability();
+  const { plugin: selectionPlugin } = useSelectionPlugin();
   const { registerBridge } = useViewer();
   const documentReady = useDocumentReady();
+  const activeDocumentId = useActiveDocumentId();
+  const documentState = useDocumentState(activeDocumentId ?? "");
+  const scaleRef = useRef(1);
+  scaleRef.current =
+    (documentState as { scale?: number } | undefined)?.scale ?? 1;
 
   const hasSelectionRef = useRef(false);
   const selectedTextRef = useRef("");
 
   useEffect(() => {
     if (!selection || !documentReady) return;
 
+    // begin/update/end + getOrLoadGeometry are runtime-public but typed private;
+    // matches the TextSelectionHandler word/line cast.
+    type SelectionPluginInternals = {
+      clearSelection: (id: string) => void;
+      beginSelection: (id: string, page: number, glyph: number) => void;
+      updateSelection: (id: string, page: number, glyph: number) => void;
+      endSelection: (id: string) => void;
+      getOrLoadGeometry: (
+        id: string,
+        pageIdx: number,
+      ) => { toPromise: () => Promise<unknown> };
+    };
+
+    const lastGlyphOnPage = (geo: {
+      runs: { charStart: number; glyphs: unknown[] }[];
+    }): number => {
+      let last = 0;
+      for (const run of geo.runs) {
+        const end = run.charStart + run.glyphs.length - 1;
+        if (end > last) last = end;
+      }
+      return last;
+    };
+
+    const selectAllInDocument = async (
+      documentId: string,
+      totalPages: number,
+    ) => {
+      const plugin = selectionPlugin as unknown as SelectionPluginInternals;
+      if (totalPages <= 0) return false;
+
+      // Pre-load geometry for every page so updateRectsAndSlices has data to
+      // emit rects for, and getSelectedText has slices for, every page.
+      try {
+        await Promise.all(
+          Array.from({ length: totalPages }, (_, p) =>
+            plugin.getOrLoadGeometry(documentId, p).toPromise(),
+          ),
+        );
+      } catch {
+        // Continue with whatever geometry did load
+      }
+
+      const state = selection.getState(documentId);
+      let firstPage = -1;
+      let lastPage = -1;
+      let lastGlyph = 0;
+      for (let p = 0; p < totalPages; p++) {
+        const geo = state.geometry[p];
+        if (!geo || geo.runs.length === 0) continue;
+        if (firstPage === -1) firstPage = p;
+        lastPage = p;
+        lastGlyph = lastGlyphOnPage(geo);
+      }
+
+      if (firstPage === -1 || lastPage === -1) return false;
+
+      plugin.clearSelection(documentId);
+      plugin.beginSelection(documentId, firstPage, 0);
+      plugin.updateSelection(documentId, lastPage, lastGlyph);
+      plugin.endSelection(documentId);
+      return true;
+    };
+
+    const selectWordAt = (
+      documentId: string,
+      pageIndex: number,
+      x: number,
+      y: number,
+    ) => {
+      const plugin = selectionPlugin as unknown as {
+        selectWord: (
+          id: string,
+          page: number,
+          glyph: number,
+          modeId: string,
+        ) => void;
+      };
+      const state = selection.getState(documentId);
+      const geo = state.geometry[pageIndex];
+      if (!geo) return false;
+      const g = glyphAt(geo, { x, y }, 3);
+      if (g === -1) return false;
+      plugin.selectWord(documentId, pageIndex, g, "pointerMode");
+      return true;
+    };
+
     const buildApi = () => ({
       copyToClipboard: () => selection.copyToClipboard(),
       getSelectedText: () => selection.getSelectedText(),
       getFormattedSelection: () => selection.getFormattedSelection(),
+      selectAll: async (totalPages: number) => {
+        const docId = activeDocumentId;
+        if (!docId || !selectionPlugin) return false;
+        return selectAllInDocument(docId, totalPages);
+      },
+      selectWordAt: (pageIndex: number, x: number, y: number) => {
+        const docId = activeDocumentId;
+        if (!docId || !selectionPlugin) return false;
+        return selectWordAt(docId, pageIndex, x, y);
+      },
     });
 
     registerBridge("selection", {
@@ -83,17 +192,47 @@ export function SelectionAPIBridge() {
       }
     };
 
+    // Right-click anywhere inside a PDF page: suppress the browser's "Copy
+    // image" menu, and if nothing is currently selected, auto-select the
+    // word under the cursor so the floating Copy menu appears in place.
+    const handleContextMenu = (event: MouseEvent) => {
+      let el = event.target as HTMLElement | null;
+      while (el && !el.dataset?.pageIndex) {
+        el = el.parentElement;
+      }
+      if (!el) return;
+      event.preventDefault();
+      if (hasSelectionRef.current) return;
+      const docId = activeDocumentId;
+      if (!docId || !selectionPlugin) return;
+      const pageIndex = Number(el.dataset.pageIndex);
+      if (Number.isNaN(pageIndex)) return;
+      const rect = el.getBoundingClientRect();
+      const scale = scaleRef.current || 1;
+      const x = (event.clientX - rect.left) / scale;
+      const y = (event.clientY - rect.top) / scale;
+      selectWordAt(docId, pageIndex, x, y);
+    };
+
     document.addEventListener("copy", handleCopy);
     document.addEventListener("keydown", handleKeyDown);
+    document.addEventListener("contextmenu", handleContextMenu);
 
     return () => {
       unsubChange?.();
       unsubCopy?.();
       document.removeEventListener("copy", handleCopy);
       document.removeEventListener("keydown", handleKeyDown);
+      document.removeEventListener("contextmenu", handleContextMenu);
       registerBridge("selection", null);
     };
-  }, [selection, documentReady, registerBridge]);
+  }, [
+    selection,
+    selectionPlugin,
+    activeDocumentId,
+    documentReady,
+    registerBridge,
+  ]);
 
   return null;
 }

frontend/editor/src/core/components/viewer/TextSelectionMenu.tsx

@@ -0,0 +1,99 @@
+import { ActionIcon, Tooltip } from "@mantine/core";
+import ContentCopyIcon from "@mui/icons-material/ContentCopy";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useTranslation } from "react-i18next";
+import type { SelectionSelectionMenuProps } from "@embedpdf/plugin-selection/react";
+import { useSelectionCapability } from "@embedpdf/plugin-selection/react";
+
+export function TextSelectionMenu({
+  selected,
+  menuWrapperProps,
+  placement,
+}: SelectionSelectionMenuProps) {
+  const { t } = useTranslation();
+  const { provides: selection } = useSelectionCapability();
+  const wrapperRef = useRef<HTMLDivElement>(null);
+  const [position, setPosition] = useState<{
+    top: number;
+    left: number;
+  } | null>(null);
+
+  const setRef = useCallback(
+    (node: HTMLDivElement | null) => {
+      wrapperRef.current = node;
+      menuWrapperProps?.ref?.(node);
+    },
+    [menuWrapperProps],
+  );
+
+  const showAbove = placement?.suggestTop ?? true;
+
+  useEffect(() => {
+    if (!selected || !wrapperRef.current) {
+      setPosition(null);
+      return;
+    }
+    const update = () => {
+      const wrapper = wrapperRef.current;
+      if (!wrapper) return;
+      const r = wrapper.getBoundingClientRect();
+      setPosition({
+        top: showAbove ? r.top - 8 : r.bottom + 8,
+        left: r.left + r.width / 2,
+      });
+    };
+    update();
+    window.addEventListener("scroll", update, true);
+    window.addEventListener("resize", update);
+    return () => {
+      window.removeEventListener("scroll", update, true);
+      window.removeEventListener("resize", update);
+    };
+  }, [selected, showAbove]);
+
+  const handleCopy = useCallback(() => {
+    selection?.copyToClipboard();
+  }, [selection]);
+
+  const portalContent =
+    position &&
+    createPortal(
+      <div
+        style={{
+          position: "fixed",
+          top: position.top,
+          left: position.left,
+          transform: `translate(-50%, ${showAbove ? "-100%" : "0"})`,
+          zIndex: 10000,
+          pointerEvents: "auto",
+        }}
+        onMouseDown={(e) => e.preventDefault()}
+      >
+        <Tooltip label={t("viewer.copyText", "Copy")} withArrow>
+          <ActionIcon
+            variant="filled"
+            size="md"
+            onClick={handleCopy}
+            aria-label={t("viewer.copyText", "Copy")}
+            style={{
+              backgroundColor: "var(--mantine-color-body)",
+              border: "1px solid var(--mantine-color-default-border)",
+              color: "var(--text-primary)",
+              boxShadow: "0 2px 12px rgba(0, 0, 0, 0.25)",
+            }}
+          >
+            <ContentCopyIcon style={{ fontSize: 18 }} />
+          </ActionIcon>
+        </Tooltip>
+      </div>,
+      document.body,
+    );
+
+  return (
+    <>
+      <div ref={setRef} style={menuWrapperProps?.style} />
+      {portalContent}
+    </>
+  );
+}