@cplieger/web-terminal-ui 8.2.1 → 8.3.1

package/css/01-scope.css

@@ -15,15 +15,9 @@
 .wt-root.wt-viewport {
   position: fixed;
   inset: 0;
-  /* Clip like the container mode below, so the two layout modes agree. Inert
-     today: the root's box IS the viewport here and page.css already hides
-     document overflow, so nothing can currently paint outside it, and
-     position:fixed descendants escape a clip regardless. It exists so the
-     asymmetry cannot be mistaken for a deliberate difference, and so a future
-     transform on .term (see docs/tab-switch-repaint.md) is bounded by a
-     declaration rather than by the viewport happening to coincide with the box.
-     overflow:clip specifically, not hidden: no scroll container, no block
-     formatting context, nothing programmatically scrollable. */
+  /* Clip like the container mode below, so the two modes agree. Inert while
+     this box is the viewport, but it bounds a future transform on .term by a
+     declaration. clip, not hidden: no scroll container, no BFC. */
   overflow: clip;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/web-terminal-ui",
-  "version": "8.2.1",
+  "version": "8.3.1",
   "type": "module",
   "description": "Reference touch-first browser UI for @cplieger/web-terminal-engine: a composable kernel + feature modules (tabs, activity monitor, mobile toolbar, context menu, IME, predictive echo, viewport handling) and CSS. One createTerminal() call.",
   "license": "MPL-2.0",
@@ -52,20 +52,20 @@
     "@stryker-mutator/vitest-runner": "10.0.0",
     "@types/node": "26.6.3",
     "@typescript/native": "npm:typescript@7.0.2",
-    "@vitest/browser": "5.0.2",
-    "@vitest/browser-playwright": "5.0.2",
-    "@vitest/coverage-v8": "5.0.2",
+    "@vitest/browser": "5.0.3",
+    "@vitest/browser-playwright": "5.0.3",
+    "@vitest/coverage-v8": "5.0.3",
     "eslint": "10.11.0",
     "fast-check": "4.10.2",
     "html-validate": "11.16.1",
-    "knip": "6.38.0",
+    "knip": "6.39.0",
     "playwright": "1.63.0",
     "prettier": "3.9.9",
     "stylelint": "17.15.0",
     "stylelint-config-standard": "40.0.0",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.0",
-    "vitest": "5.0.2"
+    "vitest": "5.0.3"
   },
   "publishConfig": {
     "access": "public"

package/src/features/connection-banner.ts

@@ -8,11 +8,11 @@ const TEXT: Partial<Record<ConnState, string>> = {
   connecting: "Reconnecting\u2026",
   reconnecting: "Reconnecting\u2026",
   offline: "Offline",
-  restarted: "Server restarted; recent input may be lost",
+  restarted: "Server restarted. Recent input may be lost",
   // The session's process exited (definitive; nothing is retrying). The final
   // screen stays rendered behind the banner; open a new tab to keep working.
   ended: "Session ended",
-  incompatible: "Terminal protocol mismatch; update the server or reload this page",
+  incompatible: "Terminal protocol mismatch. Update the server or reload this page",
 };
 
 /** Build the connectionBanner feature. Exposes no API: it owns one element in

package/src/features/tabs/index.ts

@@ -247,12 +247,12 @@ async function createSessionHonouringRetry(
       if (lastAnnouncedAt === null || elapsed - lastAnnouncedAt >= CREATE_RETRY_REANNOUNCE_MS) {
         lastAnnouncedAt = elapsed;
         const reason = err.serverMessage ?? "Server is not ready yet";
-        ctx.toast(`${reason}; waiting…`, 8000);
-        ctx.announce(`${reason}; waiting…`);
+        ctx.toast(`${reason}, waiting…`, 8000);
+        ctx.announce(`${reason}, waiting…`);
       }
       // Unthrottled: the overlay is the only surface visible before the first
       // frame, and it replaces text in place.
-      ctx.loadingReason(`${err.serverMessage ?? "Server is not ready yet"}; waiting…`);
+      ctx.loadingReason(`${err.serverMessage ?? "Server is not ready yet"}, waiting…`);
       await retryWait(win, err.retryAfterMs ?? CREATE_RETRY_FALLBACK_MS, signal);
       continue;
     }
@@ -281,27 +281,6 @@ interface ShowOptions {
 type SplitOpening =
   { readonly by: "button" } | { readonly by: "snap"; readonly id: string; readonly side: PaneSide };
 
-function looksLikeHardwareKey(ev: KeyboardEvent): boolean {
-  if (ev.ctrlKey || ev.metaKey || ev.altKey) {
-    return true;
-  }
-  switch (ev.key) {
-    case "ArrowUp":
-    case "ArrowDown":
-    case "ArrowLeft":
-    case "ArrowRight":
-    case "Escape":
-    case "Tab":
-    case "Home":
-    case "End":
-    case "PageUp":
-    case "PageDown":
-      return true;
-    default:
-      return /^F\d{1,2}$/.test(ev.key); // F1–F12
-  }
-}
-
 /** Build the tabs feature.
  *  Requires a server that speaks the session API (`GET`/`POST`/`DELETE` on
  *  `/api/sessions`, `?session=<id>` on the WebSocket, ideally the status SSE).
@@ -852,13 +831,6 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       let creatingTab = false;
       let collapseClearTimer: number | null = null;
       let hintShown = false;
-      // No web API reports a hardware keyboard, so two proxies: a fine pointer
-      // (read live, since a keyboard folio with a trackpad can be detached) and a
-      // keydown only a hardware keyboard emits (a trackpad-less folio).
-      let sawHardwareKey = false;
-      const hasFinePointer = (): boolean =>
-        typeof win.matchMedia === "function" && win.matchMedia("(any-pointer: fine)").matches;
-      const physicalKeyboardLikely = (): boolean => sawHardwareKey || hasFinePointer();
       const prefersReduce = (): boolean =>
         win.matchMedia("(prefers-reduced-motion: reduce)").matches;
 
@@ -984,7 +956,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           return;
         }
         if (
-          physicalKeyboardLikely() ||
+          ctx.shell.keyboard.likely() ||
           (inputFocusedAtPress && keyboardParkedOnChrome()) ||
           keyboardInOtherPane()
         ) {
@@ -2460,8 +2432,8 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           // became ready: say so with the server's own words when it gave any.
           ctx.toast(
             err instanceof SessionAPIError && err.serverMessage !== undefined
-              ? `Couldn't open a terminal: ${err.serverMessage}`
-              : "Couldn't open a terminal",
+              ? `Could not open a terminal. ${err.serverMessage}`
+              : "Could not open a terminal",
           );
           return;
         }
@@ -2601,7 +2573,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
             await api.close(id);
           } catch {
             if (!tornDown()) {
-              ctx.toast("Couldn't close the terminal on the server");
+              ctx.toast("Could not close the terminal on the server");
             }
           }
         }
@@ -2683,7 +2655,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
             await api.close(t.id);
           } catch {
             if (!tornDown()) {
-              ctx.toast("Couldn't close a terminal on the server");
+              ctx.toast("Could not close a terminal on the server");
             }
           }
         }
@@ -2729,7 +2701,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           el.focus();
           return;
         }
-        if (physicalKeyboardLikely()) {
+        if (ctx.shell.keyboard.likely()) {
           focusInput();
         }
       }
@@ -2801,7 +2773,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
             }
             cur.pinnedTitle = before;
             syncChrome();
-            ctx.toast("Couldn't save the terminal name");
+            ctx.toast("Could not save the terminal name");
           })
           .finally(() => {
             const left = (namesInFlight.get(id) ?? 0) - 1;
@@ -3374,14 +3346,6 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         });
       }
 
-      // A hardware-only key latches sawHardwareKey, which upgrades focus-on-switch
-      // for a keyboard folio with no trackpad.
-      ctx.registerKeydown((ev) => {
-        if (!sawHardwareKey && looksLikeHardwareKey(ev)) {
-          sawHardwareKey = true;
-        }
-        return false;
-      });
       bar.addEventListener("dragover", (e) => {
         if (!draggingEl) {
           return;
@@ -4220,8 +4184,8 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
             // can retry, as the runtime create() does.
             ctx.toast(
               err instanceof SessionAPIError && err.serverMessage !== undefined
-                ? `Couldn't open a terminal: ${err.serverMessage}`
-                : "Couldn't open a terminal",
+                ? `Could not open a terminal. ${err.serverMessage}`
+                : "Could not open a terminal",
             );
           }
         }

package/src/features/tabs/model.ts

@@ -167,10 +167,9 @@ export function tabAccessibleName(v: {
 }): string {
   const state = statusPhrase(v.status);
   const progress = v.progress ?? PROGRESS_ABSENT;
-  const head =
-    progress < 0 ? `${v.label} — ${state}` : `${v.label} — ${state}, ${String(progress)}%`;
+  const head = progress < 0 ? `${v.label}, ${state}` : `${v.label}, ${state}, ${String(progress)}%`;
   const activity = activityPhrase(v.activity ?? "", v.activityCount ?? 0);
-  return activity === "" ? head : `${head} (${activity})`;
+  return activity === "" ? head : `${head}, ${activity}`;
 }
 
 // One-time "swipe to switch" hint, remembered across loads.

package/src/index.ts

@@ -17,6 +17,7 @@ export type {
   PaneSide,
   PaneHandle,
   ShellContext,
+  KeyboardPresence,
   AttentionOptions,
   AttentionState,
   AttentionReporter,

package/src/kernel/keyboard-presence.ts

@@ -0,0 +1,112 @@
+// No web API reports a hardware keyboard, so the shell infers one from the keys
+// it sees and keeps that inference in one place for every pane and feature.
+
+import type { KeyboardPresence } from "./types.js";
+
+/** An on-screen keyboard at least this tall is docked; the hardware-keyboard
+ *  shortcut bar iPadOS shows is well under it. */
+const SOFT_KEYBOARD_MIN_PX = 150;
+
+/** Whether the PRIMARY pointer is fine. False on every iPad and iPhone whatever
+ *  is attached, true on a desktop (`pointerCharacteristicsOfPrimaryPointingDevice`,
+ *  https://github.com/WebKit/WebKit/blob/main/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm). */
+export function primaryPointerFine(win: Window): boolean {
+  return typeof win.matchMedia === "function" && win.matchMedia("(pointer: fine)").matches;
+}
+
+/** Whether a mouse or trackpad is attached; a Pencil never answers it, unlike
+ *  `any-pointer: fine` (`hoverSupportedByAnyAvailablePointingDevice`, same file). */
+function accessoryMouse(win: Window): boolean {
+  return typeof win.matchMedia === "function" && win.matchMedia("(any-hover: hover)").matches;
+}
+
+export interface KeyboardPresenceTracker extends KeyboardPresence {
+  /** Whether the visual-viewport keyboard inset is to be ignored. */
+  insetSuppressed(): boolean;
+  noteKeydown(ev: KeyboardEvent): void;
+  noteSoftKeyboard(heightPx: number, editableFocused: boolean): void;
+}
+
+export interface KeyboardPresenceOptions {
+  readonly win: Window & typeof globalThis;
+  /** Never the suppressed inset: the suppression itself reads this tracker. */
+  readonly softKeyboardHeight: () => number;
+}
+
+/** A key that is not text: a modifier chord, navigation, Escape, Tab or a
+ *  function key. An on-screen keyboard can send some of these too (Android's
+ *  `InputConnection.sendKeyEvent`, https://developer.android.com/reference/android/view/inputmethod/InputConnection#sendKeyEvent(android.view.KeyEvent)),
+ *  which the empty `code`, the height gate and `isOnScreenTab` answer. */
+function looksLikeHardwareKey(ev: KeyboardEvent): boolean {
+  if (ev.ctrlKey || ev.metaKey || ev.altKey) {
+    return true;
+  }
+  switch (ev.key) {
+    case "ArrowUp":
+    case "ArrowDown":
+    case "ArrowLeft":
+    case "ArrowRight":
+    case "Escape":
+    case "Tab":
+    case "Home":
+    case "End":
+    case "PageUp":
+    case "PageDown":
+      return true;
+    default:
+      return /^F\d{1,2}$/.test(ev.key);
+  }
+}
+
+/** An unmodified Tab: the one hardware-only key on the iPad's full on-screen
+ *  keyboard, which reports no inset while undocked or split (`_keyboardChangedWithInfo:`,
+ *  https://github.com/WebKit/WebKit/blob/main/Source/WebKit/UIProcess/API/ios/WKWebViewIOS.mm).
+ *  Its code cannot tell: WebKit derives a soft key's code from its character
+ *  (`initWithKeyEventType:`, https://github.com/WebKit/WebKit/blob/main/Source/WebCore/platform/ios/WebEvent.mm). */
+function isOnScreenTab(ev: KeyboardEvent): boolean {
+  return ev.key === "Tab" && !ev.ctrlKey && !ev.metaKey && !ev.altKey;
+}
+
+export function createKeyboardPresence(opts: KeyboardPresenceOptions): KeyboardPresenceTracker {
+  const { win } = opts;
+  let seen = false;
+  const isEditable = (target: EventTarget | null): boolean =>
+    target instanceof win.HTMLElement &&
+    (target.isContentEditable ||
+      target instanceof win.HTMLInputElement ||
+      target instanceof win.HTMLTextAreaElement);
+  return {
+    hardwareSeen: () => seen,
+    likely: () => seen || primaryPointerFine(win),
+    // createKeyboardInsets owns the phantom iPad inset this defends against; it
+    // comes with a Magic Keyboard, whose trackpad any-hover sees.
+    insetSuppressed: () => seen || primaryPointerFine(win) || accessoryMouse(win),
+    noteKeydown(ev) {
+      // An on-screen key has no physical key, so Chromium Android leaves `code`
+      // empty (it fills it from the scan code alone:
+      // https://chromium.googlesource.com/chromium/src/+/main/components/input/web_input_event_builders_android.cc),
+      // and any such key clears a latch. A keyboard app that stamps a real scan
+      // code on its own arrow can latch until its next letter. WebKit never
+      // reports an empty code (`codeForKeyEvent`,
+      // https://github.com/WebKit/WebKit/blob/main/Source/WebCore/platform/ios/PlatformEventFactoryIOS.mm),
+      // so on iOS "Unidentified", the height gate and the Tab rule below decide.
+      if (ev.code === "" || ev.key === "Unidentified") {
+        seen = false;
+        return;
+      }
+      if (
+        looksLikeHardwareKey(ev) &&
+        (!isEditable(ev.target) ||
+          (opts.softKeyboardHeight() < SOFT_KEYBOARD_MIN_PX && !isOnScreenTab(ev)))
+      ) {
+        seen = true;
+      }
+    },
+    noteSoftKeyboard(heightPx, editableFocused) {
+      // With a mouse or trackpad attached the reading may be that phantom.
+      if (heightPx >= SOFT_KEYBOARD_MIN_PX && editableFocused && !accessoryMouse(win)) {
+        seen = false;
+      }
+    },
+  };
+}

package/src/kernel/loading-status.ts

@@ -19,10 +19,10 @@ export interface LoadingMessages {
 export const DEFAULT_LOADING_MESSAGES: LoadingMessages = {
   initial: "Loading terminal…",
   waiting: [
-    "Still working — this can take a while on first start.",
-    "Still working — preparing the environment.",
-    "Still working — almost there.",
-    "Still working — thanks for your patience.",
+    "Still working. This can take a while on first start.",
+    "Still working, preparing the environment.",
+    "Still working, almost there.",
+    "Still working, thanks for your patience.",
   ],
 };
 

package/src/kernel/pane.ts

@@ -14,6 +14,7 @@ import { createRegions } from "./regions.js";
 import { createAnnouncer, createPaneTablist, type PaneTablist } from "./a11y.js";
 import { createConnState } from "./conn-state.js";
 import { selectionTextWithin } from "./selection.js";
+import { primaryPointerFine } from "./keyboard-presence.js";
 import { windowOf } from "./realm.js";
 import {
   createCleanupScope,
@@ -23,6 +24,7 @@ import {
 } from "./feature-host.js";
 import type {
   CreateTerminalOptions,
+  KeyboardPresence,
   PaneHandle,
   PaneSide,
   SessionRef,
@@ -148,6 +150,9 @@ export interface PaneServices {
   /** The document's keyboard geometry, published on the shell root, which this
    *  pane's root inherits rather than publishes. */
   readonly keyboardInsets: KeyboardInsets;
+  readonly keyboard: KeyboardPresence;
+  /** The document's last press landed inside the shell root. */
+  pressedInsideShell(): boolean;
   /** This pane's base title (the served `<title>`, or its program's OSC 0/2). */
   titleBase(text: string): void;
   readonly loading: PaneLoading;
@@ -226,13 +231,6 @@ export interface PaneKernel extends PaneHandle {
   destroy(): void;
 }
 
-/** Whether `win` has a fine pointer, and with it a hardware keyboard. Read as
- *  `any-pointer: fine` rather than from pointerType because iPadOS reports a
- *  COARSE primary pointer even with a trackpad attached. */
-export function hasFinePointer(win: Window): boolean {
-  return typeof win.matchMedia === "function" && win.matchMedia("(any-pointer: fine)").matches;
-}
-
 /** The consumer's theme as custom properties on `root`, so the whole subtree
  *  inherits them over the token defaults of css/00-tokens.css. */
 export function applyTheme(root: HTMLElement, theme: CreateTerminalOptions["theme"]): void {
@@ -808,12 +806,49 @@ function buildPaneInto(
   let pointerDownX = 0;
   let pointerDownY = 0;
   let pointerDownTime = 0;
+  let pressMadeSelection = false;
+  const ownsSelection = (): boolean => selectionTextWithin(outputEl) !== "";
   function focusTerminal(): void {
     if (destroyed) {
       return;
     }
     input.focus({ preventScroll: true });
   }
+  /** A gesture's focus, never over a selection: iOS refuses every selection
+   *  gesture outside a focused editable (`textInteractionGesture:shouldBeginAtPoint:`,
+   *  https://github.com/WebKit/WebKit/blob/main/Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm). */
+  function focusFromGesture(): void {
+    if (pressMadeSelection || ownsSelection()) {
+      return;
+    }
+    focusTerminal();
+  }
+  // At the PRESS, not the tap: WebKit decides about 500ms into a long-press
+  // whether it may select (focusFromGesture), and the input must be gone by then.
+  function releaseFocusOnPress(e: PointerEvent): void {
+    if (!services.keyboard.hardwareSeen() || doc.activeElement !== input) {
+      return;
+    }
+    if (e.pointerType !== "touch" && primaryPointerFine(win)) {
+      return;
+    }
+    if (!(e.target instanceof win.Node) || !outputEl.contains(e.target)) {
+      return;
+    }
+    if (isLinkTarget(win, e.target)) {
+      return;
+    }
+    input.blur();
+  }
+  doc.addEventListener(
+    "selectionchange",
+    () => {
+      if (pressHoldsFocus && ownsSelection()) {
+        pressMadeSelection = true;
+      }
+    },
+    { signal },
+  );
   // A passive listener on the pane root: a touch that starts a native selection
   // never focuses the textarea, so focus alone would leave the touched pane
   // unselected.
@@ -832,6 +867,8 @@ function buildPaneInto(
       pointerDownY = e.clientY;
       pointerDownTime = e.timeStamp;
       pressHoldsFocus = true;
+      pressMadeSelection = false;
+      releaseFocusOnPress(e);
     },
     { passive: true, signal },
   );
@@ -841,7 +878,9 @@ function buildPaneInto(
   termWrap.addEventListener(
     "pointerup",
     (e) => {
-      if (e.pointerType !== "touch") {
+      // With a hardware keyboard seen, a tap is the platform's: the press already
+      // released focus, and the uncancelled mousedown lets it deselect natively.
+      if (e.pointerType !== "touch" || services.keyboard.hardwareSeen()) {
         return;
       }
       if (isLinkTarget(win, e.target)) {
@@ -856,19 +895,15 @@ function buildPaneInto(
       if (e.timeStamp - pointerDownTime > TAP_MAX_MS) {
         return;
       }
-      // A clean tap while text is selected means "done selecting": iOS otherwise
-      // leaves the selection stuck, because the synthetic mousedown cancelled
-      // below also suppresses the platform's own tap-to-deselect. A deselect tap
-      // must not pop the soft keyboard, unless a hardware keyboard is present.
+      // A clean tap while text is selected means "done selecting": the synthetic
+      // mousedown cancelled below also suppresses iOS's own tap-to-deselect. It
+      // does not pop the soft keyboard.
       const sel = doc.getSelection();
       if (sel && !sel.isCollapsed) {
         sel.removeAllRanges();
-        if (hasFinePointer(win)) {
-          focusTerminal();
-        }
         return;
       }
-      focusTerminal();
+      focusFromGesture();
     },
     { passive: true, signal },
   );
@@ -876,10 +911,10 @@ function buildPaneInto(
     "mousedown",
     (e) => {
       if (lastPointerType === "touch") {
-        // Cancel the synthetic mousedown after a touch tap so iOS keeps the
-        // keyboard up, except with a fine pointer, where suppressing it defeated
-        // the native focus.
-        if (!hasFinePointer(win)) {
+        // Cancelling the synthetic mousedown after a tap keeps the soft keyboard
+        // up. With a hardware keyboard likely there is none to keep, and the
+        // uncancelled default is what moves focus off the textarea.
+        if (!services.keyboard.likely()) {
           e.preventDefault();
         }
         return;
@@ -908,23 +943,30 @@ function buildPaneInto(
         win.open(link.href, "_blank", "noopener,noreferrer");
         return;
       }
-      if (lastPointerType === "touch" && !hasFinePointer(win)) {
+      // A touch's synthetic click: the pointerup handler owned that gesture.
+      if (lastPointerType === "touch") {
+        return;
+      }
+      // An iPad trackpad click releases focus as a tap does once a hardware
+      // keyboard is seen; a desktop mouse keeps click-to-focus.
+      if (services.keyboard.hardwareSeen() && !primaryPointerFine(win)) {
         return;
       }
       const sel = doc.getSelection();
       if (sel && sel.toString().length > 0) {
         return;
       }
-      focusTerminal();
+      focusFromGesture();
     },
     { signal },
   );
 
-  // A mouse gesture over `.term-output` leaves focus on the body, so typing
-  // silently does nothing (and the two shortcuts on the keydown chain with it).
-  // Focusing on the press would collapse the selection, so the browser's model
+  const keysUnclaimed = (): boolean =>
+    (doc.getSelection()?.toString() ?? "") === "" &&
+    services.shell.selected() === services.side &&
+    services.pressedInsideShell();
+  // Focusing on the press would collapse a selection, so the browser's model
   // stands and typing takes the keyboard back, as Windows Terminal does.
-  const ownsSelection = (): boolean => selectionTextWithin(outputEl) !== "";
   doc.addEventListener(
     "keydown",
     (ev: KeyboardEvent) => {
@@ -945,7 +987,7 @@ function buildPaneInto(
       if (composition.isComposing()) {
         return;
       }
-      if (!ownsSelection()) {
+      if (!ownsSelection() && !keysUnclaimed()) {
         return;
       }
       // Features while the selection is STILL INTACT and before the modifier
@@ -953,6 +995,24 @@ function buildPaneInto(
       if (runKeydownChain(ev)) {
         return;
       }
+      // Composition happens only in a focused editable (a body target gets no
+      // beforeinput or input, `_tryToHandlePressesEvent:` in
+      // https://github.com/WebKit/WebKit/blob/main/Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm),
+      // so a dead key or an IME takes focus and passes through, ahead of the
+      // modifier gate that would keep Option+e.
+      if (
+        ev.key === "Dead" ||
+        ev.key === "Process" ||
+        ev.isComposing ||
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- the only carrier of the IME-commit fact; see IME_COMMIT_KEYCODE
+        ev.keyCode === IME_COMMIT_KEYCODE
+      ) {
+        if (ownsSelection()) {
+          doc.getSelection()?.removeAllRanges();
+        }
+        focusTerminal();
+        return;
+      }
       // Decided before taking focus, because a bare modifier press (Shift on its
       // way to Shift+click) must leave the selection alone. Computed only for an
       // "ignore", so the encoder always wins a key it maps.
@@ -980,7 +1040,9 @@ function buildPaneInto(
       }
       if (char !== null) {
         // No `input` event is coming for a key that targeted the body, so send it
-        // here; preventDefault makes that exactly once BY SPEC.
+        // here. Cancelling the keydown cancels its insertion
+        // (https://w3c.github.io/uievents/#event-type-keydown), which Chromium
+        // would otherwise route into the textarea just focused: one copy, not two.
         ev.preventDefault();
         sendText(normalizeTypedText(char));
         return;
@@ -1143,7 +1205,7 @@ function buildPaneInto(
           engine.connection.reconnectNow();
         }
         if (services.shell.selected() === services.side) {
-          focusTerminal();
+          focusFromGesture();
         }
         return;
       }
@@ -1158,7 +1220,7 @@ function buildPaneInto(
         engine.connection.reconnectNow();
       }
       if (services.shell.selected() === services.side) {
-        focusTerminal();
+        focusFromGesture();
       }
     },
     { signal },