tmux-ide 2.9.4 → 2.9.6

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"

package/packages/daemon/src/tui/mirror/open-tui-workspace-runtime-port.ts

@@ -1,3 +1,4 @@
+import { STOCK_CAPTURE_TAB_UNAVAILABLE } from "@tmux-ide/contracts";
 import { randomUUID } from "node:crypto";
 import type {
   WindowLinkTopology,
@@ -357,7 +358,12 @@ function updateFromDelivery(
     stateHash: envelope.canonicalStateHash,
     hashAlgorithm: "fnv1a64-v1" as const,
   };
-  if (payload.frame === "seed") {
+  // Wire patches may span skipped revisions; ordinary canonical patches may not.
+  // Publish the fully verified resulting state at its actual revision.
+  if (
+    payload.frame === "seed" ||
+    (payload.frame === "patch" && payload.revision > payload.baseRevision + 1)
+  ) {
     return Object.freeze({
       ...common,
       type: "terminal.seed" as const,
@@ -410,6 +416,7 @@ class WireTerminalEndpoint {
   #resolveReady!: (ready: boolean) => void;
   #readySettled = false;
   #hasCanonicalSeed = false;
+  #unavailable: string | null = null;
 
   constructor(options: {
     workspaceName: string;
@@ -450,8 +457,14 @@ class WireTerminalEndpoint {
     this.#resolveReady(true);
   }
 
+  get settled(): boolean {
+    return this.#unavailable !== null || this.inputReady;
+  }
+
   get inputReady(): boolean {
-    return !this.#closed && this.#hasCanonicalSeed && !this.#reseedRequired;
+    return (
+      !this.#closed && this.#unavailable === null && this.#hasCanonicalSeed && !this.#reseedRequired
+    );
   }
 
   async subscription(): Promise<
@@ -477,6 +490,7 @@ class WireTerminalEndpoint {
       },
     );
     this.#subscription = subscription;
+    if (this.#unavailable) subscription.unavailable(this.#unavailable);
     return subscription;
   }
 
@@ -489,6 +503,24 @@ class WireTerminalEndpoint {
       return;
     }
     if (message.type === "terminal.delivery.fault") {
+      if (message.deliveryNonce !== this.#negotiated.deliveryNonce) {
+        this.#failConnection(new Error("Terminal fault nonce does not match negotiation"));
+        return;
+      }
+      // The exact shared diagnostic is currently the compatibility-preserving discriminator.
+      if (message.reason === "source-closed" && message.message === STOCK_CAPTURE_TAB_UNAVAILABLE) {
+        this.#unavailable = message.message;
+        this.#decodeToken = null;
+        this.#assembler = null;
+        this.#assemblyStorage = null;
+        this.#envelope = null;
+        this.#pending = null;
+        this.#canonicalSnapshot = null;
+        this.#hasCanonicalSeed = false;
+        this.#subscription?.unavailable(message.message);
+        this.#canonicalSeedReady();
+        return;
+      }
       const detail = message.message.trim();
       this.#failConnection(
         new Error(
@@ -497,6 +529,7 @@ class WireTerminalEndpoint {
       );
       return;
     }
+    if (this.#unavailable) return;
     if (message.type === "terminal.delivery") {
       this.#acceptEnvelope(message);
       return;
@@ -859,6 +892,31 @@ class WireTerminalSubscription implements SessionRuntimeTerminalSubscription<
   readonly #didClose: () => void;
   frozen = false;
   closed = false;
+  #unavailable: string | null = null;
+  readonly #unavailableListeners = new Set<(message: string) => void>();
+  onUnavailable(listener: (message: string) => void): () => void {
+    if (this.closed) return () => {};
+    this.#unavailableListeners.add(listener);
+    if (this.#unavailable) {
+      try {
+        listener(this.#unavailable);
+      } catch {
+        /* Availability observers cannot interrupt sibling delivery. */
+      }
+    }
+    return () => this.#unavailableListeners.delete(listener);
+  }
+  unavailable(message: string): void {
+    if (this.closed) return;
+    this.#unavailable = message;
+    for (const listener of [...this.#unavailableListeners]) {
+      try {
+        listener(message);
+      } catch {
+        /* Availability observers cannot interrupt sibling delivery. */
+      }
+    }
+  }
 
   constructor(generation: string, flush: () => void, didClose: () => void) {
     this.generation = generation;
@@ -901,6 +959,7 @@ class WireTerminalSubscription implements SessionRuntimeTerminalSubscription<
     if (this.closed) return;
     this.closed = true;
     this.#listeners.clear();
+    this.#unavailableListeners.clear();
     this.#didClose();
   }
 }
@@ -1472,7 +1531,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(
       });
       return request.result;
     }
-    if ([...endpoints.values()].some((endpoint) => !endpoint.inputReady))
+    if ([...endpoints.values()].some((endpoint) => !endpoint.settled))
       return Promise.resolve("geometry-authority-conflict");
     return (
       semanticWindowId === undefined
@@ -1525,7 +1584,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(
       if (
         closed ||
         !latestLayoutSnapshot.windowLinks ||
-        [...endpoints.values()].some((endpoint) => !endpoint.inputReady)
+        [...endpoints.values()].some((endpoint) => !endpoint.settled)
       )
         throw new Error("Terminal inventory is still receiving canonical state");
       return (await opened.submitIntent(operationId, intent)) ?? undefined;

package/packages/daemon/src/tui/mirror/pane-surface.tsx

@@ -709,7 +709,15 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
     }
     if (this._needsWalk) {
       this._needsWalk = false;
-      this.walk();
+      try {
+        this.walk();
+      } catch (error) {
+        // The source may have consumed its dirty rows before a grapheme or
+        // presentation pass fails. Rebuild the retained surface on retry.
+        this._needsWalk = true;
+        this._forceFull = true;
+        throw error;
+      }
     } else if (this._needsCursorPresentation) {
       this.applyCursorOnlyPresentation();
     }

package/packages/daemon/src/tui/mirror/reference-performance-trace.ts

@@ -59,14 +59,30 @@ export interface ReferenceTraceWriterSnapshot {
   readonly firstDroppedRecord: ReferenceTraceDroppedRecordKind | null;
 }
 
+export interface ReferenceInputAttempts {
+  readonly begun: number;
+  readonly completed: number;
+  readonly superseded: number;
+  readonly expired: number;
+  readonly cancelled: number;
+  readonly pending: number;
+}
+
+interface ReferenceInputReport {
+  readonly pendingInputs: number;
+  readonly droppedInputs: number;
+  readonly inputAttempts?: ReferenceInputAttempts;
+}
+
 export interface ReferenceTraceCollectorReport extends ReferenceTraceWriterSnapshot {
   readonly pendingInputs: number;
   readonly droppedInputs: number;
+  readonly inputAttempts?: ReferenceInputAttempts;
 }
 
 interface ReferencePerformanceTraceSink extends TuiPerformanceEventSink {
-  snapshot(): { readonly pendingInputs: number; readonly droppedInputs: number };
-  close(): { readonly pendingInputs: number; readonly droppedInputs: number };
+  snapshot(): ReferenceInputReport & { readonly inputAttempts: ReferenceInputAttempts };
+  close(): ReferenceInputReport & { readonly inputAttempts: ReferenceInputAttempts };
 }
 
 interface ActiveCollector {
@@ -137,10 +153,7 @@ export function createReferenceTraceWriter(
   readonly append: (value: Readonly<Record<string, unknown>>) => void;
   readonly appendCritical: (value: Readonly<Record<string, unknown>>) => void;
   readonly snapshot: () => ReferenceTraceWriterSnapshot;
-  readonly close: (sink: {
-    readonly pendingInputs: number;
-    readonly droppedInputs: number;
-  }) => Promise<ReferenceTraceCollectorReport>;
+  readonly close: (sink: ReferenceInputReport) => Promise<ReferenceTraceCollectorReport>;
 } {
   let acceptedRecords = 0;
   let droppedRecords = 0;
@@ -241,13 +254,13 @@ export function createReferenceTraceWriter(
       firstDroppedRecord ??= droppedRecordKind(value);
       return;
     }
-    const line = `${JSON.stringify(value)}\n`;
-    const bytes = Buffer.byteLength(line);
-    if (bytes > MAX_TRACE_RECORD_BYTES) {
-      oversizedRecords += 1;
-      return;
-    }
     try {
+      const line = `${JSON.stringify(value)}\n`;
+      const bytes = Buffer.byteLength(line);
+      if (bytes > MAX_TRACE_RECORD_BYTES) {
+        oversizedRecords += 1;
+        return;
+      }
       if (!saturated && pendingCount() === 0) {
         writeLine(line);
         return;
@@ -273,10 +286,7 @@ export function createReferenceTraceWriter(
   const append = (value: Readonly<Record<string, unknown>>): void => appendValue(value, false);
   const appendCritical = (value: Readonly<Record<string, unknown>>): void =>
     appendValue(value, true);
-  const close = (sink: {
-    readonly pendingInputs: number;
-    readonly droppedInputs: number;
-  }): Promise<ReferenceTraceCollectorReport> => {
+  const close = (sink: ReferenceInputReport): Promise<ReferenceTraceCollectorReport> => {
     if (closePromise) return closePromise;
     closed = true;
     closePromise = (async () => {
@@ -322,8 +332,14 @@ export function createReferenceTraceWriter(
 function droppedRecordKind(
   value: Readonly<Record<string, unknown>>,
 ): ReferenceTraceDroppedRecordKind {
-  const field = (key: "type" | "stage" | "operation") =>
-    typeof value[key] === "string" ? value[key].slice(0, 64) : null;
+  const field = (key: "type" | "stage" | "operation") => {
+    try {
+      const result = value[key];
+      return typeof result === "string" ? result.slice(0, 64) : null;
+    } catch {
+      return null;
+    }
+  };
   return Object.freeze({
     type: field("type"),
     stage: field("stage"),
@@ -374,7 +390,13 @@ export function createReferencePerformanceTraceSink(options: {
   >();
   let droppedInputs = 0;
   let closed = false;
-  const snapshot = () => Object.freeze({ pendingInputs: inputs.size, droppedInputs });
+  const attempts = { begun: 0, completed: 0, superseded: 0, expired: 0, cancelled: 0 };
+  const snapshot = () =>
+    Object.freeze({
+      pendingInputs: inputs.size,
+      droppedInputs,
+      inputAttempts: Object.freeze({ ...attempts, pending: inputs.size }),
+    });
   return Object.freeze({
     detailedWindowPresentationFrames: detailed ? true : undefined,
     frame: (intervalMs: number, window?: TuiWindowPresentationFrameEvidence | null) => {
@@ -578,71 +600,81 @@ export function createReferencePerformanceTraceSink(options: {
         }
       : {}),
     beginTerminalInput: (origin?: TuiTerminalInputOrigin) => {
-      const startedAtMicros = nowMicros();
-      expireInputs(inputs, startedAtMicros);
-      // The transport carries one latest-only performance trace id. Once a
-      // newer input is admitted, an older probe can no longer be attributed to
-      // the exact changed-cell paint without lying. Retire it as superseded;
-      // `droppedInputs` is reserved for actual capacity loss.
-      inputs.clear();
-      while (inputs.size >= MAX_PENDING_INPUTS) {
-        inputs.delete(inputs.keys().next().value!);
-        droppedInputs += 1;
-      }
-      const traceId = createTraceId();
-      if (
-        (detailed || options.inputOrigin) &&
-        origin &&
-        !closed &&
-        typeof options.inputFingerprintKey === "string" &&
-        options.inputFingerprintKey.length >= 32
-      ) {
-        const payload = Buffer.from(origin.payload);
-        const event: TuiTerminalInputOriginEvent = {
-          processId,
-          clockId: "opentui-performance-now",
-          clockKind: "performance-now",
-          atMicros:
-            Number.isSafeInteger(origin.ingressAtMicros) &&
-            origin.ingressAtMicros! <= startedAtMicros
-              ? origin.ingressAtMicros!
-              : startedAtMicros,
-          origin: origin.origin,
-          payloadByteCount: payload.byteLength,
-          payloadFingerprint: createHmac("sha256", options.inputFingerprintKey)
-            .update(traceId)
-            .update("\0")
-            .update(payload)
-            .digest("hex"),
-          parserConsumption:
-            origin.origin === "keyboard"
-              ? "keyboard-event"
-              : origin.origin === "bracketed-paste"
-                ? "paste-event"
-                : "pointer-event",
-          ...(origin.gestureId ? { gestureId: origin.gestureId } : {}),
-          ...(origin.pointerAction ? { pointerAction: origin.pointerAction } : {}),
-          ...(Number.isSafeInteger(origin.pointerColumn)
-            ? { pointerColumn: origin.pointerColumn }
-            : {}),
-          ...(Number.isSafeInteger(origin.pointerRow) ? { pointerRow: origin.pointerRow } : {}),
-          ...(origin.pointerButton === null || Number.isSafeInteger(origin.pointerButton)
-            ? { pointerButton: origin.pointerButton }
-            : {}),
-          traceId,
-          semanticPaneId: origin.semanticPaneId,
-          generation: origin.generation,
-          incarnation: origin.incarnation,
-          revision: origin.revision,
-          stateHash: origin.stateHash,
-        };
-        options.append({ version: 1, type: "performance.input-origin", ...event });
+      if (closed) return Object.freeze({ traceId: "", finish: () => {}, cancel: () => {} });
+      attempts.begun += 1;
+      let traceId: string;
+      try {
+        const startedAtMicros = nowMicros();
+        attempts.expired += expireInputs(inputs, startedAtMicros);
+        // The transport carries one latest-only performance trace id. Once a
+        // newer input is admitted, an older probe can no longer be attributed to
+        // the exact changed-cell paint without lying. Retire it as superseded;
+        // `droppedInputs` is reserved for actual capacity loss.
+        attempts.superseded += inputs.size;
+        inputs.clear();
+        while (inputs.size >= MAX_PENDING_INPUTS) {
+          inputs.delete(inputs.keys().next().value!);
+          droppedInputs += 1;
+          attempts.cancelled += 1;
+        }
+        traceId = createTraceId();
+        if (
+          (detailed || options.inputOrigin) &&
+          origin &&
+          !closed &&
+          typeof options.inputFingerprintKey === "string" &&
+          options.inputFingerprintKey.length >= 32
+        ) {
+          const payload = Buffer.from(origin.payload);
+          const event: TuiTerminalInputOriginEvent = {
+            processId,
+            clockId: "opentui-performance-now",
+            clockKind: "performance-now",
+            atMicros:
+              Number.isSafeInteger(origin.ingressAtMicros) &&
+              origin.ingressAtMicros! <= startedAtMicros
+                ? origin.ingressAtMicros!
+                : startedAtMicros,
+            origin: origin.origin,
+            payloadByteCount: payload.byteLength,
+            payloadFingerprint: createHmac("sha256", options.inputFingerprintKey)
+              .update(traceId)
+              .update("\0")
+              .update(payload)
+              .digest("hex"),
+            parserConsumption:
+              origin.origin === "keyboard"
+                ? "keyboard-event"
+                : origin.origin === "bracketed-paste"
+                  ? "paste-event"
+                  : "pointer-event",
+            ...(origin.gestureId ? { gestureId: origin.gestureId } : {}),
+            ...(origin.pointerAction ? { pointerAction: origin.pointerAction } : {}),
+            ...(Number.isSafeInteger(origin.pointerColumn)
+              ? { pointerColumn: origin.pointerColumn }
+              : {}),
+            ...(Number.isSafeInteger(origin.pointerRow) ? { pointerRow: origin.pointerRow } : {}),
+            ...(origin.pointerButton === null || Number.isSafeInteger(origin.pointerButton)
+              ? { pointerButton: origin.pointerButton }
+              : {}),
+            traceId,
+            semanticPaneId: origin.semanticPaneId,
+            generation: origin.generation,
+            incarnation: origin.incarnation,
+            revision: origin.revision,
+            stateHash: origin.stateHash,
+          };
+          options.append({ version: 1, type: "performance.input-origin", ...event });
+        }
+        inputs.set(traceId, {
+          startedAtMicros,
+          expiresAtMicros: startedAtMicros + INPUT_EXPIRY_MICROS,
+          endedAtMicros: null,
+        });
+      } catch (error) {
+        attempts.cancelled += 1;
+        throw error;
       }
-      inputs.set(traceId, {
-        startedAtMicros,
-        expiresAtMicros: startedAtMicros + INPUT_EXPIRY_MICROS,
-        endedAtMicros: null,
-      });
       let finished = false;
       return Object.freeze({
         traceId,
@@ -652,11 +684,16 @@ export function createReferencePerformanceTraceSink(options: {
           const input = inputs.get(traceId);
           if (input) input.endedAtMicros = nowMicros();
         },
-        cancel: () => inputs.delete(traceId),
+        cancel: () => {
+          if (inputs.delete(traceId)) attempts.cancelled += 1;
+        },
       });
     },
-    terminalTraceSpan: (paint: TuiTerminalTraceSpanEvent) =>
-      recordCompletedTrace(inputs, paint, options.append),
+    terminalTraceSpan: (paint: TuiTerminalTraceSpanEvent) => {
+      if (closed || paint.processId !== processId) return;
+      const outcome = recordCompletedTrace(inputs, paint, options.append);
+      if (outcome) attempts[outcome] += 1;
+    },
     terminalTraceStage: (event: TuiTerminalTraceStageEvent) => {
       if ((detailed || options.inputDetail) && !closed)
         options.append({ version: 1, type: "performance.stage", ...event });
@@ -675,6 +712,7 @@ export function createReferencePerformanceTraceSink(options: {
       // Shutdown cancels probes that can no longer observe a future paint.
       // They are not backpressure loss and must not survive as phantom work in
       // a closed collector summary.
+      attempts.cancelled += inputs.size;
       inputs.clear();
       return snapshot();
     },
@@ -692,12 +730,21 @@ function recordCompletedTrace(
   >,
   paint: TuiTerminalTraceSpanEvent,
   appendRecord: (value: Readonly<Record<string, unknown>>) => void,
-): void {
+): "completed" | "expired" | null {
   const input = inputs.get(paint.traceId);
-  if (!input || input.endedAtMicros === null) return;
+  if (!input || input.endedAtMicros === null) return null;
+  if (
+    paint.clockId !== "opentui-performance-now" ||
+    paint.clockKind !== "performance-now" ||
+    !Number.isFinite(paint.startedAtMicros) ||
+    !Number.isFinite(paint.endedAtMicros) ||
+    paint.startedAtMicros < input.endedAtMicros ||
+    paint.endedAtMicros < paint.startedAtMicros
+  )
+    return null;
   if (paint.startedAtMicros > input.expiresAtMicros) {
     inputs.delete(paint.traceId);
-    return;
+    return "expired";
   }
   inputs.delete(paint.traceId);
   appendRecord({
@@ -714,14 +761,18 @@ function recordCompletedTrace(
     authority: { generation: paint.generation, incarnation: paint.incarnation },
   });
   appendRecord({ version: 1, type: "performance.stage", ...paint });
+  return "completed";
 }
 
 function expireInputs(
   inputs: Map<string, { readonly expiresAtMicros: number }>,
   nowMicros: number,
-): void {
+): number {
+  let expired = 0;
   for (const [traceId, input] of inputs) {
     if (input.expiresAtMicros > nowMicros) break;
     inputs.delete(traceId);
+    expired += 1;
   }
+  return expired;
 }