tmux-ide 2.9.2 → 2.9.3

package/packages/daemon/dist/tui/mirror/runtime/application-machine-startup.js

@@ -1,8 +1,9 @@
 import { resolveRuntimeNamespace } from "../../../lib/runtime-namespace.js";
 import { randomUUID } from "node:crypto";
 import { SavedMachineSchema } from "@tmux-ide/contracts";
-import { loadSavedMachines } from "../../../lib/saved-machines.js";
+import { loadSavedMachines, watchSavedMachines } from "../../../lib/saved-machines.js";
 import { applicationMachineAuthorityManager } from "./application-machine-authority.js";
+import { tuiPerfMark } from "./application-performance-log.js";
 /** Labels describe access routes; they never become routing identities. */
 export function ephemeralMachineProfile(alias, existing) {
     const target = SavedMachineSchema.shape.sshTarget.parse(alias);
@@ -20,17 +21,45 @@ export function ephemeralMachineProfile(alias, existing) {
 }
 /** Local discovery and rendering never wait for any remote handshake. */
 export function initializeApplicationMachines(aliases) {
-    const profiles = resolveRuntimeNamespace().development ? [] : [...loadSavedMachines().machines];
+    const development = resolveRuntimeNamespace().development;
+    const profiles = development ? [] : [...loadSavedMachines().machines];
+    const ephemeral = [];
     let preferred = null;
     for (const alias of aliases) {
         let profile = profiles.find((p) => p.sshTarget === alias && p.enabled);
         if (!profile) {
             profile = ephemeralMachineProfile(alias, profiles);
             profiles.push(profile);
+            ephemeral.push(profile);
         }
         preferred ??= profile.id;
     }
     applicationMachineAuthorityManager.initialize(profiles);
     if (preferred)
         applicationMachineAuthorityManager.select(preferred);
+    if (!development) {
+        const failed = () => tuiPerfMark("machine-registry-error", { reason: "registry-unavailable-or-invalid" });
+        try {
+            applicationMachineAuthorityManager.followProfiles((onChange) => watchSavedMachines((registry) => {
+                const next = [...registry.machines];
+                for (let index = 0; index < ephemeral.length; index++) {
+                    let profile = ephemeral[index];
+                    // A newly saved route may claim an ephemeral display label. Keep the
+                    // explicit connection's identity while making the label unambiguous.
+                    if (next.some((entry) => entry.label.normalize("NFKC").toLowerCase() ===
+                        profile.label.normalize("NFKC").toLowerCase()))
+                        profile = {
+                            ...profile,
+                            label: ephemeralMachineProfile(profile.sshTarget, next).label,
+                        };
+                    ephemeral[index] = profile;
+                    next.push(profile);
+                }
+                onChange(next);
+            }, failed));
+        }
+        catch {
+            failed();
+        }
+    }
 }

package/packages/daemon/dist/tui/mirror/runtime/application-palette-search-owner.js

@@ -1,4 +1,4 @@
-import { createMemo, createSignal } from "solid-js";
+import { createMemo, createSignal, untrack } from "solid-js";
 import { applicationCommandDescription, filterApplicationCommands, } from "../workspace/application-command-description.js";
 import { applicationPaletteKeyboardDisposition, } from "./application-palette-input.js";
 import { applicationPaneRenameKeyAction, applicationPaneRenamePaste, } from "./application-pane-rename-input.js";
@@ -11,9 +11,13 @@ export function createApplicationPaletteSearchOwner(options) {
     const [help, setHelp] = createSignal(false);
     const [query, setQuery] = createSignal("");
     const [selectedId, setSelectedId] = createSignal(null);
-    const commands = createMemo(() => filterApplicationCommands(options
+    const readCommands = () => filterApplicationCommands(options
         .commands()
-        .filter((c) => !localOnly() || typeof c === "string" || !c.fleet || c.fleet.machineId === "local"), query()));
+        .filter((c) => !localOnly() || typeof c === "string" || !c.fleet || c.fleet.machineId === "local"), query());
+    // Closed overlays must not subscribe to catalog churn. Explicit reads still
+    // resolve current commands, including reset() before the open action commits.
+    const activeCommands = createMemo(() => (options.open() ? readCommands() : null));
+    const commands = () => activeCommands() ?? untrack(readCommands);
     const selection = () => Math.max(0, commands().findIndex((command) => applicationCommandDescription(command).id === selectedId()));
     const select = (index) => {
         const command = commands()[index];

package/packages/daemon/dist/tui/mirror/runtime/application-performance-log.js

@@ -29,6 +29,8 @@ stream?.on("drain", drain);
 export const tuiLifecycleStream = stream ? Object.freeze({ enabled: true }) : null;
 export const tuiPerfStream = TUI_PERF_LOG ? tuiLifecycleStream : null;
 const LIFECYCLE_PHASES = new Set([
+    "machine-connection-status",
+    "machine-registry-error",
     "generation-status",
     "generation-connection-start",
     "generation-connection-resolved",
@@ -132,6 +134,7 @@ export function closeTuiPerfMarks() {
     closePromise = (async () => {
         if (!stream)
             return;
+        await writer?.flush();
         await flushTuiPerfMarks();
         // No drain callback may enqueue another critical record after end().
         stream.off("drain", drain);

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-input-ingress.js

@@ -7,6 +7,133 @@ import { terminalInputForOpenTuiKey, terminalInputsForPaste, } from "./terminal-
 export function createApplicationTerminalInputIngress(interaction, generation, sessionOwner, focusedPane, setNote) {
     const pending = createApplicationPendingTerminalInputOwner();
     let ownsNote = false;
+    let recovery = null;
+    const scope = () => {
+        const active = generation();
+        const owner = sessionOwner();
+        const pane = focusedPane();
+        const session = owner?.sessionName();
+        if (!active ||
+            !["live", "rebinding"].includes(active.status) ||
+            !active.connection ||
+            !active.client ||
+            !active.daemonGeneration ||
+            !owner ||
+            !session ||
+            !pane)
+            return null;
+        try {
+            const clientGeneration = active.client.getSnapshot().generation;
+            if (!Number.isSafeInteger(clientGeneration))
+                return null;
+            return {
+                owner,
+                connection: active.connection,
+                client: active.client,
+                daemon: active.daemonGeneration,
+                clientGeneration: clientGeneration,
+                session: session,
+                pane,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const sameScope = (left, right) => right !== null &&
+        left.owner === right.owner &&
+        left.connection === right.connection &&
+        left.client === right.client &&
+        left.daemon === right.daemon &&
+        left.clientGeneration === right.clientGeneration &&
+        left.session === right.session &&
+        left.pane === right.pane;
+    let recoveryVersion = 0;
+    const cancelRecovery = () => {
+        recoveryVersion++;
+        if (recovery)
+            clearTimeout(recovery.timer);
+        recovery = null;
+    };
+    const recover = (inputs, bytes, kind) => {
+        if (pending.snapshot().sessionName !== null ||
+            (!recovery && generation()?.status !== "rebinding"))
+            return false;
+        const target = scope();
+        if (!target)
+            return false;
+        if (recovery && !sameScope(recovery.scope, target))
+            cancelRecovery();
+        if (!recovery) {
+            const timer = setTimeout(() => {
+                cancelRecovery();
+                setNote("terminal recovery timed out · queued input was not sent");
+            }, 5_000);
+            timer.unref?.();
+            recovery = { scope: target, inputs: [], weight: 0, admitted: 0, draining: false, timer };
+        }
+        const weight = bytes.byteLength;
+        if (recovery.admitted >= 64 || recovery.weight + weight > 1024 * 1024) {
+            setNote("terminal input queue full · wait for the session to connect");
+            return true;
+        }
+        recovery.weight += weight;
+        recovery.admitted++;
+        const version = recoveryVersion;
+        const parserOrigin = captureOrigin()
+            ? {
+                origin: kind === "paste" ? "bracketed-paste" : "keyboard",
+                payload: Buffer.from(bytes),
+            }
+            : undefined;
+        recovery.inputs.push(async () => {
+            for (const [index, input] of inputs.entries()) {
+                if (version !== recoveryVersion ||
+                    !sameScope(target, scope()) ||
+                    generation()?.status !== "live" ||
+                    !(await interaction.sendInputToPane(target.pane, input, index === 0 ? parserOrigin : undefined)))
+                    return false;
+            }
+            return true;
+        });
+        setNote(`${target.session} · terminal ${kind} queued`);
+        return true;
+    };
+    const flushRecovery = () => {
+        const waiting = recovery;
+        if (!waiting || waiting.draining)
+            return;
+        if (!sameScope(waiting.scope, scope())) {
+            cancelRecovery();
+            setNote("terminal changed · queued input was not sent");
+            return;
+        }
+        if (generation()?.status !== "live" || !generation()?.fastLane)
+            return;
+        waiting.draining = true;
+        const version = recoveryVersion;
+        void (async () => {
+            while (version === recoveryVersion && waiting.inputs.length > 0) {
+                const send = waiting.inputs.shift();
+                try {
+                    if (await send())
+                        continue;
+                }
+                catch {
+                    /* An uncertain send is never retried. */
+                }
+                if (version !== recoveryVersion)
+                    return;
+                cancelRecovery();
+                setNote("terminal unavailable · queued input was not sent");
+                return;
+            }
+            if (version === recoveryVersion) {
+                cancelRecovery();
+                setNote(null);
+            }
+        })();
+    };
     const captureOrigin = () => Boolean(currentTuiPerformanceEventSink()?.terminalInputOrigin);
     const flush = () => {
         const owner = sessionOwner();
@@ -36,9 +163,14 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
         else
             setNote(`terminal unavailable · ${kind} was not sent`);
     };
+    const cancelInteractionInput = () => {
+        cancelRecovery();
+        interaction.cancelPendingInput();
+    };
     return {
         wrapStarter(starter) {
             const start = async (...args) => {
+                cancelInteractionInput();
                 const [sessionName] = args;
                 const identity = pending.begin(sessionName);
                 const result = await starter(...args);
@@ -52,24 +184,32 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             };
             return Object.assign(start, {
                 cancel() {
+                    cancelInteractionInput();
                     pending.dispose();
                     starter.cancel();
                 },
             });
         },
-        adopt() {
+        adopt(terminalsActive = true) {
+            if (!terminalsActive)
+                cancelInteractionInput();
             flush();
+            flushRecovery();
         },
         routeKey(event) {
             const active = generation();
             if (pending.snapshot().sessionName === null &&
+                recovery === null &&
                 active?.status === "live" &&
                 active.fastLane &&
                 focusedPane()) {
                 sendApplicationTerminalKey(interaction, event, captureOrigin());
                 return;
             }
-            if (!terminalInputForOpenTuiKey(event))
+            const recoveryInput = terminalInputForOpenTuiKey(event);
+            if (!recoveryInput)
+                return;
+            if (recover([recoveryInput], Buffer.from(recoveryInput.data, "utf8"), "input"))
                 return;
             const copy = { name: event.name, ctrl: event.ctrl, meta: event.meta, shift: event.shift };
             noteAdmission(pending.enqueue(() => sendApplicationTerminalKey(interaction, copy, captureOrigin()), Buffer.byteLength(event.name, "utf8")), "input");
@@ -87,15 +227,19 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             }
             const active = generation();
             if (pending.snapshot().sessionName === null &&
+                recovery === null &&
                 active?.status === "live" &&
                 active.fastLane &&
                 focusedPane()) {
                 sendApplicationTerminalPaste(interaction, copy, captureOrigin());
                 return;
             }
+            if (recover(terminalInputsForPaste(Buffer.from(copy).toString("utf8")), copy, "paste"))
+                return;
             noteAdmission(pending.enqueue(() => sendApplicationTerminalPaste(interaction, copy, captureOrigin()), copy.byteLength), "paste");
         },
         dispose() {
+            cancelInteractionInput();
             pending.dispose();
         },
     };

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-interaction-controller.js

@@ -84,6 +84,64 @@ export function createApplicationTerminalInteractionController(options) {
     let diagnosticWindowFrame = null;
     let diagnosticWindowFrameExpiresAtMicros = 0;
     let inputAuthorityIdentity = null;
+    // Pane selection belongs to the control connection, which can outlive a
+    // terminal renderer rebuild. Never carry selection or input across reconnects.
+    const controlIdentity = (snapshot) => {
+        if (!snapshot ||
+            !["live", "rebinding"].includes(snapshot.status) ||
+            !snapshot.connection ||
+            !snapshot.client ||
+            !snapshot.daemonGeneration)
+            return null;
+        try {
+            const generation = snapshot.client.getSnapshot().generation;
+            if (!Number.isSafeInteger(generation))
+                return null;
+            return {
+                connection: snapshot.connection,
+                client: snapshot.client,
+                daemon: snapshot.daemonGeneration,
+                generation,
+                workspace: snapshot.connection.workspaceName,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const sameControl = (left, right) => left !== null &&
+        right !== null &&
+        left.connection === right.connection &&
+        left.client === right.client &&
+        left.daemon === right.daemon &&
+        left.generation === right.generation &&
+        left.workspace === right.workspace;
+    let selectedControl = null;
+    const waitingInput = new Set();
+    let waitingInputBytes = 0;
+    let releasingInput = null;
+    const awaitInputRuntime = (weight) => {
+        const control = controlIdentity(options.generation());
+        if (!control || waitingInput.size >= 64 || waitingInputBytes + weight > 1024 * 1024)
+            return Promise.resolve(false);
+        return new Promise((resolve) => {
+            const entry = {
+                control,
+                weight,
+                settle: (ready) => {
+                    if (!waitingInput.delete(entry))
+                        return;
+                    waitingInputBytes -= weight;
+                    clearTimeout(timer);
+                    resolve(ready);
+                },
+            };
+            const timer = setTimeout(() => entry.settle(false), 5000);
+            timer.unref?.();
+            waitingInput.add(entry);
+            waitingInputBytes += weight;
+        });
+    };
     const armDiagnosticWindowFrame = (pending) => {
         diagnosticWindowFrame = pending;
         diagnosticWindowFrameExpiresAtMicros = pending.startedAtMicros + 6_000_000;
@@ -356,6 +414,71 @@ export function createApplicationTerminalInteractionController(options) {
             pendingWindowSwitch = null;
         }
     };
+    const beginWindowSwitch = (pane, target, windowLink) => {
+        pendingWindowSwitch = null;
+        if (options.diagnosticsEnabled) {
+            try {
+                const active = options.generation();
+                const identity = active?.adapter?.paneCanonicalIdentity(pane);
+                const clientGeneration = active?.client?.getSnapshot().generation;
+                const startedAtMicros = diagnosticNowMicros();
+                if (active?.status === "live" &&
+                    active.daemonGeneration &&
+                    identity &&
+                    Number.isSafeInteger(clientGeneration) &&
+                    startedAtMicros !== null) {
+                    pendingWindowSwitch = {
+                        selectionKind: windowLink ? "window-link" : "pane",
+                        ...(windowLink ? { windowLink } : {}),
+                        traceId: createTraceId(),
+                        target,
+                        paneId: pane,
+                        startedAtMicros,
+                        daemonGeneration: active.daemonGeneration,
+                        clientGeneration: clientGeneration,
+                        rendererEpoch: active.rendererEpoch,
+                        sourceEpoch: identity.sourceEpoch,
+                        generation: identity.generation,
+                        incarnation: identity.incarnation,
+                        revision: identity.revision,
+                        stateHash: identity.stateHash,
+                        cols: identity.cols,
+                        rows: identity.rows,
+                        layoutPublished: false,
+                        selectionApplied: false,
+                        presentationPublished: false,
+                        followUpRequested: false,
+                        ...(options.detailedWindowSwitchTiming
+                            ? {
+                                timing: {
+                                    receiptAtMicros: null,
+                                    layoutAtMicros: null,
+                                    presentationAtMicros: null,
+                                },
+                            }
+                            : {}),
+                    };
+                    armDiagnosticWindowFrame({ kind: "window-switch", ...pendingWindowSwitch });
+                    diagnose("window-switch-start", { ...pendingWindowSwitch });
+                }
+                else {
+                    diagnose("window-switch-untracked", {
+                        paneId: pane,
+                        target,
+                        status: active?.status ?? null,
+                        daemonGeneration: active?.daemonGeneration ?? null,
+                        rendererEpoch: active?.rendererEpoch ?? null,
+                        clientGeneration: clientGeneration ?? null,
+                        identity: identity ?? null,
+                        laneCounters: active?.fastLane?.lane.counters() ?? null,
+                    });
+                }
+            }
+            catch {
+                pendingWindowSwitch = null;
+            }
+        }
+    };
     let linkSelection = null;
     const finishLinkSelection = (selected) => {
         const pending = linkSelection;
@@ -363,6 +486,20 @@ export function createApplicationTerminalInteractionController(options) {
             return;
         linkSelection = null;
         clearTimeout(pending.timer);
+        const diagnostic = pending.diagnostic;
+        if (diagnostic && pendingWindowSwitch === diagnostic) {
+            if (selected) {
+                diagnostic.selectionApplied = true;
+                maybeRequestWindowSwitchFrame();
+            }
+            else {
+                diagnoseCritical(`window-switch:${diagnostic.traceId}:failed`, "window-switch-failed", {
+                    ...diagnostic,
+                    reason: "window-link-selection-not-applied",
+                });
+                pendingWindowSwitch = null;
+            }
+        }
         pending.resolve(selected);
     };
     const reconcileLinkSelection = (snapshot) => {
@@ -386,11 +523,18 @@ export function createApplicationTerminalInteractionController(options) {
         select: async (paneId) => {
             finishLinkSelection(false);
             const expected = liveSelectionTarget();
+            const selectionControl = controlIdentity(options.generation());
             const selecting = pendingWindowSwitch;
             const operationId = selecting?.traceId;
             const selectionFailure = { current: null };
             const receipt = expected
-                ? await selectTerminalPane(expected, liveSelectionTarget, paneId, operationId, (failure) => {
+                ? await selectTerminalPane(expected, () => {
+                    if (!selectionControl)
+                        return liveSelectionTarget();
+                    return sameControl(selectionControl, controlIdentity(options.generation()))
+                        ? expected
+                        : null;
+                }, paneId, operationId, (failure) => {
                     selectionFailure.current = failure;
                 }, windowLinkForPane(options.layout(), paneId) ?? undefined)
                 : null;
@@ -455,6 +599,16 @@ export function createApplicationTerminalInteractionController(options) {
         },
         send: async (paneId, routed) => {
             const { input, parserOrigin } = routed;
+            const selectionVersion = paneInput.selectionVersion;
+            if (options.generation()?.status === "rebinding") {
+                if (!(await awaitInputRuntime(Buffer.byteLength(input.data, "utf8"))))
+                    return false;
+            }
+            else if (releasingInput) {
+                await releasingInput;
+            }
+            if (paneInput.selectionVersion !== selectionVersion || paneInput.focusedPane !== paneId)
+                return false;
             const active = options.generation();
             if (active?.status !== "live" || !active.fastLane)
                 return false;
@@ -534,7 +688,35 @@ export function createApplicationTerminalInteractionController(options) {
         onFocusedPane: options.setFocusedPane,
     });
     return {
+        cancelPendingInput() {
+            finishLinkSelection(false);
+            paneInput.invalidateSelection();
+            for (const entry of waitingInput)
+                entry.settle(false);
+        },
         adoptGeneration(snapshot) {
+            const control = controlIdentity(snapshot);
+            if (!sameControl(selectedControl, control)) {
+                finishLinkSelection(false);
+                paneInput.invalidateSelection();
+            }
+            selectedControl = control;
+            if (waitingInput.size > 0 && snapshot?.status === "live" && snapshot.fastLane) {
+                // Old waiters resume first; input admitted synchronously by the next
+                // layout publication must not overtake them in this microtask turn.
+                const barrier = Promise.resolve();
+                releasingInput = barrier;
+                queueMicrotask(() => {
+                    if (releasingInput === barrier)
+                        releasingInput = null;
+                });
+            }
+            for (const entry of waitingInput) {
+                if (!sameControl(entry.control, control))
+                    entry.settle(false);
+                else if (snapshot?.status === "live" && snapshot.fastLane)
+                    entry.settle(true);
+            }
             let next = null;
             if (snapshot?.status === "live" &&
                 snapshot.daemonGeneration &&
@@ -570,7 +752,6 @@ export function createApplicationTerminalInteractionController(options) {
                     next.adapter !== inputAuthorityIdentity.adapter);
             if (next === null || replaced) {
                 finishLinkSelection(false);
-                paneInput.invalidateSelection();
                 pendingWindowSwitch = null;
                 pendingWindowRename = null;
                 diagnosticWindowFrame = null;
@@ -715,6 +896,7 @@ export function createApplicationTerminalInteractionController(options) {
                 observed.expectedSemanticWindowId !== target.expectedSemanticWindowId)
                 return;
             finishLinkSelection(false);
+            beginWindowSwitch(paneId, target.expectedSemanticWindowId, target);
             let resolve;
             const settled = new Promise((done) => {
                 resolve = done;
@@ -724,6 +906,7 @@ export function createApplicationTerminalInteractionController(options) {
                 paneId,
                 layout: snapshot,
                 received: false,
+                diagnostic: pendingWindowSwitch,
                 resolve,
                 timer: setTimeout(() => {
                     if (linkSelection === pending)
@@ -751,6 +934,7 @@ export function createApplicationTerminalInteractionController(options) {
                 }
                 const wrapper = (await expected.client.dispatch({
                     kind: "semantic-intent",
+                    ...(pending.diagnostic ? { operationId: pending.diagnostic.traceId } : {}),
                     intent: {
                         verb: "workspace.window.link.select",
                         workspaceName: expected.workspaceName,
@@ -763,6 +947,7 @@ export function createApplicationTerminalInteractionController(options) {
                 if (wrapper.kind !== "semantic-intent" ||
                     !result.success ||
                     result.data.operationId !== wrapper.operationId ||
+                    (pending.diagnostic && wrapper.operationId !== pending.diagnostic.traceId) ||
                     result.data.daemonInstanceId !== expected.daemonGeneration ||
                     result.data.workspaceName !== expected.workspaceName ||
                     result.data.target.linkId !== target.linkId ||
@@ -772,6 +957,18 @@ export function createApplicationTerminalInteractionController(options) {
                     finishLinkSelection(false);
                     return;
                 }
+                if (pending.diagnostic) {
+                    const receiptAtMicros = diagnosticNowMicros();
+                    if (pending.diagnostic.timing)
+                        pending.diagnostic.timing.receiptAtMicros = receiptAtMicros;
+                    diagnose("window-switch-receipt", {
+                        ...pending.diagnostic,
+                        operationId: wrapper.operationId,
+                        selected: true,
+                        applied: true,
+                        ...(options.detailedWindowSwitchTiming ? { phaseAtMicros: receiptAtMicros } : {}),
+                    });
+                }
                 pending.received = true;
                 reconcileLinkSelection(pending.layout);
                 await settled;
@@ -1022,54 +1219,7 @@ export function createApplicationTerminalInteractionController(options) {
             const target = next?.semanticWindowId ?? next?.windowName;
             if (!pane || !target)
                 return;
-            if (options.diagnosticsEnabled) {
-                try {
-                    const active = options.generation();
-                    const identity = active?.adapter?.paneCanonicalIdentity(pane);
-                    const clientGeneration = active?.client?.getSnapshot().generation;
-                    const startedAtMicros = diagnosticNowMicros();
-                    if (active?.status === "live" &&
-                        active.daemonGeneration &&
-                        identity &&
-                        Number.isSafeInteger(clientGeneration) &&
-                        startedAtMicros !== null) {
-                        pendingWindowSwitch = {
-                            traceId: createTraceId(),
-                            target,
-                            paneId: pane,
-                            startedAtMicros,
-                            daemonGeneration: active.daemonGeneration,
-                            clientGeneration: clientGeneration,
-                            rendererEpoch: active.rendererEpoch,
-                            sourceEpoch: identity.sourceEpoch,
-                            generation: identity.generation,
-                            incarnation: identity.incarnation,
-                            revision: identity.revision,
-                            stateHash: identity.stateHash,
-                            cols: identity.cols,
-                            rows: identity.rows,
-                            layoutPublished: false,
-                            selectionApplied: false,
-                            presentationPublished: false,
-                            followUpRequested: false,
-                            ...(options.detailedWindowSwitchTiming
-                                ? {
-                                    timing: {
-                                        receiptAtMicros: null,
-                                        layoutAtMicros: null,
-                                        presentationAtMicros: null,
-                                    },
-                                }
-                                : {}),
-                        };
-                        armDiagnosticWindowFrame({ kind: "window-switch", ...pendingWindowSwitch });
-                        diagnose("window-switch-start", { ...pendingWindowSwitch });
-                    }
-                }
-                catch {
-                    pendingWindowSwitch = null;
-                }
-            }
+            beginWindowSwitch(pane, target);
             paneInput.selectPane(pane, { presentOptimistically: false });
         },
         async zoomPane(targetPane) {
@@ -1265,6 +1415,7 @@ export function createApplicationTerminalInteractionController(options) {
                     ? {}
                     : { phaseAtMicros: pending.timing.presentationAtMicros }),
             });
+            maybeRequestWindowSwitchFrame();
         },
         observeDiagnosticWindowFrame() {
             if (!options.diagnosticsEnabled)