@cplieger/web-terminal-ui 7.3.2 → 8.0.0

package/src/features/clipboard.ts

@@ -1,53 +1,38 @@
-/**
- * clipboard feature: copy/paste helpers, the desktop Ctrl+Shift+C/V shortcuts,
- * and OSC 52 mirroring. Exposes a typed API so contextMenu
- * can offer Copy/Paste through it (ctx.use). With this feature absent, inbound
- * OSC 52 has no subscriber and is intentionally a no-op.
- *
- * @module
- */
-
+import { windowOf } from "../kernel/realm.js";
+import { selectionTextWithin } from "../kernel/selection.js";
 import type { TerminalFeature } from "../kernel/types.js";
 
-/** The value a peer feature reads through `ctx.use(clipboard())` — contextMenu's
- *  Copy and Paste items are this API behind a button.
- *
- *  Both members are fire-and-forget: the underlying Clipboard API calls are async
- *  and their outcome is reported to the user as a toast rather than returned, so a
- *  caller cannot await or branch on success. Both require a secure context
- *  (`navigator.clipboard` is absent on a plain-HTTP non-loopback host, a supported
- *  web-terminal-server deployment), where they toast "Clipboard unavailable" and
- *  do nothing. */
+/** The value a peer reads through `ctx.use(clipboard())`. Both members are
+ *  fire-and-forget: the outcome reaches the user as a toast, never the caller.
+ *  Outside a secure context (`navigator.clipboard` absent) they toast
+ *  "Clipboard unavailable" and do nothing. */
 export interface ClipboardApi {
-  /** Write text to the system clipboard (surfaces a toast on success/failure). */
+  /** Write text to the system clipboard. */
   copy(text: string): void;
   /** Read the system clipboard and paste it through the sanitizing funnel. */
   paste(): void;
 }
 
-/** Build the clipboard feature.
- *
- *  It claims three things for the lifetime of the terminal: a kernel keydown
- *  intercept (Ctrl+Shift+C copies the browser selection, Ctrl+Shift+V pastes, and
- *  a plain Ctrl+V is consumed WITHOUT preventDefault so the browser's own paste
- *  event reaches the hidden textarea instead of being mapped to `\x16`), the
- *  `wire:clipboard` event that mirrors an application's OSC 52 copy to the system
- *  clipboard, and a document `copy` listener that toasts "Copied" for a selection
- *  inside the terminal surface only. Teardown releases all three. */
+/** Build the clipboard feature: Ctrl+Shift+C copies the browser selection,
+ *  Ctrl+Shift+V pastes, a plain Ctrl+V is consumed WITHOUT preventDefault so the
+ *  browser's own paste event reaches the hidden textarea, an application's OSC 52
+ *  copy is mirrored to the system clipboard, and a native copy of a selection
+ *  inside the terminal toasts "Copied". Absent, inbound OSC 52 is a no-op. */
 export function clipboard(): TerminalFeature<ClipboardApi> {
   return {
     name: "clipboard",
     setup(ctx) {
+      const surface = ctx.surface();
+      const doc = ctx.shell.root.ownerDocument;
+      const win = windowOf(doc);
       function copy(text: string): void {
-        // navigator.clipboard is undefined outside a secure context (plain-HTTP
-        // non-loopback host, a supported web-terminal-server deployment), where a
-        // property access on it throws synchronously. Feature-detect first.
+        // A property access on navigator.clipboard throws outside a secure context.
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- undefined outside secure contexts
-        if (!navigator.clipboard) {
+        if (!win.navigator.clipboard) {
           ctx.toast("Clipboard unavailable");
           return;
         }
-        navigator.clipboard
+        win.navigator.clipboard
           .writeText(text)
           .then(() => {
             ctx.toast("Copied");
@@ -59,11 +44,11 @@ export function clipboard(): TerminalFeature<ClipboardApi> {
 
       function paste(): void {
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- undefined outside secure contexts
-        if (!navigator.clipboard) {
+        if (!win.navigator.clipboard) {
           ctx.toast("Clipboard unavailable");
           return;
         }
-        navigator.clipboard
+        win.navigator.clipboard
           .readText()
           .then((text) => {
             ctx.paste(text);
@@ -73,23 +58,17 @@ export function clipboard(): TerminalFeature<ClipboardApi> {
           });
       }
 
-      // Desktop clipboard shortcuts, handled before the kernel's key mapping so
-      // they take the browser selection/clipboard rather than server-bound bytes.
-      const offKey = ctx.registerKeydown((ev) => {
-        // Plain Ctrl+V: let the browser's NATIVE paste event flow into the
-        // hidden textarea (the kernel's insertFromPaste path sends it through the
-        // sanitizing funnel). Consuming the key WITHOUT preventDefault stops the
-        // kernel mapping Ctrl+V to \x16 while leaving the native paste intact — so
-        // no navigator.clipboard.readText(), hence no Firefox clipboard-read
-        // popup. (Cmd+V on macOS already pastes natively and never reached the
-        // \x16 mapping.)
+      ctx.registerKeydown((ev) => {
+        // Consuming plain Ctrl+V without preventDefault stops the kernel mapping
+        // it to \x16 while the native paste still flows into the textarea, so no
+        // clipboard read and no Firefox clipboard-read popup.
         if (ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey && ev.code === "KeyV") {
-          return true; // do NOT preventDefault — the browser pastes natively
+          return true;
         }
         if (ev.ctrlKey && ev.shiftKey && !ev.altKey && !ev.metaKey) {
           if (ev.code === "KeyC") {
-            const sel = window.getSelection()?.toString();
-            if (sel) {
+            const sel = selectionTextWithin(surface);
+            if (sel !== "") {
               copy(sel);
             }
             ev.preventDefault();
@@ -104,32 +83,25 @@ export function clipboard(): TerminalFeature<ClipboardApi> {
         return false;
       });
 
-      // Inbound OSC 52: an app copied; mirror it to the system clipboard. This
-      // is an async push (not a user gesture), so some browsers reject it and
-      // copy() surfaces "Copy failed".
-      const offClip = ctx.on("wire:clipboard", (text) => {
+      // An OSC 52 copy is an async push, not a user gesture, so some browsers
+      // reject it and copy() toasts "Copy failed".
+      ctx.on("wire:clipboard", (text) => {
         copy(text);
       });
 
-      // Native copy (e.g. Cmd/Ctrl+C on a selection) feedback toast, scoped to a
-      // selection inside the terminal surface so an embedding host's copies of
-      // its own (non-terminal) content do not raise a spurious "Copied".
-      const surface = ctx.surface();
       const onCopy = (): void => {
-        const node = window.getSelection()?.anchorNode ?? null;
-        if (node && surface.contains(node)) {
+        if (selectionTextWithin(surface) !== "") {
           ctx.toast("Copied");
         }
       };
-      document.addEventListener("copy", onCopy);
+      doc.addEventListener("copy", onCopy);
+      ctx.defer(() => {
+        doc.removeEventListener("copy", onCopy);
+      });
 
       return {
         api: { copy, paste },
-        teardown() {
-          offKey();
-          offClip();
-          document.removeEventListener("copy", onCopy);
-        },
+        teardown: () => undefined,
       };
     },
   };

package/src/features/connection-banner.ts

@@ -1,12 +1,6 @@
-/**
- * connectionBanner feature: renders the kernel's connection state as a visible
- * banner. The state machine, the loading
- * lifecycle, and the give-up hook are kernel-owned; this feature is a pure
- * renderer subscribing to connection:state. It uses the kernel's single
- * announcer (ctx.announce) rather than spawning its own aria-live region.
- *
- * @module
- */
+// The state machine, the loading lifecycle and the give-up hook are the kernel's;
+// this feature only renders connection:state, and announces through the kernel's
+// one announcer rather than an aria-live region of its own.
 
 import type { ConnState, TerminalFeature } from "../kernel/types.js";
 
@@ -21,21 +15,18 @@ const TEXT: Partial<Record<ConnState, string>> = {
   incompatible: "Terminal protocol mismatch; update the server or reload this page",
 };
 
-/** Build the connectionBanner feature. Exposes no API — it owns one element in
- *  the kernel's "banner" region and nothing else reads from it.
- *
- *  Only the states with copy above are shown; `connected` and any other state
- *  hides the banner, so it is a transient surface rather than a permanent status
- *  line. `restarted`, `ended` and `incompatible` are the terminal ones a user
- *  cannot wait out. Each change is announced once through `ctx.announce`, so a
- *  flaky link re-entering the same state does not repeat itself to a screen
- *  reader. Teardown unsubscribes and removes the element. */
+/** Build the connectionBanner feature. Exposes no API: it owns one element in
+ *  the "banner" region. Only the states with copy above are shown, so it is a
+ *  transient surface, not a status line; `restarted`, `ended` and
+ *  `incompatible` are the terminal ones a user cannot wait out. Each change is
+ *  announced once, so a flaky link re-entering a state does not repeat itself
+ *  to a screen reader. Teardown unsubscribes and removes the element. */
 export function connectionBanner(): TerminalFeature {
   return {
     name: "connectionBanner",
     setup(ctx) {
       const slot = ctx.region("banner", "status");
-      const banner = document.createElement("div");
+      const banner = ctx.shell.root.ownerDocument.createElement("div");
       banner.className = "wt-conn-banner";
       slot.appendChild(banner);
 

package/src/features/context-menu.ts

@@ -1,151 +1,69 @@
-/**
- * contextMenu feature: the Copy / Select All / Paste menu for the terminal
- * surface, rendered into the overlay region. Copy and Paste
- * need the clipboard feature (ctx.use), and Paste routes through the kernel's
- * sanitizing funnel. Escape-to-close goes through the kernel keydown intercept;
- * outside-click is a document gesture.
- *
- * WHY THIS MENU EXISTS
- * The terminal output is real DOM text, so the browser already does the hard
- * part: drag-select with a mouse, long-press word-select plus the OS copy callout
- * on touch. What no platform can offer is PASTE — the keyboard target is a 1x1
- * pointer-events:none textarea, so there is no editable surface under the pointer
- * for a native paste item to attach to. This menu is the paste path. It carries
- * Copy and Select All because a menu appearing where the platform's would have
- * appeared should not be missing them.
- *
- * THE MODEL: one owner per gesture, and nothing decided mid-gesture.
- *
- *   Mouse / pen — `contextmenu` is an already-classified request for a menu:
- *   preventDefault and open at the pointer. No timers, no heuristics, no
- *   platform branches.
- *
- *   Touch — the platform owns the press while the finger is down. We run no hold
- *   timer against it, open nothing before it finishes, and never cancel its
- *   gesture on WebKit. We classify ONCE, on `touchend`, when every fact is
- *   settled: a single-finger, stationary press held past the tap ceiling
- *   (kernel/gesture.ts, shared with the kernel's tap-to-focus so the two cannot
- *   both claim one press) that selected nothing and did not start on a link is a
- *   press the platform declined — so it is ours, and it is the paste path. A
- *   press that produced a selection belongs to the OS callout; a press on a link
- *   belongs to the platform's link preview; a shorter press is the kernel's tap.
- *
- * WHY AT RELEASE RATHER THAN DURING THE HOLD
- * Opening from a ~550ms hold timer put this feature in a race it cannot win: the
- * timer has to beat the platform's own long-press threshold and then GUESS
- * whether a selection is still coming (iOS 26 registers a word selection well
- * after 550ms). Four mechanisms existed only to referee that guess — a hit test
- * for glyphs under the finger, a selectionchange watch to retract a menu that
- * opened too early, a device sniff, and per-platform contextmenu branching,
- * because WebKit reads preventDefault on a touch contextmenu as "cancel every
- * remaining default of this gesture", the not-yet-registered selection included.
- * Deciding at release deletes all four: the outcome is observed, not predicted.
- *
- * It also fixes the symptom that prompted the rewrite. A touch long-press emits a
- * trailing click on release, and the swallow window that covers that click was
- * armed when the menu OPENED — ~550ms into the press, expiring 350ms later — so
- * holding a beat longer meant the release click landed as an outside click and
- * dismissed the menu the instant the finger lifted. Opened BY the release, the
- * window can only ever start at the release edge.
- *
- * @module
- */
+// Exists for PASTE: the keyboard target is a 1x1 pointer-events:none textarea, so
+// no platform can attach a native paste item under the pointer. A touch press is
+// classified ONCE, at touchend, when every fact is settled (a stationary
+// single-finger press past the tap ceiling that selected nothing and did not start
+// on a link is one the platform declined), and deciding at release is what lets
+// the trailing-click swallow start at the release edge.
 
+import { windowOf } from "../kernel/realm.js";
+import { selectionTextWithin } from "../kernel/selection.js";
 import type { TerminalFeature } from "../kernel/types.js";
 import { TAP_MAX_MS, TAP_MOVEMENT_PX, isLinkTarget } from "../kernel/gesture.js";
 import type { ClipboardApi } from "./clipboard.js";
 import { createClickSwallow, placeMenuAt } from "./menu-position.js";
 
-// Viewport clamping, the flip-above-the-fingertip gap, and the trailing-click
-// swallow all live in the shared point-anchored menu module (menu-position.ts),
-// shared with the tab menu.
-
-/** Options for the contextMenu feature.
- *
- *  Pass the SAME clipboard feature value the composition includes, not a second
- *  `clipboard()` call: `ctx.use` resolves a value to the instance the kernel set
- *  up, so a value that is not in the feature list resolves to nothing and the
- *  menu silently loses Copy and Paste. `presetSingle` shows the shape. */
+/** Options for the contextMenu feature. Pass the SAME clipboard feature value
+ *  the composition includes, not a second `clipboard()` call: `ctx.use` resolves
+ *  a value that is not in the feature list to nothing, and the menu silently
+ *  loses Copy and Paste. */
 export interface ContextMenuOptions {
-  /** The clipboard feature value, so the menu can offer Copy/Paste through its
-   *  API (ctx.use). Omitted: the menu shows only Select All. */
+  /** The clipboard feature value. Omitted: the menu shows only Select All. */
   clipboard?: TerminalFeature<ClipboardApi>;
 }
 
-/** iPhone/iPad/iPod, including iPadOS Safari's default "desktop mode" (platform
- *  MacIntel with a touch screen).
- *
- *  This decides exactly one thing: whether a touch `contextmenu` may be
- *  cancelled. WebKit reads preventDefault there as "cancel every remaining
- *  default action of this gesture", which takes the platform's own
- *  not-yet-registered word selection with it — that asymmetry is what once left
- *  an iPad unable to select text at all while an iPhone (which fires no
- *  contextmenu) could. Everywhere else, cancelling is how we stop the platform's
- *  menu appearing alongside ours. It no longer decides whether or when our menu
- *  opens, so a wrong answer here costs at most a duplicated menu on an unusual
- *  device, never a broken selection and never a lost paste. */
-function isAppleTouchDevice(): boolean {
-  // Dead in every runtime that reaches this, and left in place deliberately.
-  // Measured on this repo's Node (v24.18.0, the version ts-ci pins): `typeof
-  // navigator` is "object", with userAgent "Node.js/24", platform
-  // "Linux x86_64" and maxTouchPoints undefined — so the fall-through already
-  // answers false there, by the same route a browser on a non-Apple device
-  // takes. A Web Worker has a WorkerNavigator, so it does not reach this
-  // either. What the guard still buys is totality: without it the bare
-  // `navigator` reads below would throw a ReferenceError in a runtime that has
-  // no navigator at all. It answers the same `false` the fall-through would, so
-  // nothing depends on reaching it, and no test can reach it without stubbing.
-  if (typeof navigator === "undefined") {
-    return false;
-  }
-  const ua = navigator.userAgent || "";
-  const platform = navigator.platform || "";
+/** Whether a touch `contextmenu` may be cancelled. WebKit reads preventDefault
+ *  there as "cancel every remaining default of this gesture", the platform's
+ *  not-yet-registered word selection included, which once left an iPad unable to
+ *  select text; everywhere else cancelling keeps the platform's menu from
+ *  appearing beside ours. */
+function isAppleTouchDevice(nav: Navigator): boolean {
+  const ua = nav.userAgent || "";
+  const platform = nav.platform || "";
   if (/iP(hone|ad|od)/.test(ua) || /iP(hone|ad|od)/.test(platform)) {
     return true;
   }
-  // iPadOS 13+ Safari defaults to desktop mode: platform "MacIntel" but a touch
-  // screen (maxTouchPoints > 1). A real trackpad Mac reports maxTouchPoints 0.
-  return platform === "MacIntel" && navigator.maxTouchPoints > 1;
+  // iPadOS Safari's desktop mode reports MacIntel with a touch screen; a
+  // trackpad Mac reports maxTouchPoints 0.
+  return platform === "MacIntel" && nav.maxTouchPoints > 1;
 }
 
-/** The current selection as text ("" when nothing is selected). A collapsed
- *  selection stringifies to "", so this is the whole test. */
-function selectionText(): string {
-  return window.getSelection()?.toString() ?? "";
-}
-
-/** True when an event target sits inside a hyperlink. A long-press on a link
- *  raises the platform's own link preview/menu without ever making a selection,
- *  so the selection test alone would not keep us out of its way. */
-const onLink = isLinkTarget;
-
-/** Build the contextMenu feature. Exposes no API — the menu is opened by the
- *  gestures described above, never programmatically by a peer.
- *
- *  Hand it the clipboard value the composition also includes (see
- *  ContextMenuOptions) or it degrades to a Select All-only menu; its own position in
- *  the feature list is otherwise free, since nothing reads it through `ctx.use`. Its
- *  items act on the browser selection inside the terminal surface and on the
- *  kernel's paste funnel, so it holds no session state and survives a tab switch
- *  unchanged. Teardown removes the menu element and releases the keydown intercept
- *  along with every surface and document listener. */
+/** Build the contextMenu feature. Exposes no API. Without the clipboard value of
+ *  ContextMenuOptions it degrades to a Select All-only menu. Its items act on the
+ *  browser selection inside the surface and on the kernel's paste funnel, so it
+ *  holds no session state. */
 export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
   return {
     name: "contextMenu",
     setup(ctx) {
       const surface = ctx.surface();
-      const menu = document.createElement("div");
+      const doc = ctx.shell.root.ownerDocument;
+      const win = windowOf(doc);
+      const menu = doc.createElement("div");
       menu.className = "wt-ctx-menu";
       ctx.region("overlay", "menu").appendChild(menu);
+      // A long-press on a link raises the platform's own preview without ever
+      // making a selection, so the selection test alone would not keep us out of
+      // its way.
+      const onLink = (target: EventTarget | null): boolean => isLinkTarget(win, target);
 
       // The device that started the current interaction: `contextmenu` fires on a
       // desktop right-click AND on an Android long-press, so its handler branches
       // on this to tell them apart.
       let lastPointerType = "mouse";
       // Computed once: may a touch contextmenu be cancelled (see isAppleTouchDevice).
-      const appleTouch = isAppleTouchDevice();
+      const appleTouch = isAppleTouchDevice(win.navigator);
       // Swallows the trailing click a touch long-press emits on release.
-      const swallow = createClickSwallow();
+      const swallow = createClickSwallow(win);
 
       // The in-flight single-finger press, all of it read at `touchend`.
       // pressLive goes false the moment the gesture stops being a candidate (a
@@ -169,7 +87,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
       }
 
       function hide(refocus = true): void {
-        const shouldRefocus = refocus && menu.contains(document.activeElement);
+        const shouldRefocus = refocus && menu.contains(doc.activeElement);
         menu.classList.remove("visible");
         menu.replaceChildren();
         if (shouldRefocus) {
@@ -181,7 +99,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
       // NOT refocus the textarea, or Firefox collapses the just-made selection
       // when focus leaves the output.
       function addButton(label: string, onClick: () => void, refocus = true): void {
-        const b = document.createElement("button");
+        const b = doc.createElement("button");
         b.type = "button";
         b.textContent = label;
         b.addEventListener("click", () => {
@@ -196,7 +114,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
       function show(x: number, y: number): void {
         hide();
         const clipboard = clip();
-        const sel = selectionText();
+        const sel = selectionTextWithin(surface);
         if (clipboard && sel) {
           addButton("Copy", () => {
             clipboard.copy(sel);
@@ -205,7 +123,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         addButton(
           "Select All",
           () => {
-            const s = window.getSelection();
+            const s = doc.getSelection();
             const output = surface.querySelector(".term-output");
             if (s && output) {
               s.selectAllChildren(output);
@@ -229,6 +147,9 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         lastPointerType = e.pointerType;
       };
       surface.addEventListener("pointerdown", onPointerDown, { passive: true });
+      ctx.defer(() => {
+        surface.removeEventListener("pointerdown", onPointerDown);
+      });
 
       const onContextMenu = (e: MouseEvent): void => {
         if (lastPointerType !== "touch") {
@@ -236,20 +157,21 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
           show(e.clientX, e.clientY);
           return;
         }
-        // Touch: our menu never opens from here — the touchend classifier owns
-        // that. The only question left is whether the PLATFORM's menu may
-        // proceed. On WebKit it must (cancelling here cancels the whole gesture's
-        // remaining defaults, the word selection included). Elsewhere (Android
-        // fires contextmenu mid-press) cancel it when the press has nothing of
-        // the platform's own to show, so its menu and ours cannot both appear.
-        if (!appleTouch && !onLink(e.target) && selectionText() === "") {
+        // Touch: the touchend classifier owns our menu; the question here is whether
+        // the PLATFORM's may proceed. WebKit must keep it (cancelling cancels the
+        // gesture's remaining defaults, the word selection included); elsewhere it is
+        // cancelled when the press has nothing of the platform's to show.
+        if (!appleTouch && !onLink(e.target) && selectionTextWithin(surface) === "") {
           e.preventDefault();
         }
       };
       surface.addEventListener("contextmenu", onContextMenu);
+      ctx.defer(() => {
+        surface.removeEventListener("contextmenu", onContextMenu);
+      });
 
       // Escape closes the menu without also sending ESC to the PTY.
-      const offKey = ctx.registerKeydown((ev) => {
+      ctx.registerKeydown((ev) => {
         if (ev.key === "Escape" && menu.classList.contains("visible")) {
           ev.preventDefault();
           hide();
@@ -263,7 +185,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         // menu with the correct refocus behaviour (Select All must not refocus
         // the input, or Firefox collapses the selection it just made). Reaching
         // hide() from here as well would override that choice.
-        if (e.target instanceof Node && menu.contains(e.target)) {
+        if (e.target instanceof win.Node && menu.contains(e.target)) {
           return;
         }
         // The release click of the long-press that just opened the menu is that
@@ -273,7 +195,10 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         }
         hide();
       };
-      document.addEventListener("click", onDocClick);
+      doc.addEventListener("click", onDocClick);
+      ctx.defer(() => {
+        doc.removeEventListener("click", onDocClick);
+      });
       // A right-click outside the terminal surface (a tab, its menu, elsewhere,
       // or a native browser menu) dismisses this menu. A right-click on the
       // surface is handled by onContextMenu (which reopens it) and fires first.
@@ -282,7 +207,10 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
           hide();
         }
       };
-      document.addEventListener("contextmenu", onDocContextMenu);
+      doc.addEventListener("contextmenu", onDocContextMenu);
+      ctx.defer(() => {
+        doc.removeEventListener("contextmenu", onDocContextMenu);
+      });
 
       const onTouchStart = (e: TouchEvent): void => {
         const t = e.touches.length === 1 ? e.touches[0] : undefined;
@@ -295,7 +223,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         pressX = t.clientX;
         pressY = t.clientY;
         pressOnLink = onLink(e.target);
-        pressSelection = selectionText();
+        pressSelection = selectionTextWithin(surface);
       };
       const onTouchMove = (e: TouchEvent): void => {
         if (!pressLive) {
@@ -325,7 +253,7 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
         if (e.timeStamp - pressStart <= TAP_MAX_MS) {
           return; // a tap: the kernel focuses the input / clears the selection
         }
-        const sel = selectionText();
+        const sel = selectionTextWithin(surface);
         if (sel !== "" && sel !== pressSelection) {
           return; // this press selected text; the OS callout owns it
         }
@@ -343,18 +271,15 @@ export function contextMenu(opts: ContextMenuOptions = {}): TerminalFeature {
       surface.addEventListener("touchmove", onTouchMove, { passive: true });
       surface.addEventListener("touchend", onTouchEnd, { passive: true });
       surface.addEventListener("touchcancel", onTouchCancel, { passive: true });
+      ctx.defer(() => {
+        surface.removeEventListener("touchstart", onTouchStart);
+        surface.removeEventListener("touchmove", onTouchMove);
+        surface.removeEventListener("touchend", onTouchEnd);
+        surface.removeEventListener("touchcancel", onTouchCancel);
+      });
 
       return {
         teardown() {
-          offKey();
-          surface.removeEventListener("pointerdown", onPointerDown);
-          surface.removeEventListener("contextmenu", onContextMenu);
-          document.removeEventListener("click", onDocClick);
-          document.removeEventListener("contextmenu", onDocContextMenu);
-          surface.removeEventListener("touchstart", onTouchStart);
-          surface.removeEventListener("touchmove", onTouchMove);
-          surface.removeEventListener("touchend", onTouchEnd);
-          surface.removeEventListener("touchcancel", onTouchCancel);
           menu.remove();
         },
       };