tmux-ide 2.9.3 → 2.9.5

package/packages/daemon/src/terminal/session-runtime/terminal-delivery-hub.ts

@@ -1,3 +1,4 @@
+import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.ts";
 import {
   MAX_RETAINED_NATIVE_BACKING_BYTES,
   takeNativeSeedBacking,
@@ -27,6 +28,8 @@ import {
 } from "@tmux-ide/contracts";
 import {
   TerminalDeliveryStateTooLargeError,
+  terminalReplicaRowsEqual,
+  TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS,
   applyTerminalReplicaUpdate,
   applyTerminalReplicaUpdateCooperatively,
   terminalReplicaUpdateNeedsCooperativeReduction,
@@ -71,6 +74,11 @@ export interface TerminalDeliveryMetrics {
   /** Unique delivery subscribers, independent of their pane count. */
   readonly clients: number;
   readonly connections: number;
+  readonly sourceSubscriptions: number;
+  readonly sourceCloseFailures: number;
+  readonly pendingSourceCloses: number;
+  readonly pendingSourceSubscriptions: number;
+  readonly pendingClients: number;
   readonly inFlight: number;
   readonly latestPointers: number;
   readonly coalesced: number;
@@ -196,6 +204,8 @@ interface ClientState {
   readonly outgoing: Array<() => TerminalDeliveryServerMessage>;
   sending: boolean;
   retireAfterDrain: boolean;
+  /** A capture capability failure is terminal before the fault sink drains. */
+  captureUnavailable: boolean;
   lastAck: TerminalDeliveryAck | null;
   /** Delivery displaced by authoritative source close; its racing ACK is benign. */
   sourceClosedFlight: TerminalDeliveryEnvelope | null;
@@ -312,6 +322,8 @@ export class SessionRuntimeTerminalDeliveryHub {
   readonly #observability: SessionRuntimeObservability;
   readonly #panes = new Map<string, PaneState>();
   readonly #clients = new Map<string, ClientState>();
+  #sourceCloseFailures = 0;
+  #pendingSourceCloses = 0;
   /** Synchronous reservations held while an async pane source is starting. */
   readonly #pendingClients = new Map<string, string>();
   readonly #cache = new Map<string, CachedRepresentation>();
@@ -409,6 +421,7 @@ export class SessionRuntimeTerminalDeliveryHub {
         outgoing: [],
         sending: false,
         retireAfterDrain: false,
+        captureUnavailable: false,
         lastAck: null,
         sourceClosedFlight: null,
         backgroundTimer: null,
@@ -433,11 +446,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" as const),
+        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: string, error: StockCaptureTabUnavailableError): void {
+    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: string,
     expected: NativeBackingIdentity,
@@ -506,6 +545,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,
@@ -588,10 +633,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: TerminalReplicaSourceSubscription): Promise<void> {
+    this.#pendingSourceCloses += 1;
+    try {
+      await source.close();
+    } catch (error) {
+      this.#sourceCloseFailures += 1;
+      throw error;
+    } finally {
+      this.#pendingSourceCloses -= 1;
+    }
+  }
+
   async close(): Promise<void> {
     if (this.#closed) return;
     this.#closed = true;
@@ -646,7 +703,7 @@ export class SessionRuntimeTerminalDeliveryHub {
           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;
@@ -850,7 +907,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) continue;
+      if (client.paneId !== semanticPaneId || client.closed || client.captureUnavailable) continue;
       if (!client.lifecycleOpenRecorded)
         client.lifecycleOpenRecorded = this.#recordDeliveryLifecycle(client, pane, "open");
       if (
@@ -880,7 +937,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);
     }
@@ -923,6 +980,7 @@ export class SessionRuntimeTerminalDeliveryHub {
   #schedule(client: ClientState): void {
     if (
       client.closed ||
+      client.captureUnavailable ||
       client.inFlight ||
       client.encoding ||
       client.latestRevision === null ||
@@ -963,6 +1021,7 @@ export class SessionRuntimeTerminalDeliveryHub {
       !pane ||
       !target ||
       client.closed ||
+      client.captureUnavailable ||
       client.inFlight ||
       client.encoding ||
       client.visibility === "hidden" ||
@@ -1330,7 +1389,12 @@ 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") {
@@ -1663,6 +1727,22 @@ export class SessionRuntimeTerminalDeliveryHub {
 
   #nack(client: ClientState, input: TerminalDeliveryNack): void {
     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 ||
@@ -1825,7 +1905,7 @@ 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();
   }
 
@@ -2233,6 +2313,7 @@ function semanticPayload(
   baselineRevision: number,
   baseline: TerminalReplicaSnapshot | null,
   target: RevisionRecord,
+  baselineIncarnation?: string,
 ): TerminalSemanticDeliveryPayload {
   const update = target.update;
   if (!target.state.snapshot) {
@@ -2244,8 +2325,8 @@ function semanticPayload(
       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",
@@ -2253,6 +2334,59 @@ function semanticPayload(
       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: TerminalReplicaSnapshot["grid"][number],
+      right: TerminalReplicaSnapshot["grid"][number],
+    ) => {
+      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: { index: number; row: TerminalReplicaSnapshot["grid"][number] }[] = [];
+    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);
 }
 

package/packages/daemon/src/terminal/session-runtime/terminal-replica-interpreter.ts

@@ -1,3 +1,4 @@
+import { assertStockCaptureRepresentable } from "./stock-capture-fidelity.ts";
 import { rememberNativeSeedBacking } from "./native-seed-backing.ts";
 import type { NativeGridCapture } from "../mirror/native-grid-capture.ts";
 import type { MirrorObservedTerminalModes } from "../mirror/events.ts";
@@ -40,6 +41,7 @@ import { createXtermTerminalInterpreterBackend } from "./xterm-terminal-interpre
 import {
   CAUSAL_CELL_OSC,
   CausalCellLedger,
+  cellsEqual,
   type CausalCellLedgerResult,
 } from "./causal-cell-ledger.ts";
 
@@ -72,6 +74,8 @@ export type TerminalReplicaInterpreterOperation =
       readonly cols: number;
       readonly rows: number;
       readonly chunks: readonly Uint8Array[];
+      /** Explicit capture provenance; excludes post-capture live data. Legacy callers capture all chunks. */
+      readonly captureChunks?: readonly Uint8Array[];
       readonly cursor: { readonly x: number; readonly y: number };
       readonly wraparound?: boolean;
       readonly observedModes?: MirrorObservedTerminalModes;
@@ -101,6 +105,8 @@ export interface TerminalReplicaInterpreterOptions {
     readonly baseRevision: number;
     readonly revision: number;
     readonly chunks: readonly Uint8Array[];
+    /** Explicit capture provenance; excludes post-capture live data. Legacy callers capture all chunks. */
+    readonly captureChunks?: readonly Uint8Array[];
     readonly contiguous: boolean;
   }) => void;
   /** Request native truth without publishing an unknown saved-buffer projection. */
@@ -243,7 +249,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);
   }
@@ -280,8 +292,10 @@ 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({
@@ -343,6 +357,8 @@ export class TerminalReplicaInterpreter {
   ): Promise<void> {
     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;
@@ -394,6 +410,13 @@ export class TerminalReplicaInterpreter {
       this.#nativeSeedBackingCandidate = operation.native;
       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/src/terminal/session-runtime/terminal-replica-owner.ts

@@ -47,6 +47,11 @@ export interface TerminalReplicaQualificationSnapshot {
   readonly revision: number | null;
   readonly stateHash: string | null;
   readonly stats: TerminalReplicaInterpreterStats;
+  readonly listeners: {
+    readonly canonical: number;
+    readonly raw: number;
+    readonly upstream: number;
+  };
 }
 
 /** Daemon-private backing admission; this is not a client transport schema. */
@@ -72,6 +77,7 @@ interface ReseedCandidate {
   readonly layoutLease: LayoutLease | null;
   readonly subscriptionEpoch: number;
   readonly chunks: Uint8Array[];
+  readonly captureChunks: Uint8Array[];
   readonly trace: SessionRuntimeTraceContext | null;
 }
 
@@ -98,6 +104,7 @@ export class SessionRuntimeTerminalReplicaOwner {
   #reseedRetryCount = 0;
   #reseed: ReseedCandidate | null = null;
   #bootstrapped = false;
+  #publishedIncarnation: string | null = null;
   #waitingForGeometryCapture = false;
   #historyTimer: SessionRuntimeTimer | null = null;
   #historyChecking = false;
@@ -144,6 +151,7 @@ export class SessionRuntimeTerminalReplicaOwner {
         );
       },
       onUpdate: (update, trace) => {
+        this.#publishedIncarnation = update.incarnation;
         if (update.type === "terminal.seed") {
           this.#bootstrapped = true;
           this.#reseedRetryCount = 0;
@@ -224,6 +232,11 @@ export class SessionRuntimeTerminalReplicaOwner {
     this.#interpreter.failCausalCell(reason, traceId);
   }
 
+  /** Scalar diagnostic only: no seed construction, hashing, or owner creation. */
+  inputDispatchIncarnation(): string | null {
+    return this.#disposed ? null : this.#publishedIncarnation;
+  }
+
   qualificationSnapshot(): TerminalReplicaQualificationSnapshot {
     const seed = this.#interpreter.currentSeed();
     return Object.freeze({
@@ -231,6 +244,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,
+      }),
     });
   }
 
@@ -425,6 +443,7 @@ export class SessionRuntimeTerminalReplicaOwner {
         layoutLease: this.#layoutLease,
         subscriptionEpoch: this.#subscriptionEpoch,
         chunks: [],
+        captureChunks: [],
         trace: this.#consumeOutputTrace(),
       };
     } else if (event.type === "seed" || event.type === "delta") {
@@ -433,7 +452,11 @@ export class SessionRuntimeTerminalReplicaOwner {
         if (event.type === "seed" && event.requiresNativeRecapture)
           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({
@@ -456,6 +479,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/src/terminal/session-runtime/xterm-terminal-interpreter-backend.ts

@@ -10,7 +10,7 @@ import type {
   TerminalReplicaRow,
   TerminalReplicaSnapshot,
 } from "@tmux-ide/contracts";
-import { freezeTerminalReplicaRow } from "@tmux-ide/core";
+import { createProjectedTerminalReplicaRowBuilder } from "@tmux-ide/core";
 import type {
   TerminalInterpreterBackend,
   TerminalInterpreterBackendFactoryOptions,
@@ -580,21 +580,28 @@ function projectRowCached(
       return prior.row;
   }
   const cell = buffer.getNullCell();
-  const cells: TerminalReplicaCell[] = [];
+  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() as 0 | 1 | 2) : 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() as 0 | 1 | 2) : 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,
@@ -633,16 +640,15 @@ function rawRowsEqual(left: Uint32Array | null, right: Uint32Array | null): bool
   return true;
 }
 
-function cellColor(
+function cellColorKind(
   cell: ReturnType<Terminal["buffer"]["active"]["getNullCell"]>,
   channel: "foreground" | "background",
-): TerminalReplicaColor {
+): TerminalReplicaColor["kind"] {
   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 };
-  if (palette) return { kind: "indexed", index: value };
-  return { kind: "default" };
+  if (rgb) return "rgb";
+  if (palette) return "indexed";
+  return "default";
 }
 
 function cellAttributes(cell: ReturnType<Terminal["buffer"]["active"]["getNullCell"]>): number {
@@ -675,7 +681,7 @@ interface NativeImportBuffer {
   x: number;
   y: number;
 }
-/** Inverse of this pinned adapter's cellColor/cellAttributes projection. */
+/** Inverse of this pinned adapter's cellColorKind/cellAttributes projection. */
 function nativeImportAttributes(cell: TerminalReplicaCell): [number, number] {
   const color = (value: TerminalReplicaColor) =>
     value.kind === "default"