tmux-ide 2.9.11 → 2.9.13

package/packages/daemon/dist/terminal/session-runtime/terminal-delivery-hub.js

@@ -1,7 +1,10 @@
+import { prepareProjection } from "./terminal-projection-delivery.js";
+import { TerminalProjectionEnvelopeSchemaZ, TerminalProjectionReceiptSchemaZ, TerminalProjectionMaterializeSchemaZ, } from "@tmux-ide/contracts";
+import { encodeTerminalProjectionCooperatively } from "@tmux-ide/core";
 import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.js";
 import { MAX_RETAINED_NATIVE_BACKING_BYTES, takeNativeSeedBacking, } from "./native-seed-backing.js";
 import { WorkspaceIdSchemaZ, TERMINAL_GRAPHICS_CAPABILITY_VERSION, TERMINAL_DELIVERY_PATCH_TO_SEED_BYTES, TERMINAL_DELIVERY_MAX_REPRESENTATION_BYTES, TerminalDeliveryEnvelopeSchemaZ, TerminalDeliveryAckSchemaZ, TerminalDeliveryNackSchemaZ, TerminalDeliveryOfferSchemaZ, TerminalDeliveryVisibilitySchemaZ, } from "@tmux-ide/contracts";
-import { TerminalDeliveryStateTooLargeError, terminalReplicaRowsEqual, TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS, applyTerminalReplicaUpdate, applyTerminalReplicaUpdateCooperatively, terminalReplicaUpdateNeedsCooperativeReduction, encodeCompactSemanticTerminalUpdate, encodeCompactSemanticTerminalUpdateCooperatively, terminalSemanticUpdateNeedsCooperativeEncoding, encodeAnsiTerminalRepresentation, encodeSemanticTerminalUpdate, hashTerminalDeliveryRepresentation, negotiateTerminalDelivery, preaccountSemanticTerminalUpdateBytes, } from "@tmux-ide/core";
+import { TerminalDeliveryStateTooLargeError, terminalReplicaRowsEqual, TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS, applyTerminalReplicaUpdate, applyTerminalReplicaUpdateCooperatively, terminalReplicaUpdateNeedsCooperativeReduction, encodeBinarySemanticTerminalUpdate, encodeBinarySemanticTerminalUpdateCooperatively, encodeCompactSemanticTerminalUpdate, encodeCompactSemanticTerminalUpdateCooperatively, terminalSemanticUpdateNeedsCooperativeEncoding, encodeAnsiTerminalRepresentation, encodeSemanticTerminalUpdate, hashTerminalDeliveryRepresentation, negotiateTerminalDelivery, preaccountSemanticTerminalUpdateBytes, } from "@tmux-ide/core";
 import { SYSTEM_SESSION_RUNTIME_SCHEDULER, } from "./runtime-scheduler.js";
 import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability.js";
 import { registerTerminalDeliveryObservationOrdinal } from "./terminal-delivery-observation-identity.js";
@@ -15,6 +18,13 @@ const MAX_PANES = 32;
 const MAX_PENDING_CANONICAL_CELLS = 1_000_000;
 const MAX_CONNECTIONS = MAX_CLIENTS * MAX_PANES;
 const BACKGROUND_CADENCE_MS = 100;
+class DeferredProjectionEncoding extends Error {
+    payload;
+    constructor(payload) {
+        super("Deferred projection encoding");
+        this.payload = payload;
+    }
+}
 class DeferredSeedEncoding extends Error {
     payload;
     constructor(payload) {
@@ -135,6 +145,10 @@ export class SessionRuntimeTerminalDeliveryHub {
                 visibility: "visible",
                 baselineRevision: -1,
                 baselineHash: null,
+                projectionBaseline: null,
+                materializeRequested: false,
+                lastProjectionReceipt: null,
+                lastMaterialize: null,
                 reseedRequired: false,
                 inFlight: null,
                 latestRevision: pane.latest?.update.revision ?? null,
@@ -159,6 +173,8 @@ export class SessionRuntimeTerminalDeliveryHub {
                 negotiation,
                 closed,
                 ack: (ack) => this.#ack(client, ack),
+                projectionReceipt: (receipt) => this.#projectionReceipt(client, receipt),
+                materialize: (request) => this.#materialize(client, request),
                 nack: (nack) => this.#nack(client, nack),
                 setVisibility: (visibilityInput) => {
                     if (client.closed)
@@ -587,7 +603,10 @@ export class SessionRuntimeTerminalDeliveryHub {
             if (!client.lifecycleOpenRecorded)
                 client.lifecycleOpenRecorded = this.#recordDeliveryLifecycle(client, pane, "open");
             if (update.type === "terminal.tombstone" &&
-                (client.inFlight !== null || client.encoding !== null || client.visibility !== "visible")) {
+                (client.inFlight !== null ||
+                    client.encoding !== null ||
+                    client.visibility !== "visible" ||
+                    client.projectionBaseline !== null)) {
                 this.#fault(client, "source-closed", "Terminal source closed before final state delivery");
                 continue;
             }
@@ -705,8 +724,13 @@ export class SessionRuntimeTerminalDeliveryHub {
             encodedRepresentation = representation;
             const transactionId = this.#scheduler.createId();
             const chunkCount = Math.max(1, Math.ceil(representation.bytes.byteLength / (256 * 1024)));
-            const envelope = TerminalDeliveryEnvelopeSchemaZ.parse({
-                type: "terminal.delivery",
+            const envelope = (representation.projection
+                ? TerminalProjectionEnvelopeSchemaZ
+                : TerminalDeliveryEnvelopeSchemaZ).parse({
+                type: representation.projection ? "terminal.projection" : "terminal.delivery",
+                ...(representation.projection
+                    ? { projectionStateHash: representation.projection.hash }
+                    : {}),
                 workspaceName: client.deliveryWorkspaceName,
                 semanticPaneId: target.update.semanticPaneId,
                 generation: target.update.generation,
@@ -717,7 +741,11 @@ export class SessionRuntimeTerminalDeliveryHub {
                 protocolVersion: 1,
                 encoding: representation.encoding ?? client.negotiated.encoding,
                 frame: representation.frame,
-                baseRevision: representation.frame === "seed" ? null : Math.max(0, client.baselineRevision),
+                baseRevision: representation.projection
+                    ? representation.projectionBaseRevision
+                    : representation.frame === "seed"
+                        ? null
+                        : Math.max(0, client.baselineRevision),
                 canonicalRevision: target.update.revision,
                 canonicalStateHash: target.update.stateHash,
                 representationHash: representation.representationHash ??
@@ -733,6 +761,7 @@ export class SessionRuntimeTerminalDeliveryHub {
             registerTerminalDeliveryObservationOrdinal(envelope, deliveryOrdinal);
             client.inFlight = {
                 envelope,
+                projection: representation.projection ?? null,
                 deliveryOrdinal,
                 bytes: representation.bytes,
                 nextChunk: 0,
@@ -744,9 +773,9 @@ export class SessionRuntimeTerminalDeliveryHub {
                 pane.pendingDeliveryTrace = null;
         }
         catch (error) {
-            if (error instanceof DeferredSeedEncoding) {
+            if (error instanceof DeferredSeedEncoding || error instanceof DeferredProjectionEncoding) {
                 deferred = true;
-                this.#startEncoding(client, pane, target, error.payload, traceStarted);
+                this.#startEncoding(client, pane, target, error.payload, traceStarted, error instanceof DeferredProjectionEncoding);
                 return;
             }
             failedSelectionObservation = semanticSelectionObservationFromError(error);
@@ -804,7 +833,7 @@ export class SessionRuntimeTerminalDeliveryHub {
                 }
         }
     }
-    #startEncoding(client, pane, target, payload, traceStarted) {
+    #startEncoding(client, pane, target, payload, traceStarted, projection = false) {
         const key = cacheKey([
             target.update.workspaceName,
             client.paneId,
@@ -814,6 +843,9 @@ export class SessionRuntimeTerminalDeliveryHub {
             target.update.stateHash,
             client.negotiated.encoding,
             client.negotiated.richPlacements ? "rich" : "plain",
+            projection
+                ? `projection:${client.projectionBaseline?.revision ?? -1}:${client.projectionBaseline?.hash ?? "none"}`
+                : "complete",
         ]);
         let job = this.#pendingEncodings.get(key);
         let created = false;
@@ -844,10 +876,13 @@ export class SessionRuntimeTerminalDeliveryHub {
         owned.clients.add(client);
         if (!created)
             return;
-        void encodeCompactSemanticTerminalUpdateCooperatively(payload, {
-            signal: owned.abort.signal,
-            yieldControl: () => this.#yieldEncoding(owned),
-        }).then((bytes) => this.#completeEncoding(owned, { bytes }), (error) => this.#completeEncoding(owned, { error }));
+        const options = { signal: owned.abort.signal, yieldControl: () => this.#yieldEncoding(owned) };
+        const result = projection
+            ? encodeTerminalProjectionCooperatively(payload, options)
+            : client.negotiated.encoding === "semantic-binary-v1"
+                ? encodeBinarySemanticTerminalUpdateCooperatively(payload, options)
+                : encodeCompactSemanticTerminalUpdateCooperatively(payload, options);
+        void result.then((bytes) => this.#completeEncoding(owned, { bytes }), (error) => this.#completeEncoding(owned, { error }));
     }
     #yieldEncoding(job) {
         if (this.#scheduler.nowMs() - job.yieldStartedAt < 2)
@@ -914,6 +949,27 @@ export class SessionRuntimeTerminalDeliveryHub {
         this.#pruneCanonicalRevisions(client.paneId);
     }
     #representation(client, pane, target, seedOutcome) {
+        const snapshotForProjection = target.state.snapshot;
+        if (client.negotiated.alternateScreenProjection &&
+            !client.materializeRequested &&
+            (client.baselineRevision < 0 || client.projectionBaseline !== null) &&
+            snapshotForProjection?.modes.alternateScreen &&
+            snapshotForProjection.history.length > 0) {
+            const { payload, retained } = prepareProjection(snapshotForProjection, target.update.revision, target.update.incarnation, client.reseedRequired ? null : client.projectionBaseline);
+            if (!seedOutcome)
+                throw new DeferredProjectionEncoding(payload);
+            if ("error" in seedOutcome)
+                throw seedOutcome.error;
+            return {
+                bytes: seedOutcome.bytes,
+                encoding: "alternate-projection-binary-v1",
+                frame: payload.frame,
+                history: "deferred",
+                canonicalEquivalent: false,
+                projection: retained,
+                projectionBaseRevision: payload.frame === "seed" ? null : payload.baseRevision,
+            };
+        }
         const key = cacheKey([
             target.update.workspaceName,
             target.update.semanticPaneId,
@@ -937,18 +993,24 @@ export class SessionRuntimeTerminalDeliveryHub {
         const snapshot = target.state.snapshot;
         let result = null;
         if (client.negotiated.encoding === "semantic-v1" ||
-            client.negotiated.encoding === "semantic-compact-v1") {
+            client.negotiated.encoding === "semantic-compact-v1" ||
+            client.negotiated.encoding === "semantic-binary-v1") {
             const encodeSemantic = (payload) => {
-                if (client.negotiated.encoding !== "semantic-compact-v1")
+                if (client.negotiated.encoding !== "semantic-compact-v1" &&
+                    client.negotiated.encoding !== "semantic-binary-v1")
                     return encodeSemanticTerminalUpdate(payload);
-                if (terminalSemanticUpdateNeedsCooperativeEncoding(payload)) {
+                if (payload.frame === "seed" &&
+                    (client.negotiated.encoding === "semantic-binary-v1" ||
+                        terminalSemanticUpdateNeedsCooperativeEncoding(payload))) {
                     if (!seedOutcome)
                         throw new DeferredSeedEncoding(payload);
                     if ("error" in seedOutcome)
                         throw seedOutcome.error;
                     return seedOutcome.bytes;
                 }
-                return encodeCompactSemanticTerminalUpdate(payload);
+                return client.negotiated.encoding === "semantic-binary-v1"
+                    ? encodeBinarySemanticTerminalUpdate(payload)
+                    : encodeCompactSemanticTerminalUpdate(payload);
             };
             if (client.reseedRequired) {
                 const payload = semanticSeed(target);
@@ -1213,6 +1275,10 @@ export class SessionRuntimeTerminalDeliveryHub {
             return;
         }
         const envelope = flight.envelope;
+        if (envelope.type !== "terminal.delivery") {
+            this.#fault(client, "protocol-violation", "Canonical ACK cannot acknowledge a projection");
+            return;
+        }
         if (flight.nextChunk !== envelope.chunkCount ||
             ack.workspaceName !== envelope.workspaceName ||
             ack.semanticPaneId !== envelope.semanticPaneId ||
@@ -1227,6 +1293,8 @@ export class SessionRuntimeTerminalDeliveryHub {
             return;
         }
         this.#maxSlowClientMs = Math.max(this.#maxSlowClientMs, this.#scheduler.nowMs() - flight.sentAt);
+        client.projectionBaseline = null;
+        client.lastProjectionReceipt = null;
         client.baselineRevision = ack.canonicalRevision;
         client.baselineHash = ack.canonicalStateHash;
         client.reseedRequired = false;
@@ -1277,6 +1345,68 @@ export class SessionRuntimeTerminalDeliveryHub {
         this.#schedule(client);
         this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
     }
+    #projectionReceipt(client, input) {
+        const receipt = TerminalProjectionReceiptSchemaZ.parse(input);
+        if (client.lastProjectionReceipt &&
+            JSON.stringify(client.lastProjectionReceipt) === JSON.stringify(receipt))
+            return;
+        const flight = client.inFlight;
+        const envelope = flight?.envelope;
+        if (!flight ||
+            !flight.projection ||
+            envelope?.type !== "terminal.projection" ||
+            flight.nextChunk !== envelope.chunkCount ||
+            receipt.workspaceName !== envelope.workspaceName ||
+            receipt.semanticPaneId !== envelope.semanticPaneId ||
+            receipt.generation !== envelope.generation ||
+            receipt.incarnation !== envelope.incarnation ||
+            receipt.deliveryNonce !== envelope.deliveryNonce ||
+            receipt.transactionId !== envelope.transactionId ||
+            receipt.canonicalRevision !== envelope.canonicalRevision ||
+            receipt.canonicalStateHash !== envelope.canonicalStateHash ||
+            receipt.projectionStateHash !== envelope.projectionStateHash ||
+            receipt.representationHash !== envelope.representationHash) {
+            this.#fault(client, "protocol-violation", "Projection receipt does not identify the in-flight projection");
+            return;
+        }
+        client.projectionBaseline = flight.projection;
+        client.lastProjectionReceipt = receipt;
+        client.reseedRequired = false;
+        client.inFlight = null;
+        if (client.latestRevision === receipt.canonicalRevision)
+            client.latestRevision = null;
+        if (client.materializeRequested)
+            client.latestRevision = this.#panes.get(client.paneId)?.latest?.update.revision ?? null;
+        this.#pruneCanonicalRevisions(client.paneId);
+        this.#schedule(client);
+        this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
+    }
+    #materialize(client, input) {
+        const request = TerminalProjectionMaterializeSchemaZ.parse(input);
+        if (client.lastMaterialize &&
+            JSON.stringify(client.lastMaterialize) === JSON.stringify(request))
+            return;
+        const baseline = client.projectionBaseline;
+        if (!client.negotiated.alternateScreenProjection ||
+            !baseline ||
+            request.workspaceName !== client.deliveryWorkspaceName ||
+            request.semanticPaneId !== client.paneId ||
+            request.generation !== client.negotiated.generation ||
+            request.incarnation !== baseline.incarnation ||
+            request.deliveryNonce !== client.negotiated.deliveryNonce ||
+            request.canonicalRevision !== baseline.revision ||
+            request.projectionStateHash !== baseline.hash) {
+            this.#fault(client, "protocol-violation", "History request does not identify the retained projection");
+            return;
+        }
+        client.lastMaterialize = request;
+        client.materializeRequested = true;
+        this.#cancelEncoding(client);
+        client.latestRevision = this.#panes.get(client.paneId)?.latest?.update.revision ?? null;
+        // A queued projection still owns its transaction until its receipt arrives.
+        // The following complete seed then supersedes it, including at the same revision.
+        this.#schedule(client);
+    }
     #nack(client, input) {
         const nack = TerminalDeliveryNackSchemaZ.parse(input);
         const closed = client.sourceClosedFlight;

package/packages/daemon/dist/terminal/session-runtime/terminal-projection-delivery.js

@@ -0,0 +1,32 @@
+import { hashTerminalProjection, projectAlternateSnapshot, terminalReplicaRowsEqual, } from "@tmux-ide/core";
+export function prepareProjection(snapshot, revision, incarnation, baseline) {
+    const projected = projectAlternateSnapshot(snapshot);
+    const retained = {
+        revision,
+        incarnation,
+        hash: hashTerminalProjection(projected),
+        snapshot: projected,
+    };
+    if (!baseline ||
+        baseline.incarnation !== incarnation ||
+        baseline.snapshot.cols !== projected.cols ||
+        baseline.snapshot.rows !== projected.rows)
+        return { payload: { frame: "seed", revision, projection: projected }, retained };
+    const rows = projected.grid.flatMap((row, index) => terminalReplicaRowsEqual(row, baseline.snapshot.grid[index]) ? [] : [{ index, row }]);
+    return {
+        retained,
+        payload: {
+            frame: "patch",
+            baseRevision: baseline.revision,
+            revision,
+            patch: {
+                rows,
+                deferredHistory: projected.deferredHistory,
+                cursor: projected.cursor,
+                modes: projected.modes,
+                placements: projected.placements,
+                bootstrap: projected.bootstrap,
+            },
+        },
+    };
+}

package/packages/daemon/dist/terminal/session-runtime/terminal-replica-owner.js

@@ -155,11 +155,10 @@ export class SessionRuntimeTerminalReplicaOwner {
     inputDispatchIncarnation() {
         return this.#disposed ? null : this.#publishedIncarnation;
     }
-    /** Scalar admission fence; unavailable while canonical replacement is pending. */
+    /** Screen recapture does not replace the terminal lifetime. Keep its input fence
+     * while resizing; disposal or a new owner still invalidates held input. */
     inputAdmissionIncarnation() {
-        return this.#disposed || this.#reseed || this.#waitingForGeometryCapture
-            ? null
-            : this.#publishedIncarnation;
+        return this.#disposed ? null : this.#publishedIncarnation;
     }
     qualificationSnapshot() {
         const seed = this.#interpreter.currentSeed();

package/packages/daemon/dist/tui/mirror/open-tui-workspace-runtime-port.js

@@ -335,6 +335,10 @@ class WireTerminalEndpoint {
         }
         if (this.#unavailable)
             return;
+        if (message.type === "terminal.projection") {
+            this.#failConnection(new Error("Unsolicited alternate-screen projection"));
+            return;
+        }
         if (message.type === "terminal.delivery") {
             this.#acceptEnvelope(message);
             return;

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

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.js";
 import { createTerminalSelectionWaiter } from "./terminal-selection-waiter.js";
 import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
 import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.js";
@@ -738,10 +739,14 @@ export function createApplicationTerminalInteractionController(options) {
             }
             return outcome.status === "sent";
         },
-        onFocusedPane: options.setFocusedPane,
+        onFocusedPane: (pane) => {
+            rendererProbe()?.cancel("selection-changed", nowMicros());
+            options.setFocusedPane(pane);
+        },
     });
     return {
         cancelPendingInput() {
+            rendererProbe()?.cancel("input-cancelled", nowMicros());
             selectionWaiter.cancel();
             finishLinkSelection(false);
             paneInput.invalidateSelection();
@@ -752,6 +757,7 @@ export function createApplicationTerminalInteractionController(options) {
             selectionGeneration = snapshot;
             const control = controlIdentity(snapshot);
             if (!sameControl(selectedControl, control)) {
+                rendererProbe()?.cancel("control-changed", nowMicros());
                 finishLinkSelection(false);
                 paneInput.invalidateSelection();
             }
@@ -807,6 +813,7 @@ export function createApplicationTerminalInteractionController(options) {
                     next.fastLane !== inputAuthorityIdentity.fastLane ||
                     next.adapter !== inputAuthorityIdentity.adapter);
             if (next === null || replaced) {
+                rendererProbe()?.cancel("generation-changed", nowMicros());
                 finishLinkSelection(false);
                 pendingWindowSwitch = null;
                 pendingWindowRename = null;
@@ -1039,9 +1046,27 @@ export function createApplicationTerminalInteractionController(options) {
             }
         },
         sendInput: async (input, parserOrigin) => {
-            await paneInput.sendInput({ input, parserOrigin });
+            const probe = rendererProbe();
+            const state = probe
+                ? (options.generation()?.fastLane?.lane.paneState(paneInput.focusedPane ?? "") ?? null)
+                : null;
+            const measured = probe?.admit(input, state, nowMicros());
+            const sent = await paneInput.sendInput({ input: measured ?? input, parserOrigin });
+            if (measured && !sent)
+                probe?.cancel("dispatch-rejected", nowMicros());
+        },
+        sendInputToPane: async (paneId, input, parserOrigin) => {
+            const probe = rendererProbe();
+            const state = probe ? (options.generation()?.fastLane?.lane.paneState(paneId) ?? null) : null;
+            const measured = probe?.admit(input, state, nowMicros());
+            const sent = await paneInput.sendInputToPane(paneId, {
+                input: measured ?? input,
+                parserOrigin,
+            });
+            if (measured && !sent)
+                probe?.cancel("dispatch-rejected", nowMicros());
+            return sent;
         },
-        sendInputToPane: (paneId, input, parserOrigin) => paneInput.sendInputToPane(paneId, { input, parserOrigin }),
         beginResizePointerIngress(input) {
             if (!options.diagnosticsEnabled)
                 return null;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-workspace.jsx

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.js";
 import { paneInteractionDisplayDestination } from "../ui/pane-interaction-presentation.js";
 import { interactionPaneEndpointKey } from "@tmux-ide/core";
 import { interactionForCurrentPane } from "../ui/pane-interaction-presentation.js";
@@ -935,6 +936,7 @@ export function ApplicationTerminalWorkspace(props) {
             return;
         }
         if (event.type === "scroll") {
+            const probeAt = rendererProbe() ? Math.floor(performance.now() * 1000) : 0;
             // A held selection owns the gesture even when the pointer crosses a sibling.
             const activeSelection = selecting;
             const selectionCell = activeSelection &&
@@ -942,7 +944,9 @@ export function ApplicationTerminalWorkspace(props) {
             const hit = activeSelection && selectionCell
                 ? { frame: activeSelection.frame, ...selectionCell }
                 : paneContentAt(point);
-            const before = props.onWheelObservation && hit ? scrollback.offset(hit.frame.paneId) : null;
+            const before = (props.onWheelObservation || rendererProbe()) && hit
+                ? scrollback.offset(hit.frame.paneId)
+                : null;
             const observe = (route) => {
                 props.onWheelObservation?.({
                     paneId: hit?.frame.paneId ?? null,
@@ -1021,6 +1025,14 @@ export function ApplicationTerminalWorkspace(props) {
                 }
                 else
                     scrollback.move(hit.frame.paneId, motion.lines);
+                if (rendererProbe() && identity && before !== null)
+                    rendererProbe()?.scroll({
+                        pane: hit.frame.paneId,
+                        generation: identity.generation,
+                        incarnation: identity.incarnation,
+                        cols: snapshot.cols,
+                        rows: snapshot.rows,
+                    }, snapshot, before, scrollback.offset(hit.frame.paneId), probeAt);
                 observe("local-history");
                 if (selecting?.paneId === hit.frame.paneId)
                     updatePointerSelection(selecting.pointer);

package/packages/daemon/dist/tui/mirror/runtime/renderer-probe.js

@@ -0,0 +1,195 @@
+import { visibleTerminalRowAt } from "../semantic-pane-render-source.js";
+import { appendFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+function scope(state) {
+    return state.snapshot
+        ? {
+            pane: state.semanticPaneId,
+            generation: state.generation,
+            incarnation: state.incarnation,
+            cols: state.snapshot.cols,
+            rows: state.snapshot.rows,
+        }
+        : null;
+}
+const key = (s) => JSON.stringify([s.pane, s.generation, s.incarnation, s.cols, s.rows]);
+export class RendererProbe {
+    trials;
+    emit;
+    #next = 0;
+    #pending = null;
+    constructor(trials, emit) {
+        this.trials = trials;
+        this.emit = emit;
+        if (trials.length > 64 ||
+            new Set(trials.map((t) => t.nonce)).size !== trials.length ||
+            trials.some((t) => !t.id ||
+                t.id.length > 128 ||
+                !/^[a-f0-9]{32}$/.test(t.nonce) ||
+                (t.kind !== undefined && !["input", "scroll", "output"].includes(t.kind))))
+            throw new Error("Invalid renderer probe trials");
+    }
+    get pending() {
+        return this.#pending !== null;
+    }
+    admit(input, state, at) {
+        if (input.kind !== "text" ||
+            input.data !== "!" ||
+            !state?.snapshot ||
+            this.#pending ||
+            !this.trials[this.#next])
+            return null;
+        if (this.trials[this.#next]?.kind === "scroll")
+            return { kind: "text", data: `PROBE-PREPARE-SCROLL:${this.trials[this.#next].nonce}\n` };
+        const trial = this.trials[this.#next++], marker = `PROBE-OUTPUT:${trial.nonce}`, identity = scope(state);
+        this.#pending = { trial, scope: identity, at, marker, offset: 0, sourceOffset: 0 };
+        if (state.snapshot.cols < marker.length ||
+            state.snapshot.grid.some((r) => r.cells
+                .map((c) => c.grapheme)
+                .join("")
+                .includes(marker))) {
+            this.cancel("negative-control", at);
+            return null;
+        }
+        return {
+            kind: "text",
+            data: `${trial.kind === "output" ? "PROBE-BURST" : "PROBE-IN"}:${trial.nonce}\n`,
+        };
+    }
+    scroll(identity, snapshot, before, after, at) {
+        const trial = this.trials[this.#next];
+        if (this.#pending || trial?.kind !== "scroll" || before === after)
+            return;
+        const row = visibleTerminalRowAt(snapshot, after, 0);
+        const text = row?.cells
+            .map((c) => c.grapheme)
+            .join("")
+            .trimEnd() ?? "";
+        if (!new RegExp(`^PROBE-ROW:${trial.nonce}:[0-9]{4}$`).test(text))
+            return;
+        for (let y = 0; y < snapshot.rows; y++)
+            if (visibleTerminalRowAt(snapshot, before, y)
+                ?.cells.map((c) => c.grapheme)
+                .join("")
+                .trimEnd() === text)
+                return;
+        this.#next++;
+        this.#pending = {
+            trial,
+            scope: identity,
+            at,
+            marker: text,
+            offset: after,
+            sourceOffset: before,
+        };
+    }
+    tick(at) {
+        if (this.#pending && at - this.#pending.at > 5_000_000)
+            this.cancel("timeout", at);
+    }
+    cancel(reason, at) {
+        const p = this.#pending;
+        if (!p)
+            return;
+        this.#pending = null;
+        this.emit({
+            ...p.trial,
+            side: "tui",
+            kind: p.trial.kind ?? "input",
+            sourceScope: p.scope,
+            expectedScope: p.scope,
+            sourceOffset: p.sourceOffset,
+            expectedOffset: p.offset,
+            admittedAtMicros: p.at,
+            completedAtMicros: at,
+            endpoint: "input-admission-to-renderer-work-complete",
+            status: "failed",
+            reason,
+        });
+    }
+    observe(state, at) {
+        if (!this.#pending)
+            return;
+        if (state && state.semanticPaneId !== this.#pending.scope.pane)
+            return;
+        if (!state || !scope(state) || key(scope(state)) !== key(this.#pending.scope))
+            this.cancel("scope-changed", at);
+        else if (at - this.#pending.at > 5_000_000)
+            this.cancel("timeout", at);
+    }
+    row(state, row, viewportRow, width, height, left, scrollOffset, at) {
+        this.observe(state, at);
+        const p = this.#pending;
+        if (!p || state.semanticPaneId !== p.scope.pane)
+            return;
+        if (scrollOffset !== p.offset ||
+            left !== 0 ||
+            viewportRow !== 0 ||
+            height < 1 ||
+            width < p.marker.length ||
+            !row)
+            return;
+        const cells = row.cells.slice(0, p.marker.length);
+        if (cells.some((c) => c.width !== 1) || cells.map((c) => c.grapheme).join("") !== p.marker)
+            return;
+        if (!Number.isSafeInteger(at) || at < p.at) {
+            this.cancel("clock-invalid", at);
+            return;
+        }
+        this.#pending = null;
+        this.emit({
+            ...p.trial,
+            side: "tui",
+            kind: p.trial.kind ?? "input",
+            sourceScope: p.scope,
+            expectedScope: p.scope,
+            sourceOffset: p.sourceOffset,
+            expectedOffset: p.offset,
+            admittedAtMicros: p.at,
+            completedAtMicros: at,
+            endpoint: "input-admission-to-renderer-work-complete",
+            status: "completed",
+            durationMicros: at - p.at,
+            witness: {
+                row: viewportRow,
+                column: 0,
+                marker: p.marker,
+                revision: state.revision,
+                stateHash: state.hash,
+            },
+        });
+    }
+}
+let singleton;
+/** All filesystem work is asynchronous and deferred; at most64 short receipts. */
+export function rendererProbe() {
+    if (singleton !== undefined)
+        return singleton;
+    singleton = null;
+    if (process.env.TMUX_IDE_RENDERER_FIXTURE !== "1")
+        return null;
+    const raw = process.env.TMUX_IDE_RENDERER_PROBE_TRIALS, path = process.env.TMUX_IDE_RENDERER_PROBE_LOG;
+    if (!raw || raw.length > 16384 || !path || !isAbsolute(path))
+        return null;
+    try {
+        const trials = JSON.parse(raw);
+        if (!Array.isArray(trials))
+            return null;
+        let writes = Promise.resolve(), failed = false;
+        singleton = new RendererProbe(trials, (record) => {
+            if (failed)
+                return;
+            writes = writes
+                .then(() => appendFile(path, JSON.stringify(record) + "\n", { mode: 0o600 }))
+                .catch(() => {
+                failed = true;
+            });
+        });
+        const timer = setInterval(() => singleton?.tick(Math.floor(performance.now() * 1000)), 250);
+        timer.unref();
+    }
+    catch {
+        singleton = null;
+    }
+    return singleton;
+}

package/packages/daemon/dist/tui/mirror/runtime/terminal-fast-lane-renderer-adapter.js

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.js";
 import { terminalReplicaRowsEqual } from "@tmux-ide/core";
 import { reflowTerminalPosition, reflowRetainedTerminalSnapshot, retainNativeTerminalBacking, } from "../terminal-viewport.js";
 import { blitSemanticRow, changedTerminalRows, visibleTerminalRowAt, } from "../semantic-pane-render-source.js";
@@ -481,6 +482,8 @@ export class TerminalFastLaneRendererAdapter {
         if (interest.retainedView && next)
             this.#resizeRetainedView(interest, next);
         interest.state = publication.state;
+        if (rendererProbe()?.pending)
+            rendererProbe()?.observe(publication.state, Math.floor(performance.now() * 1000));
         // Preserve coordinates for an unchanged prefix or an exact retained suffix.
         // The suffix offset is fixed by the length difference; never search repeated
         // log lines for a guessed overlap. Changed grids/reflow need a separate map.
@@ -810,6 +813,9 @@ export class TerminalFastLaneRendererAdapter {
             if (interest?.dirtyRows.has(canonicalRow))
                 paintedCanonicalChange = true;
             blit(sourceRow, buffers, row, width, defaultFg, defaultBg, options.graphemes, options.palette, options.viewportOrigin?.x ?? 0);
+            if (interest?.state && rendererProbe()?.pending) {
+                rendererProbe()?.row(interest.retainedView?.state ?? interest.state, sourceRow, row, width, height, options.viewportOrigin?.x ?? 0, options.viewportOrigin ? Math.max(0, -options.viewportOrigin.y) : scrollOffset, Math.floor(performance.now() * 1_000));
+            }
             options.dirtyRows.push(row);
             paintedRows[row] = sourceRow;
         }