[Init] Initial commit - NetMesh terminal manager

components/terminal/TerminalView.test.tsx

@@ -0,0 +1,733 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+  formatTerminalHostInfoBarTitle,
+  formatTerminalHostInfoBarTooltip,
+  formatTerminalTitleConnectionAddress,
+  focusTerminalFromDisconnectedNotice,
+  getLineTimestampToggleHostUpdate,
+  resolveNetworkDeviceTipRightInset,
+  resolveTerminalRightInset,
+  resolveTerminalTopOffsets,
+  shouldBlockTerminalReconnectForTarget,
+  shouldEnableStatusBarDisconnect,
+  shouldEnableStatusBarReconnect,
+  shouldReconnectTerminalOnEnterKey,
+  shouldShowSelectionAIOverlay,
+  shouldShowLineTimestampToolbarToggle,
+  shouldShowStatusBarConnectionControls,
+  TerminalDisconnectedNotice,
+  resolveTerminalDisconnectedNoticeMessage,
+} from "./TerminalView.tsx";
+
+test("terminal disconnected notice keeps the reason and reconnect hint on one compact row", () => {
+  const markup = renderToStaticMarkup(React.createElement(TerminalDisconnectedNotice, {
+    message: "Connection timed out.",
+    reconnectHint: "Press Enter to reconnect",
+    bottom: 4,
+    left: 4,
+    right: 4,
+  }));
+
+  assert.match(markup, /data-terminal-disconnected-notice="true"/);
+  assert.match(markup, /role="status"/);
+  assert.match(markup, /Connection timed out\./);
+  assert.match(markup, /Press Enter to reconnect/);
+  assert.match(markup, /h-7/);
+  assert.doesNotMatch(markup, /pointer-events-none/);
+});
+
+test("clicking the disconnected notice preserves terminal keyboard focus", () => {
+  let prevented = false;
+  let focused = false;
+
+  focusTerminalFromDisconnectedNotice(
+    { preventDefault: () => { prevented = true; } },
+    () => { focused = true; },
+  );
+
+  assert.equal(prevented, true);
+  assert.equal(focused, true);
+});
+
+test("automatic reconnect notice uses explicit lifecycle copy instead of a stale log line", () => {
+  assert.equal(
+    resolveTerminalDisconnectedNoticeMessage({
+      status: "connecting",
+      error: null,
+      reconnectMessage: "Auto reconnect attempt 2...",
+      disconnectedLabel: "Disconnected",
+    }),
+    "Auto reconnect attempt 2...",
+  );
+  assert.equal(
+    resolveTerminalDisconnectedNoticeMessage({
+      status: "disconnected",
+      error: "Connection timed out.",
+      reconnectMessage: "Waiting for host key confirmation",
+      disconnectedLabel: "Disconnected",
+    }),
+    "Connection timed out.",
+  );
+  assert.equal(
+    resolveTerminalDisconnectedNoticeMessage({
+      status: "disconnected",
+      error: "Connection timed out.",
+      reconnectMessage: "Reconnecting...",
+      disconnectedLabel: "Disconnected",
+      isReconnectActive: true,
+    }),
+    "Reconnecting...",
+  );
+});
+
+test("automatic reconnect switches to attempt copy before waking a hibernated terminal", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const startReconnect = source.indexOf('const startReconnect = async');
+  const updateNotice = source.indexOf('setReconnectNoticeMessage(reconnectAttemptMessage)', startReconnect);
+  const wakeHibernated = source.indexOf('if (!termRef.current && hibernatedRef.current)', startReconnect);
+
+  assert.ok(startReconnect >= 0);
+  assert.ok(updateNotice > startReconnect);
+  assert.ok(wakeHibernated > updateNotice);
+});
+
+test("hibernated manual reconnect can continue after its runtime wakes", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const startReconnect = source.indexOf("const startReconnect = async");
+  const markManualReconnect = source.indexOf(
+    'setManualReconnectActive(mode === "manual")',
+    startReconnect,
+  );
+  const initialGuard = source.slice(startReconnect, markManualReconnect);
+  const clearWakeInFlight = source.indexOf(
+    "reconnectWakeInFlightRef.current = false",
+    markManualReconnect,
+  );
+  const continueReconnect = source.indexOf("startReconnectRef.current?.(mode)", clearWakeInFlight);
+
+  assert.ok(startReconnect >= 0);
+  assert.ok(markManualReconnect > startReconnect);
+  assert.match(initialGuard, /reconnectPreparationTokenRef\.current !== null/);
+  assert.match(initialGuard, /reconnectWakeInFlightRef\.current/);
+  assert.doesNotMatch(initialGuard, /manualReconnectActive/);
+  assert.ok(clearWakeInFlight > markManualReconnect);
+  assert.ok(continueReconnect > clearWakeInFlight);
+});
+
+test("manual reconnect publishes preparation without starting the connection timeout", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const startReconnect = source.indexOf("const startReconnect = async");
+  const publishPreparation = source.indexOf(
+    "terminalReconnectRegistry.setActive(sessionId, true)",
+    startReconnect,
+  );
+  const cleanupSession = source.indexOf(
+    "await cleanupSession({ retainOwnership: true })",
+    startReconnect,
+  );
+  const restoreDisconnected = source.indexOf(
+    'updateStatus("disconnected")',
+    startReconnect,
+  );
+
+  assert.ok(startReconnect >= 0);
+  assert.ok(publishPreparation > startReconnect);
+  assert.ok(cleanupSession > publishPreparation);
+  assert.equal(
+    source.indexOf('if (mode === "manual") updateStatus("connecting")', startReconnect),
+    -1,
+  );
+  assert.ok(restoreDisconnected > startReconnect);
+  assert.ok(restoreDisconnected < cleanupSession);
+});
+
+test("programmatic input during hibernated reconnect does not clear reconnect presentation", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const scrollStart = source.indexOf("const scrollToBottomAfterProgrammaticInput");
+  const scrollEnd = source.indexOf("useEffect(() =>", scrollStart);
+  const scrollBody = source.slice(scrollStart, scrollEnd);
+
+  assert.notEqual(scrollStart, -1);
+  assert.notEqual(scrollEnd, -1);
+  assert.doesNotMatch(scrollBody, /manualReconnectActiveRef|setReconnectNoticeMessage/);
+});
+
+test("line timestamp toggle creates a persistent host update", () => {
+  const host = {
+    id: "host-1",
+    label: "Host",
+    showLineTimestamps: false,
+    theme: "default",
+  };
+
+  assert.deepEqual(getLineTimestampToggleHostUpdate(host), {
+    id: "host-1",
+    showLineTimestamps: true,
+  });
+  assert.deepEqual(getLineTimestampToggleHostUpdate({ ...host, showLineTimestamps: true }), {
+    id: "host-1",
+    showLineTimestamps: false,
+  });
+});
+
+test("line timestamp toolbar toggle is hidden when timestamps are unavailable", () => {
+  assert.equal(shouldShowLineTimestampToolbarToggle(false, () => {}), false);
+  assert.equal(shouldShowLineTimestampToolbarToggle(true, () => {}), true);
+  assert.equal(shouldShowLineTimestampToolbarToggle(undefined, () => {}), true);
+  assert.equal(shouldShowLineTimestampToolbarToggle(true, undefined), false);
+});
+
+test("selection AI overlay honors the visibility preference", () => {
+  const overlayPosition = { left: 120, top: 80 };
+  const addSelection = () => {};
+
+  assert.equal(
+    shouldShowSelectionAIOverlay({
+      hasSelection: true,
+      selectionOverlayPosition: overlayPosition,
+      onAddSelectionToAI: addSelection,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldShowSelectionAIOverlay({
+      hasSelection: true,
+      selectionOverlayPosition: overlayPosition,
+      onAddSelectionToAI: addSelection,
+      showSelectionAIAction: true,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldShowSelectionAIOverlay({
+      hasSelection: true,
+      selectionOverlayPosition: overlayPosition,
+      onAddSelectionToAI: addSelection,
+      showSelectionAIAction: false,
+    }),
+    false,
+  );
+});
+
+test("disconnected terminal reconnects on plain Enter when input is not claimed elsewhere", () => {
+  assert.equal(
+    shouldReconnectTerminalOnEnterKey({
+      key: "Enter",
+      status: "disconnected",
+      hasRetryHandler: true,
+      isComposeBarOpen: false,
+      needsAuth: false,
+      needsHostKeyVerification: false,
+      hasBlockingOverlay: false,
+    }),
+    true,
+  );
+});
+
+test("terminal enter reconnect ignores active controls and non-disconnected states", () => {
+  const base = {
+    key: "Enter",
+    status: "disconnected" as const,
+    hasRetryHandler: true,
+    isComposeBarOpen: false,
+    needsAuth: false,
+    needsHostKeyVerification: false,
+    hasBlockingOverlay: false,
+  };
+
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, status: "connected" }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, key: "a" }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, hasRetryHandler: false }), false);
+  // Open search must not globally suppress Enter reconnect / the hint (#2546).
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base }), true);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, isComposeBarOpen: true }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, needsAuth: true }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, needsHostKeyVerification: true }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, hasBlockingOverlay: true }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, isReconnectActive: true }), false);
+  assert.equal(shouldReconnectTerminalOnEnterKey({ ...base, altKey: true }), false);
+});
+
+test("terminal enter reconnect ignores interactive controls outside xterm only", () => {
+  assert.equal(
+    shouldBlockTerminalReconnectForTarget({
+      isWithinXterm: false,
+      hasInteractiveAncestor: true,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldBlockTerminalReconnectForTarget({
+      isWithinXterm: true,
+      hasInteractiveAncestor: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldBlockTerminalReconnectForTarget({
+      isWithinXterm: false,
+      hasInteractiveAncestor: false,
+    }),
+    false,
+  );
+  // An open terminal search input is interactive, but disconnected Enter must
+  // still reconnect rather than find-next (#2546).
+  assert.equal(
+    shouldBlockTerminalReconnectForTarget({
+      isWithinXterm: false,
+      hasInteractiveAncestor: true,
+      isTerminalSearchInput: true,
+    }),
+    false,
+  );
+});
+
+test("terminal title formats the connection address for remote sessions", () => {
+  assert.equal(
+    formatTerminalTitleConnectionAddress({
+      protocol: "ssh",
+      username: "root",
+      hostname: "10.1.2.34",
+      port: 2222,
+    }),
+    "root@10.1.2.34:2222",
+  );
+  assert.equal(formatTerminalTitleConnectionAddress({ protocol: "local", hostname: "localhost" }), null);
+  assert.equal(formatTerminalTitleConnectionAddress({
+    protocol: "plugin:com.example.transport.connection",
+    hostname: "com.example.transport.connection",
+    port: 22,
+  }), null);
+});
+
+test("host info bar title follows address or label mode", () => {
+  assert.equal(
+    formatTerminalHostInfoBarTitle({
+      serverName: "prod-web",
+      connectionAddress: "root@10.1.2.34:2222",
+      mode: "address",
+    }),
+    "root@10.1.2.34:2222",
+  );
+  assert.equal(
+    formatTerminalHostInfoBarTitle({
+      serverName: "prod-web",
+      connectionAddress: "root@10.1.2.34:2222",
+      mode: "label",
+    }),
+    "prod-web",
+  );
+  assert.equal(
+    formatTerminalHostInfoBarTitle({
+      serverName: "  prod-web  ",
+      connectionAddress: " root@10.1.2.34:2222 ",
+      mode: "label",
+    }),
+    "prod-web",
+  );
+  assert.equal(
+    formatTerminalHostInfoBarTitle({
+      serverName: "",
+      connectionAddress: "root@10.1.2.34:2222",
+      mode: "label",
+    }),
+    "root@10.1.2.34:2222",
+  );
+  assert.equal(
+    formatTerminalHostInfoBarTitle({
+      serverName: "Local Terminal",
+      connectionAddress: null,
+      mode: "address",
+    }),
+    "Local Terminal",
+  );
+  assert.equal(
+    formatTerminalHostInfoBarTooltip({
+      serverName: "prod-web",
+      connectionAddress: "root@10.1.2.34:2222",
+    }),
+    "prod-web · root@10.1.2.34:2222",
+  );
+});
+
+test("terminal title row does not render a status dot beside the address", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const titleStart = source.indexOf("data-terminal-detach-drag-handle");
+  const titleEnd = source.indexOf("shouldShowLineTimestampToolbarToggle", titleStart);
+  assert.notEqual(titleStart, -1);
+  assert.notEqual(titleEnd, -1);
+
+  assert.doesNotMatch(source.slice(titleStart, titleEnd), /statusDotTone/);
+});
+
+test("terminal title keeps the copy host action beside the address", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const titleStart = source.indexOf("data-terminal-detach-drag-handle");
+  const copyAction = source.indexOf('aria-label={t("terminal.statusbar.copyHostname.label")}', titleStart);
+  const timestampToggle = source.indexOf("shouldShowLineTimestampToolbarToggle", titleStart);
+
+  assert.notEqual(titleStart, -1);
+  assert.notEqual(copyAction, -1);
+  assert.notEqual(timestampToggle, -1);
+  assert.ok(copyAction < timestampToggle);
+});
+
+test("focus mode and temporary pane magnification use separate toolbar actions", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const focusAction = source.indexOf("onClick={onExpandToFocus}");
+  const magnifyAction = source.indexOf("onClick={onTogglePaneMagnification}");
+
+  assert.notEqual(focusAction, -1);
+  assert.notEqual(magnifyAction, -1);
+  assert.ok(focusAction < magnifyAction);
+  assert.match(source.slice(focusAction, magnifyAction), /terminal\.toolbar\.focusMode/);
+  assert.match(source.slice(magnifyAction), /terminal\.paneMagnification\.(restore|magnify)/);
+});
+
+test("popup terminals disable line timestamp controls", () => {
+  const source = readFileSync(new URL("../TerminalPopupPage.tsx", import.meta.url), "utf8");
+
+  assert.match(source, /lineTimestampsAvailable=\{false\}/);
+});
+
+test("terminal body keeps a slight inset from the surrounding chrome", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+
+  assert.match(source, /const terminalBodyInset = 4/);
+  assert.match(source, /left: activeLineTimestampGutterWidth \+ terminalBodyInset/);
+  assert.match(source, /right: terminalRightInset/);
+  assert.match(source, /const terminalBottomInset = terminalBodyInset \+ \(showDisconnectedTerminalNotice \? 28 : 0\)/);
+  assert.match(source, /bottom: terminalBottomInset/);
+  assert.match(source, /left=\{terminalBodyInset\}/);
+  assert.match(source, /bottom=\{terminalBottomInset\}/);
+});
+
+test("hidden host information bar gives its vertical space back to the terminal", () => {
+  assert.deepEqual(
+    resolveTerminalTopOffsets({ showHostInfoBar: false, isSearchOpen: false }),
+    { toolbarOffset: 0, contentTop: "4px" },
+  );
+  assert.deepEqual(
+    resolveTerminalTopOffsets({ showHostInfoBar: true, isSearchOpen: false }),
+    { toolbarOffset: 30, contentTop: "34px" },
+  );
+});
+
+test("terminal search keeps enough space when host information is hidden", () => {
+  assert.deepEqual(
+    resolveTerminalTopOffsets({ showHostInfoBar: false, isSearchOpen: true }),
+    { toolbarOffset: 64, contentTop: "68px" },
+  );
+});
+
+test("network device tip reserves extra top space below the toolbar", () => {
+  // Tip stacks below the toolbar: content shifts down by the tip height, but
+  // the toolbar offset itself is unchanged.
+  assert.deepEqual(
+    resolveTerminalTopOffsets({ showHostInfoBar: true, isSearchOpen: false, networkDeviceTipHeight: 28 }),
+    { toolbarOffset: 30, contentTop: "62px" },
+  );
+  assert.deepEqual(
+    resolveTerminalTopOffsets({ showHostInfoBar: false, isSearchOpen: false, networkDeviceTipHeight: 28 }),
+    { toolbarOffset: 0, contentTop: "32px" },
+  );
+});
+
+test("network device tip clears the compact speed-dial toggle only when it is present", () => {
+  // Speed dial only renders when host info is hidden and search is closed;
+  // reserve right-side room there so the tip cannot cover its click target.
+  assert.equal(resolveNetworkDeviceTipRightInset({ showHostInfoBar: false, isSearchOpen: false }), 40);
+  assert.equal(resolveNetworkDeviceTipRightInset({ showHostInfoBar: true, isSearchOpen: false }), 0);
+  assert.equal(resolveNetworkDeviceTipRightInset({ showHostInfoBar: false, isSearchOpen: true }), 0);
+});
+
+test("hidden host information does not reserve a side gutter for its floating action button", () => {
+  // Speed-dial overlays the terminal; scrollbar stays at the pane edge.
+  assert.equal(resolveTerminalRightInset({ showHostInfoBar: false, isSearchOpen: false }), 4);
+  assert.equal(resolveTerminalRightInset({ showHostInfoBar: true, isSearchOpen: false }), 4);
+  assert.equal(resolveTerminalRightInset({ showHostInfoBar: false, isSearchOpen: true }), 4);
+});
+
+test("hidden host information keeps terminal actions rendered", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const hostInfoStart = source.indexOf("{showHostInfoBar && <div");
+  const hostInfoEnd = source.indexOf("</div>}", hostInfoStart);
+  const copyAction = source.indexOf('aria-label={t("terminal.statusbar.copyHostname.label")}');
+  const timestampAction = source.indexOf("shouldShowLineTimestampToolbarToggle", copyAction);
+  const systemAction = source.indexOf('aria-label={t("terminal.layer.system")}', timestampAction);
+  const disconnectAction = source.indexOf('aria-label={t("terminal.statusbar.disconnect.label")}', systemAction);
+  const reconnectAction = source.indexOf('aria-label={t("terminal.statusbar.reconnect.label")}', disconnectAction);
+  const actionsStart = source.indexOf('className="flex items-center gap-0.5 flex-shrink-0"');
+  const controls = source.indexOf("{renderControls({ showClose: inWorkspace, restorePaneLayout: isPaneMagnified })}");
+  const compactDragHandle = source.indexOf('data-terminal-detach-drag-handle="true"');
+
+  assert.notEqual(hostInfoStart, -1);
+  assert.notEqual(hostInfoEnd, -1);
+  assert.notEqual(copyAction, -1);
+  assert.notEqual(timestampAction, -1);
+  assert.notEqual(systemAction, -1);
+  assert.notEqual(disconnectAction, -1);
+  assert.notEqual(reconnectAction, -1);
+  assert.notEqual(actionsStart, -1);
+  assert.notEqual(controls, -1);
+  assert.notEqual(compactDragHandle, -1);
+  // Compact drag handle uses GripVertical, not the old radial-dot “chessboard”.
+  assert.match(source, /GripVertical/);
+  assert.ok(!source.includes("backgroundSize: '4px 4px'"));
+  assert.ok(hostInfoStart < hostInfoEnd);
+  assert.ok(hostInfoEnd < copyAction);
+  assert.ok(copyAction < timestampAction);
+  assert.ok(timestampAction < systemAction);
+  assert.ok(systemAction < disconnectAction);
+  assert.ok(disconnectAction < reconnectAction);
+  assert.ok(reconnectAction < actionsStart);
+  assert.ok(actionsStart < controls);
+  assert.ok(compactDragHandle < hostInfoStart);
+});
+
+test("status bar disconnect stays enabled while connected or connecting", () => {
+  assert.equal(shouldEnableStatusBarDisconnect("connected"), true);
+  assert.equal(shouldEnableStatusBarDisconnect("connecting"), true);
+  assert.equal(shouldEnableStatusBarDisconnect("disconnected"), false);
+  assert.equal(shouldEnableStatusBarDisconnect(undefined), false);
+});
+
+test("status bar reconnect matches tab-menu reconnect gating", () => {
+  assert.equal(shouldEnableStatusBarReconnect("connected"), true);
+  assert.equal(shouldEnableStatusBarReconnect("disconnected"), true);
+  assert.equal(shouldEnableStatusBarReconnect("connecting"), false);
+  assert.equal(shouldEnableStatusBarReconnect(undefined), false);
+});
+
+test("status bar connection controls require an owned session surface", () => {
+  assert.equal(
+    shouldShowStatusBarConnectionControls({
+      showConnectionControls: true,
+      hasDisconnectHandler: true,
+      hasReconnectHandler: true,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldShowStatusBarConnectionControls({
+      showConnectionControls: false,
+      hasDisconnectHandler: true,
+      hasReconnectHandler: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldShowStatusBarConnectionControls({
+      showConnectionControls: true,
+      hasDisconnectHandler: false,
+      hasReconnectHandler: false,
+    }),
+    false,
+  );
+});
+
+test("manual disconnect keeps the session pane for reconnect", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const disconnectStart = source.indexOf("const handleDisconnect = () => {");
+  const disconnectEnd = source.indexOf("const handleDismissDisconnectedDialog", disconnectStart);
+  assert.notEqual(disconnectStart, -1);
+  assert.notEqual(disconnectEnd, -1);
+  const body = source.slice(disconnectStart, disconnectEnd);
+  assert.match(body, /clearAutoReconnect\(\{ stopLoop: true \}\)/);
+  assert.match(body, /reconnectWakeTokenRef\.current = null/);
+  assert.match(body, /reconnectWakeInFlightRef\.current = false/);
+  assert.match(body, /netcatty:terminal-session-disconnected/);
+  assert.match(body, /invalidateBootEpochForClose\(\)/);
+  assert.match(body, /isBootActiveRef\.current = false/);
+  assert.match(body, /setIsCancelling\(true\)/);
+  assert.match(body, /updateStatus\("disconnected"\)/);
+  assert.match(body, /void cleanupSession\(\{ retainOwnership: true \}\)/);
+  assert.match(source, /trackSessionCleanup/);
+  assert.doesNotMatch(body, /onCloseSession/);
+  assert.match(source, /handleDisconnect: \(attachExistingSession \|\| compactToolbar\) \? undefined : handleDisconnect/);
+  assert.match(source, /showConnectionControls: !attachExistingSession && !compactToolbar/);
+  assert.match(source, /setTerminalBootEpoch/);
+
+  const startersSource = readFileSync(
+    new URL("./runtime/createTerminalSessionStarters.ts", import.meta.url),
+    "utf8",
+  );
+  assert.match(startersSource, /createBootAttemptGuard\(ctx\)/);
+  assert.match(startersSource, /setTerminalBootEpoch\(ctx\.sessionId, bootEpoch\)/);
+
+  const effectsSource = readFileSync(new URL("./useTerminalEffects.ts", import.meta.url), "utf8");
+  assert.match(
+    effectsSource,
+    /!isBootActiveRef\.current[\s\S]*statusRef\.current === "disconnected"[\s\S]*bootEpochMismatch/,
+  );
+  assert.match(
+    effectsSource,
+    /respondHostKeyVerification\?\.\(request\.requestId, false\)/,
+  );
+  assert.match(effectsSource, /request\.bootEpoch/);
+  assert.match(
+    startersSource,
+    /if \(!isCurrentAttempt\(\)\) return;/,
+  );
+  assert.match(startersSource, /bootEpoch,/);
+});
+
+test("cancel connect invalidates the boot epoch like disconnect", () => {
+  const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const cancelStart = source.indexOf("const handleCancelConnect = () => {");
+  const cancelEnd = source.indexOf("const handleDisconnect = () => {", cancelStart);
+  assert.notEqual(cancelStart, -1);
+  assert.notEqual(cancelEnd, -1);
+  const body = source.slice(cancelStart, cancelEnd);
+
+  assert.match(body, /invalidateBootEpochForClose\(\)/);
+  assert.match(body, /isBootActiveRef\.current = false/);
+  // Both must land before cleanupSession so the close targets the pre-bump epoch.
+  assert.ok(
+    body.indexOf("invalidateBootEpochForClose()") < body.indexOf("void cleanupSession()"),
+    "cancel must invalidate the boot epoch before cleanupSession",
+  );
+  assert.ok(
+    body.indexOf("isBootActiveRef.current = false") < body.indexOf("void cleanupSession()"),
+    "cancel must clear boot-active before cleanupSession",
+  );
+});
+
+test("terminal boot is cancelable and closes eagerly on cleanup", () => {
+  const effectsSource = readFileSync(new URL("./useTerminalEffects.ts", import.meta.url), "utf8");
+  const startersSource = readFileSync(
+    new URL("./runtime/createTerminalSessionStarters.ts", import.meta.url),
+    "utf8",
+  );
+
+  assert.match(effectsSource, /const bootAbort = new AbortController\(\)/);
+  assert.match(effectsSource, /const bootStartOptions = \{ signal: bootAbort\.signal \}/);
+  assert.match(
+    effectsSource,
+    /queueMicrotask\(\(\) => \{\s*\n\s*if \(disposed\) return;\s*\n\s*void boot\(\);/,
+    "backend boot must defer past StrictMode's synchronous re-invoke",
+  );
+  for (const starter of [
+    "startPluginConnection",
+    "startSerial",
+    "startLocal",
+    "startTelnet",
+    "startMosh",
+    "startEt",
+    "startSSH",
+  ]) {
+    assert.match(
+      effectsSource,
+      new RegExp(`sessionStarters\\.${starter}\\(term, bootStartOptions\\)`),
+      `${starter} must receive the boot abort signal`,
+    );
+  }
+
+  // Cleanup order: abort, then eager close + sync dispose for never-connected
+  // boots (StrictMode remount), else the async capture/teardown path.
+  const cleanupStart = effectsSource.indexOf("      disposed = true;");
+  assert.notEqual(cleanupStart, -1);
+  const cleanup = effectsSource.slice(cleanupStart);
+  const abortAt = cleanup.indexOf("bootAbort.abort()");
+  const neverConnectedAt = cleanup.indexOf("if (!hasConnectedRef.current)");
+  assert.ok(abortAt !== -1 && neverConnectedAt !== -1);
+  assert.ok(abortAt < neverConnectedAt, "cleanup must abort before the never-connected close branch");
+  const neverConnectedBranch = cleanup.slice(
+    neverConnectedAt,
+    cleanup.indexOf("const persistCloseCapture", neverConnectedAt),
+  );
+  const closeAt = neverConnectedBranch.indexOf("terminalBackend.closeSession(");
+  const syncDisposeAt = neverConnectedBranch.indexOf("disposeOwnedRuntime();");
+  const earlyReturnAt = neverConnectedBranch.indexOf("return;");
+  assert.ok(closeAt !== -1 && syncDisposeAt !== -1 && earlyReturnAt !== -1);
+  assert.ok(closeAt < syncDisposeAt, "eager close must run before sync runtime dispose");
+  assert.ok(
+    syncDisposeAt < earlyReturnAt,
+    "never-connected boots must sync-dispose before leaving cleanup",
+  );
+  // Owner panes close the pending backend; attach popups only dispose xterm.
+  assert.match(neverConnectedBranch, /if \(!attachExistingSession\)/);
+  assert.match(effectsSource, /let ownedRuntime:/);
+  assert.match(
+    cleanup,
+    /void completeClose\(\)/,
+    "connected boots still use the async capture path",
+  );
+
+  // An aborted boot must stop counting as the current attempt so the existing
+  // orphan-close / attach-refusal guards cover cancellation too.
+  assert.match(
+    startersSource,
+    /options\?\.signal\?\.aborted !== true && isBootEpochCurrent\(\)/,
+  );
+  for (const starter of [
+    "startSSH",
+    "startTelnet",
+    "startMosh",
+    "startEt",
+    "startPluginConnection",
+    "startLocal",
+    "startSerial",
+  ]) {
+    assert.match(
+      startersSource,
+      new RegExp(
+        `const ${starter} = async \\(term: XTerm, options\\?: TerminalSessionStartOptions\\)`,
+      ),
+      `${starter} must accept an abort signal`,
+    );
+  }
+  // The plugin path holds its own in-flight request controller; the boot abort
+  // has to reach it or the extension request outlives the pane.
+  assert.match(startersSource, /options\?\.signal\?\.addEventListener\("abort", onBootAborted/);
+  assert.match(startersSource, /options\?\.signal\?\.removeEventListener\("abort", onBootAborted\)/);
+});
+
+test("hidden host information reveals actions without permanently covering terminal content", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+
+  assert.match(source, /aria-label=\{t\("terminal\.toolbar\.showActions"\)\}/);
+  assert.match(source, /aria-expanded=\{compactActionsOpen\}/);
+  assert.match(source, /aria-controls=\{`terminal-actions-\$\{sessionId\}`\}/);
+  assert.match(source, /id=\{`terminal-actions-\$\{sessionId\}`\}/);
+  assert.match(source, /onClick=\{\(\) => setCompactActionsOpen/);
+  assert.match(source, /right: terminalRightInset/);
+  // Compact mode is a circular speed-dial: tray springs left via 0fr→1fr grid
+  // (must not use .terminal-topbar — container-type collapses content width).
+  assert.match(source, /flex flex-row-reverse items-center/);
+  assert.match(source, /rounded-full/);
+  assert.match(source, /grid-cols-\[1fr\]/);
+  assert.match(source, /grid-cols-\[0fr\]/);
+  assert.match(source, /ChevronsLeft/);
+  assert.match(source, /h-7/);
+  assert.match(source, /Do NOT use `\.terminal-topbar`|container-type:inline-size|container-type collapses/);
+  assert.match(source, /document\.addEventListener\("pointerdown", handlePointerDown\)/);
+  assert.match(source, /closest\('\[data-radix-popper-content-wrapper\]'\)/);
+  assert.match(source, /event\.key !== "Escape"/);
+  assert.match(source, /compactActionsButtonRef\.current\?\.focus\(\)/);
+});
+
+test("compact action toggle preserves terminal focus like the visible toolbar", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const overlayStart = source.indexOf('ref={compactActionsRef}');
+  const toggleStart = source.indexOf('ref={compactActionsButtonRef}', overlayStart);
+
+  assert.notEqual(overlayStart, -1);
+  assert.notEqual(toggleStart, -1);
+  assert.ok(overlayStart < toggleStart);
+  assert.match(source.slice(overlayStart, toggleStart), /onMouseDownCapture=\{handleTopOverlayMouseDownCapture\}/);
+});
+
+test("terminal theme updates force xterm renderer to repaint immediately", () => {
+  const source = readFileSync(new URL("./useTerminalEffects.ts", import.meta.url), "utf8");
+  const schedulerSource = readFileSync(new URL("./terminalThemeScheduler.ts", import.meta.url), "utf8");
+
+  assert.match(source, /applyTerminalThemeSync\(term, effectiveTheme\)/);
+  assert.match(schedulerSource, /term\.options\.theme = \{/);
+  assert.match(schedulerSource, /forceSyncRenderAfterResize\(term\)/);
+});