tmux-ide 2.9.3 → 2.9.5

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

@@ -1,6 +1,7 @@
+import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.js";
 import { MAX_RETAINED_NATIVE_BACKING_BYTES, takeNativeSeedBacking, } from "./native-seed-backing.js";
 import { TERMINAL_DELIVERY_PATCH_TO_SEED_BYTES, TERMINAL_DELIVERY_MAX_REPRESENTATION_BYTES, TerminalDeliveryEnvelopeSchemaZ, TerminalDeliveryAckSchemaZ, TerminalDeliveryNackSchemaZ, TerminalDeliveryOfferSchemaZ, TerminalDeliveryVisibilitySchemaZ, } from "@tmux-ide/contracts";
-import { TerminalDeliveryStateTooLargeError, 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, 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";
@@ -64,6 +65,8 @@ export class SessionRuntimeTerminalDeliveryHub {
     #observability;
     #panes = new Map();
     #clients = new Map();
+    #sourceCloseFailures = 0;
+    #pendingSourceCloses = 0;
     /** Synchronous reservations held while an async pane source is starting. */
     #pendingClients = new Map();
     #cache = new Map();
@@ -140,6 +143,7 @@ export class SessionRuntimeTerminalDeliveryHub {
                 outgoing: [],
                 sending: false,
                 retireAfterDrain: false,
+                captureUnavailable: false,
                 lastAck: null,
                 sourceClosedFlight: null,
                 backgroundTimer: null,
@@ -166,10 +170,37 @@ export class SessionRuntimeTerminalDeliveryHub {
                 close: async () => this.#closeClient(client),
             };
         }
+        catch (error) {
+            if (!(error instanceof StockCaptureTabUnavailableError))
+                throw error;
+            // Negotiation still settles this pane; no invented canonical seed is published.
+            await accept({
+                type: "terminal.delivery.fault",
+                reason: "source-closed",
+                message: error.message,
+                deliveryNonce: negotiation.negotiated.deliveryNonce,
+            });
+            return {
+                negotiation,
+                closed: Promise.resolve("closed"),
+                ack: () => { },
+                nack: () => { },
+                setVisibility: () => { },
+                close: async () => { },
+            };
+        }
         finally {
             this.#pendingClients.delete(key);
         }
     }
+    /** Retire only this pane's delivery owners before its canonical owner is disposed. */
+    failPaneCapture(semanticPaneId, error) {
+        for (const client of this.#clients.values())
+            if (client.paneId === semanticPaneId && !client.closed && !client.captureUnavailable) {
+                client.captureUnavailable = true;
+                this.#fault(client, "source-closed", error.message);
+            }
+    }
     retainedNativeBacking(paneId, expected) {
         const pane = this.#panes.get(paneId);
         const record = pane?.revisions.get(expected.revision);
@@ -230,6 +261,12 @@ export class SessionRuntimeTerminalDeliveryHub {
         return Object.freeze({
             clients: new Set([...this.#clients.values()].map((client) => client.clientId)).size,
             connections: this.#clients.size,
+            sourceSubscriptions: [...this.#panes.values()].filter((pane) => pane.source !== null).length,
+            pendingSourceSubscriptions: [...this.#panes.values()].filter((pane) => pane.source === null)
+                .length,
+            pendingClients: this.#pendingClients.size,
+            sourceCloseFailures: this.#sourceCloseFailures,
+            pendingSourceCloses: this.#pendingSourceCloses,
             inFlight: [...this.#clients.values()].filter((client) => client.inFlight).length,
             latestPointers: [...this.#clients.values()].filter((client) => client.latestRevision !== null)
                 .length,
@@ -293,9 +330,22 @@ export class SessionRuntimeTerminalDeliveryHub {
             pane.pendingCanonicalCells = 0;
             pane.canonicalScheduled = false;
         }
-        await Promise.allSettled(panes.map((pane) => pane.source?.close()));
+        await Promise.allSettled(panes.map((pane) => pane.source && this.#closeSource(pane.source)));
         this.#clearCache();
     }
+    async #closeSource(source) {
+        this.#pendingSourceCloses += 1;
+        try {
+            await source.close();
+        }
+        catch (error) {
+            this.#sourceCloseFailures += 1;
+            throw error;
+        }
+        finally {
+            this.#pendingSourceCloses -= 1;
+        }
+    }
     async close() {
         if (this.#closed)
             return;
@@ -346,7 +396,7 @@ export class SessionRuntimeTerminalDeliveryHub {
             if (this.#closed ||
                 this.#panes.get(semanticPaneId) !== pane ||
                 pane?.canonicalAbort.signal.aborted) {
-                await source.close();
+                await this.#closeSource(source);
                 throw new Error("Terminal delivery source retired during startup");
             }
             pane.source = source;
@@ -510,7 +560,7 @@ export class SessionRuntimeTerminalDeliveryHub {
         pane.revisions.set(update.revision, record);
         this.#pruneCanonicalRevisions(semanticPaneId);
         for (const client of this.#clients.values()) {
-            if (client.paneId !== semanticPaneId || client.closed)
+            if (client.paneId !== semanticPaneId || client.closed || client.captureUnavailable)
                 continue;
             if (!client.lifecycleOpenRecorded)
                 client.lifecycleOpenRecorded = this.#recordDeliveryLifecycle(client, pane, "open");
@@ -540,7 +590,7 @@ export class SessionRuntimeTerminalDeliveryHub {
                 pane.pendingCanonical.length = 0;
                 pane.pendingCanonicalCells = 0;
                 pane.canonicalScheduled = false;
-                void pane.source?.close().catch(() => undefined);
+                void (pane.source && this.#closeSource(pane.source).catch(() => undefined));
                 this.#clearCache();
             }, 0);
         }
@@ -581,6 +631,7 @@ export class SessionRuntimeTerminalDeliveryHub {
     }
     #schedule(client) {
         if (client.closed ||
+            client.captureUnavailable ||
             client.inFlight ||
             client.encoding ||
             client.latestRevision === null ||
@@ -613,6 +664,7 @@ export class SessionRuntimeTerminalDeliveryHub {
         if (!pane ||
             !target ||
             client.closed ||
+            client.captureUnavailable ||
             client.inFlight ||
             client.encoding ||
             client.visibility === "hidden" ||
@@ -936,7 +988,7 @@ export class SessionRuntimeTerminalDeliveryHub {
                 this.#reseeds += 1;
             }
             else {
-                const patchPayload = semanticPayload(client.baselineRevision, baseline, target);
+                const patchPayload = semanticPayload(client.baselineRevision, baseline, target, pane.revisions.get(client.baselineRevision)?.update.incarnation);
                 const seedPayload = patchPayload.frame === "tombstone" ? null : semanticSeed(target);
                 const legacyAttempts = null;
                 if (patchPayload.frame !== "patch") {
@@ -1205,6 +1257,20 @@ export class SessionRuntimeTerminalDeliveryHub {
     }
     #nack(client, input) {
         const nack = TerminalDeliveryNackSchemaZ.parse(input);
+        const closed = client.sourceClosedFlight;
+        // A decoder may have sent this NACK before observing the pane-local fault.
+        // Only the exact displaced transaction is inert; unrelated feedback still
+        // follows the normal protocol-violation path below.
+        if (client.captureUnavailable &&
+            !client.inFlight &&
+            closed &&
+            nack.workspaceName === closed.workspaceName &&
+            nack.semanticPaneId === closed.semanticPaneId &&
+            nack.generation === closed.generation &&
+            nack.incarnation === closed.incarnation &&
+            nack.deliveryNonce === closed.deliveryNonce &&
+            nack.transactionId === closed.transactionId)
+            return;
         const envelope = client.inFlight?.envelope;
         if (!envelope ||
             nack.workspaceName !== envelope.workspaceName ||
@@ -1350,7 +1416,8 @@ export class SessionRuntimeTerminalDeliveryHub {
             pane.pendingCanonicalCells = 0;
             pane.canonicalScheduled = false;
         }
-        await pane?.source?.close().catch(() => undefined);
+        if (pane?.source)
+            await this.#closeSource(pane.source).catch(() => undefined);
         this.#clearCache();
     }
     #recordDeliveryLifecycle(client, pane, event) {
@@ -1689,7 +1756,7 @@ function semanticSelectionObservationFromError(error) {
         ? error.selectionObservation
         : null;
 }
-function semanticPayload(baselineRevision, baseline, target) {
+function semanticPayload(baselineRevision, baseline, target, baselineIncarnation) {
     const update = target.update;
     if (!target.state.snapshot) {
         if (update.type !== "terminal.tombstone")
@@ -1701,8 +1768,8 @@ function semanticPayload(baselineRevision, baseline, target) {
             tombstone: update.tombstone,
         };
     }
-    // Adjacent canonical patches are already the cheapest exact diff. A skipped
-    // revision uses an atomic seed; the m56.2 adjacent reducer is never weakened.
+    // Adjacent canonical patches are already the cheapest exact diff. Preserve
+    // this direct path before considering an exact coalesced snapshot patch.
     if (baseline && update.type === "terminal.patch" && update.baseRevision === baselineRevision)
         return {
             frame: "patch",
@@ -1710,6 +1777,57 @@ function semanticPayload(baselineRevision, baseline, target) {
             revision: update.revision,
             patch: update.patch,
         };
+    // A skipped revision may still have an exact small representation. Only
+    // append-only history is proved here; trim/reflow and changed dimensions
+    // retain the full seed boundary. Equality includes wrapped and all cells.
+    const snapshot = target.state.snapshot;
+    if (baseline &&
+        baselineIncarnation === update.incarnation &&
+        baseline.cols === snapshot.cols &&
+        baseline.rows === snapshot.rows &&
+        baseline.history.length <= snapshot.history.length) {
+        // Identity reuse is cheap, but detached equal histories must not turn a
+        // cooperative seed into an unbounded synchronous cell comparison.
+        let comparisonCells = 0;
+        const equal = (left, right) => {
+            if (left === right)
+                return true;
+            comparisonCells += right.cells.length;
+            return comparisonCells <= TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS
+                ? terminalReplicaRowsEqual(left, right)
+                : null;
+        };
+        for (let index = 0; index < baseline.history.length; index++)
+            if (equal(baseline.history[index], snapshot.history[index]) !== true)
+                return semanticSeed(target);
+        const rows = [];
+        for (let index = 0; index < snapshot.grid.length; index++) {
+            const same = equal(baseline.grid[index], snapshot.grid[index]);
+            if (same === null)
+                return semanticSeed(target);
+            if (!same)
+                rows.push({ index, row: snapshot.grid[index] });
+        }
+        const appendedRows = snapshot.history.length - baseline.history.length;
+        // Compact patches serialize synchronously. Do not move a large appended
+        // suffix or repaint across the seed-only cooperative encoding boundary.
+        if ((rows.length + appendedRows) * snapshot.cols >= TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS)
+            return semanticSeed(target);
+        const append = snapshot.history.slice(baseline.history.length);
+        return {
+            frame: "patch",
+            baseRevision: baselineRevision,
+            revision: update.revision,
+            patch: {
+                rows,
+                ...(append.length ? { historyDelta: { trim: 0, append } } : {}),
+                cursor: snapshot.cursor,
+                modes: snapshot.modes,
+                placements: snapshot.placements,
+                bootstrap: snapshot.bootstrap,
+            },
+        };
+    }
     return semanticSeed(target);
 }
 /** Account represented cells without traversing/serializing the snapshot. */

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

@@ -1,10 +1,11 @@
+import { assertStockCaptureRepresentable } from "./stock-capture-fidelity.js";
 import { rememberNativeSeedBacking } from "./native-seed-backing.js";
 import { detectWidgetMarkerFromReplicaRows, } from "@tmux-ide/contracts";
 import { applyTerminalReplicaPatch, assembleTerminalReplicaSnapshot, blankTerminalReplicaSnapshot, hashTerminalReplicaSnapshot, hashTerminalReplicaTombstone, hashTerminalWidgetContent, terminalReplicaRowsEqual, } from "@tmux-ide/core";
 import { SYSTEM_SESSION_RUNTIME_SCHEDULER, } from "./runtime-scheduler.js";
 import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability.js";
 import { createXtermTerminalInterpreterBackend } from "./xterm-terminal-interpreter-backend.js";
-import { CAUSAL_CELL_OSC, CausalCellLedger, } from "./causal-cell-ledger.js";
+import { CAUSAL_CELL_OSC, CausalCellLedger, cellsEqual, } from "./causal-cell-ledger.js";
 /** Daemon-owned, sans-I/O VT interpreter with one FIFO for bytes and geometry. */
 export class TerminalReplicaInterpreter {
     #nativeSeedBackingCandidate;
@@ -110,7 +111,13 @@ export class TerminalReplicaInterpreter {
         }
         this.#flushWrites();
         const admitted = operation.type === "reseed"
-            ? { ...operation, chunks: operation.chunks.map((chunk) => chunk.slice()) }
+            ? {
+                ...operation,
+                chunks: operation.chunks.map((chunk) => Uint8Array.from(chunk)),
+                ...(operation.captureChunks
+                    ? { captureChunks: operation.captureChunks.map((chunk) => Uint8Array.from(chunk)) }
+                    : {}),
+            }
             : operation;
         return this.#append(admitted);
     }
@@ -141,8 +148,7 @@ export class TerminalReplicaInterpreter {
             seed.incarnation !== probe.incarnation ||
             this.#snapshot.cols !== probe.geometry.cols ||
             this.#snapshot.rows !== probe.geometry.rows ||
-            JSON.stringify(this.#snapshot.grid[probe.geometry.row]?.cells[probe.geometry.column]) !==
-                JSON.stringify(probe.before))
+            !cellsEqual(this.#snapshot.grid[probe.geometry.row]?.cells[probe.geometry.column], probe.before))
             throw new Error("Causal-cell baseline drifted before admission");
         const ledger = new CausalCellLedger({
             probe,
@@ -192,6 +198,8 @@ export class TerminalReplicaInterpreter {
         if (this.#closed)
             return;
         if (operation.type === "reseed") {
+            if (operation.bootstrap === "painted-capture" && !operation.native)
+                assertStockCaptureRepresentable(operation.captureChunks ?? operation.chunks);
             this.#causalCell?.fail("reseeded");
             const nativeCols = operation.nativeCols ?? operation.cols;
             const nativeRows = operation.nativeRows ?? operation.rows;
@@ -241,6 +249,15 @@ export class TerminalReplicaInterpreter {
             try {
                 this.#commit(true, undefined, operation.trace ?? null);
             }
+            catch (error) {
+                try {
+                    previous.dispose();
+                }
+                catch {
+                    // Preserve the commit failure; replacement remains owned until close.
+                }
+                throw error;
+            }
             finally {
                 this.#nativeSeedBackingCandidate = undefined;
             }

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

@@ -28,6 +28,7 @@ export class SessionRuntimeTerminalReplicaOwner {
     #reseedRetryCount = 0;
     #reseed = null;
     #bootstrapped = false;
+    #publishedIncarnation = null;
     #waitingForGeometryCapture = false;
     #historyTimer = null;
     #historyChecking = false;
@@ -61,6 +62,7 @@ export class SessionRuntimeTerminalReplicaOwner {
                 }));
             },
             onUpdate: (update, trace) => {
+                this.#publishedIncarnation = update.incarnation;
                 if (update.type === "terminal.seed") {
                     this.#bootstrapped = true;
                     this.#reseedRetryCount = 0;
@@ -135,6 +137,10 @@ export class SessionRuntimeTerminalReplicaOwner {
     failCausalCell(reason, traceId) {
         this.#interpreter.failCausalCell(reason, traceId);
     }
+    /** Scalar diagnostic only: no seed construction, hashing, or owner creation. */
+    inputDispatchIncarnation() {
+        return this.#disposed ? null : this.#publishedIncarnation;
+    }
     qualificationSnapshot() {
         const seed = this.#interpreter.currentSeed();
         return Object.freeze({
@@ -142,6 +148,11 @@ export class SessionRuntimeTerminalReplicaOwner {
             revision: seed?.revision ?? null,
             stateHash: seed?.stateHash ?? null,
             stats: this.#interpreter.stats(),
+            listeners: Object.freeze({
+                canonical: this.#listeners.size,
+                raw: this.#rawListeners.size,
+                upstream: this.#upstream ? 1 : 0,
+            }),
         });
     }
     async captureNativeBacking() {
@@ -325,6 +336,7 @@ export class SessionRuntimeTerminalReplicaOwner {
                 layoutLease: this.#layoutLease,
                 subscriptionEpoch: this.#subscriptionEpoch,
                 chunks: [],
+                captureChunks: [],
                 trace: this.#consumeOutputTrace(),
             };
         }
@@ -336,8 +348,12 @@ export class SessionRuntimeTerminalReplicaOwner {
                     this.#reseed.requiresNativeRecapture = true;
                 if (event.type === "seed" && event.native)
                     this.#reseed.native = event.native;
-                else
-                    this.#reseed.chunks.push(event.data.slice());
+                else {
+                    const bytes = Uint8Array.from(event.data);
+                    this.#reseed.chunks.push(bytes);
+                    if (event.type === "seed")
+                        this.#reseed.captureChunks.push(bytes);
+                }
             }
             else
                 this.#supervise(this.#interpreter.enqueue({
@@ -359,6 +375,7 @@ export class SessionRuntimeTerminalReplicaOwner {
                     cols: reseed.nativeCols,
                     rows: reseed.nativeRows,
                     chunks: reseed.chunks,
+                    captureChunks: reseed.captureChunks,
                     native: reseed.native,
                     historyLimit: event.historyLimit,
                     historySize: event.historySize,

package/packages/daemon/dist/terminal/session-runtime/xterm-terminal-interpreter-backend.js

@@ -2,7 +2,7 @@ import { isNativeBootstrapCapture } from "../mirror/native-grid-capture.js";
 import { projectNativeGridRow } from "../mirror/native-grid-projection.js";
 import { Terminal } from "@tmux-ide/xterm-headless";
 import { Unicode11Addon } from "@xterm/addon-unicode11";
-import { freezeTerminalReplicaRow } from "@tmux-ide/core";
+import { createProjectedTerminalReplicaRowBuilder } from "@tmux-ide/core";
 /** Pinned xterm 6 adapter and the rollback oracle for native backends. */
 export class XtermTerminalInterpreterBackend {
     kind = "xterm";
@@ -429,21 +429,20 @@ function projectRowCached(cache, buffer, index, cols) {
             return prior.row;
     }
     const cell = buffer.getNullCell();
-    const cells = [];
+    const builder = createProjectedTerminalReplicaRowBuilder();
     for (let column = 0; column < cols; column += 1) {
         line?.getCell(column, cell);
-        cells.push({
-            // Empty width-one cells are unused storage; literal spaces are content.
-            // Both paint as blanks, but preserving the distinction is necessary for
-            // reflow and for recognizing padding before a wrapped wide glyph.
-            grapheme: line && column + cell.getWidth() <= cols ? cell.getChars() : "",
-            width: line && column + cell.getWidth() <= cols ? cell.getWidth() : 1,
-            foreground: line ? cellColor(cell, "foreground") : { kind: "default" },
-            background: line ? cellColor(cell, "background") : { kind: "default" },
-            attributes: line ? cellAttributes(cell) : 0,
-        });
+        // Compute the same clipped cell values before selecting trusted blanks.
+        const grapheme = line && column + cell.getWidth() <= cols ? cell.getChars() : "";
+        const width = line && column + cell.getWidth() <= cols ? cell.getWidth() : 1;
+        const foregroundKind = line ? cellColorKind(cell, "foreground") : "default";
+        const foregroundValue = line ? cell.getFgColor() : 0;
+        const backgroundKind = line ? cellColorKind(cell, "background") : "default";
+        const backgroundValue = line ? cell.getBgColor() : 0;
+        const attributes = line ? cellAttributes(cell) : 0;
+        builder.append(grapheme, width, attributes, foregroundKind, foregroundValue, backgroundKind, backgroundValue);
     }
-    const row = freezeTerminalReplicaRow({ cells, wrapped: line?.isWrapped ?? false });
+    const row = builder.finish(line?.isWrapped ?? false);
     if (line && cacheKey)
         cache.set(cacheKey, {
             data: lineData(line)?.slice() ?? null,
@@ -474,15 +473,14 @@ function rawRowsEqual(left, right) {
             return false;
     return true;
 }
-function cellColor(cell, channel) {
+function cellColorKind(cell, channel) {
     const rgb = channel === "foreground" ? cell.isFgRGB() : cell.isBgRGB();
     const palette = channel === "foreground" ? cell.isFgPalette() : cell.isBgPalette();
-    const value = channel === "foreground" ? cell.getFgColor() : cell.getBgColor();
     if (rgb)
-        return { kind: "rgb", value };
+        return "rgb";
     if (palette)
-        return { kind: "indexed", index: value };
-    return { kind: "default" };
+        return "indexed";
+    return "default";
 }
 function cellAttributes(cell) {
     return ((cell.isBold() ? 1 : 0) |
@@ -494,7 +492,7 @@ function cellAttributes(cell) {
         (cell.isInvisible() ? 64 : 0) |
         (cell.isStrikethrough() ? 128 : 0));
 }
-/** Inverse of this pinned adapter's cellColor/cellAttributes projection. */
+/** Inverse of this pinned adapter's cellColorKind/cellAttributes projection. */
 function nativeImportAttributes(cell) {
     const color = (value) => value.kind === "default"
         ? 0