tmux-ide 2.9.10 → 2.9.12

package/packages/daemon/src/tui/mirror/runtime/renderer-probe.ts

@@ -0,0 +1,257 @@
+/** Opt-in controlled nonce workload; renderer-buffer completion, never visible pixels. */
+import type { TerminalReplicaState } from "@tmux-ide/core";
+import { visibleTerminalRowAt } from "../semantic-pane-render-source.ts";
+import type { TerminalReplicaRow, TerminalReplicaSnapshot } from "@tmux-ide/contracts";
+import type { SessionRuntimeTerminalInput } from "@tmux-ide/contracts";
+import { appendFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+export interface ProbeTrial {
+  id: string;
+  nonce: string;
+  kind?: "input" | "scroll" | "output";
+}
+export interface ProbeRecord extends ProbeTrial {
+  side: "tui";
+  kind: "input" | "scroll" | "output";
+  sourceScope: Scope;
+  expectedOffset: number;
+  sourceOffset: number;
+  expectedScope: Scope;
+  admittedAtMicros: number;
+  completedAtMicros: number;
+  witness?: { row: number; column: number; marker: string; revision: number; stateHash: string };
+  endpoint: "input-admission-to-renderer-work-complete";
+  status: "completed" | "failed";
+  durationMicros?: number;
+  reason?: string;
+}
+interface Scope {
+  pane: string;
+  generation: string;
+  incarnation: string;
+  cols: number;
+  rows: number;
+}
+function scope(state: TerminalReplicaState): Scope | null {
+  return state.snapshot
+    ? {
+        pane: state.semanticPaneId,
+        generation: state.generation,
+        incarnation: state.incarnation,
+        cols: state.snapshot.cols,
+        rows: state.snapshot.rows,
+      }
+    : null;
+}
+const key = (s: Scope) => JSON.stringify([s.pane, s.generation, s.incarnation, s.cols, s.rows]);
+export class RendererProbe {
+  #next = 0;
+  #pending: {
+    trial: ProbeTrial;
+    scope: Scope;
+    at: number;
+    marker: string;
+    offset: number;
+    sourceOffset: number;
+  } | null = null;
+  constructor(
+    private readonly trials: readonly ProbeTrial[],
+    private readonly emit: (r: ProbeRecord) => void,
+  ) {
+    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(): boolean {
+    return this.#pending !== null;
+  }
+  admit(
+    input: SessionRuntimeTerminalInput,
+    state: TerminalReplicaState | null,
+    at: number,
+  ): SessionRuntimeTerminalInput | null {
+    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: Scope,
+    snapshot: TerminalReplicaSnapshot,
+    before: number,
+    after: number,
+    at: number,
+  ): void {
+    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: number): void {
+    if (this.#pending && at - this.#pending.at > 5_000_000) this.cancel("timeout", at);
+  }
+  cancel(reason: string, at: number): void {
+    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: TerminalReplicaState | null, at: number): void {
+    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: TerminalReplicaState,
+    row: TerminalReplicaRow | undefined,
+    viewportRow: number,
+    width: number,
+    height: number,
+    left: number,
+    scrollOffset: number,
+    at: number,
+  ): void {
+    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: RendererProbe | null | undefined;
+/** All filesystem work is asynchronous and deferred; at most64 short receipts. */
+export function rendererProbe(): RendererProbe | null {
+  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: unknown = 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/src/tui/mirror/runtime/runtime-layout-presentation.ts

@@ -11,7 +11,7 @@ export interface OpenTuiRuntimeLayoutPresentation {
   getWindowSnapshot(): OpenTuiWorkspaceLayoutSnapshot;
   subscribe(listener: (layout: OpenTuiTerminalLayout | null) => void): () => void;
   subscribeWindows(listener: (layout: OpenTuiWorkspaceLayoutSnapshot) => void): () => void;
-  adopt(port: OpenTuiLayoutPort): () => void;
+  adopt(port: OpenTuiLayoutPort, rendererEpoch: number): () => void;
   clear(): void;
   dispose(): void;
 }
@@ -66,21 +66,24 @@ export function createOpenTuiRuntimeLayoutPresentation(): OpenTuiRuntimeLayoutPr
       listener(windows);
       return () => windowListeners.delete(listener);
     },
-    adopt(port) {
+    adopt(port, rendererEpoch) {
       if (disposed) return () => undefined;
       let candidate = true;
       let candidateStop: (() => void) | null = null;
       candidateStop = port.onLayout((layout) => {
         if (disposed || !candidate || !layout.current) return;
+        // A port may reuse its snapshot object. Own the provenance wrapper so
+        // a preparing runtime cannot relabel the retained coherent frame.
+        const presented = Object.freeze({ ...layout, rendererEpoch });
         if (currentPort !== port) {
           const previousStop = stopLayout;
           currentPort = port;
           stopLayout = candidateStop;
-          publish(layout);
+          publish(presented);
           previousStop?.();
           return;
         }
-        publish(layout);
+        publish(presented);
       });
       // `onLayout` intentionally seeds synchronously. Capture the disposer
       // after that first callback has promoted this candidate.

package/packages/daemon/src/tui/mirror/runtime/select-terminal-pane.ts

@@ -20,6 +20,7 @@ export type PaneSelectionFailure = Readonly<{
     | "generation-replaced"
     | "operation-timeout"
     | "transport-rejected"
+    | "topology-changed"
     | "receipt-invalid";
   backendReason?:
     | "pane_inventory_not_ready"
@@ -42,6 +43,7 @@ export async function selectTerminalPane(
   operationId?: string,
   onFailure?: (failure: PaneSelectionFailure) => void,
   windowLink?: WindowLinkTarget,
+  onDispatch?: () => void,
 ): Promise<PaneSelectionReceipt | null> {
   const fail = (failure: PaneSelectionFailure): null => {
     try {
@@ -62,7 +64,12 @@ export async function selectTerminalPane(
       : undefined;
     return fail({
       stage,
-      reason: code === "operation-timeout" ? "operation-timeout" : "transport-rejected",
+      reason:
+        code === "operation-timeout"
+          ? "operation-timeout"
+          : code === "topology-changed" && stage === "dispatch"
+            ? "topology-changed"
+            : "transport-rejected",
       ...(backendReason ? { backendReason } : {}),
     });
   };
@@ -90,6 +97,7 @@ export async function selectTerminalPane(
     if (!isCurrent()) return fail({ stage: "pre-dispatch", reason: "generation-replaced" });
     let result: unknown;
     try {
+      onDispatch?.();
       result = await expected.client.dispatch({
         kind: "semantic-intent",
         ...(operationId ? { operationId } : {}),

package/packages/daemon/src/tui/mirror/runtime/terminal-fast-lane-renderer-adapter.ts

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.ts";
 import type { ReadNativeBacking } from "../../../terminal/protocol/native-backing-client.ts";
 import type { TerminalReplicaSnapshot } from "@tmux-ide/contracts";
 import type {
@@ -637,6 +638,8 @@ export class TerminalFastLaneRendererAdapter implements PaneScopedTerminalAdapte
     // live parsing and must keep following the native pane's actual size.
     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.
@@ -992,6 +995,18 @@ export class TerminalFastLaneRendererAdapter implements PaneScopedTerminalAdapte
         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;
     }

package/packages/daemon/src/tui/mirror/runtime/terminal-selection-waiter.ts

@@ -0,0 +1,36 @@
+/** One bounded selection observation; never submits or repeats a mutation. */
+export function createTerminalSelectionWaiter() {
+  let pending: {
+    check: () => boolean | "pending";
+    finish: (selected: boolean) => void;
+  } | null = null;
+  const cancel = () => pending?.finish(false);
+  const reconcile = () => {
+    const waiting = pending;
+    if (!waiting) return;
+    const result = waiting.check();
+    if (result !== "pending") waiting.finish(result);
+  };
+  return {
+    cancel,
+    reconcile,
+    wait(check: () => boolean | "pending"): Promise<boolean> {
+      cancel();
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => waiting.finish(false), 5000);
+        timer.unref?.();
+        const waiting = {
+          check,
+          finish(selected: boolean) {
+            if (pending !== waiting) return;
+            pending = null;
+            clearTimeout(timer);
+            resolve(selected);
+          },
+        };
+        pending = waiting;
+        reconcile();
+      });
+    },
+  };
+}

package/packages/daemon/src/tui/mirror/semantic-pane-render-source.ts

@@ -202,6 +202,10 @@ export class SemanticPaneReplica {
   }
 
   accept(message: TerminalDeliveryServerMessage): void {
+    if (message.type === "terminal.projection") {
+      this.#fail("protocol-violation", message.transactionId);
+      return;
+    }
     if (message.type === "terminal.delivery.fault") {
       this.#assembler = null;
       this.#snapshot = null;

package/packages/daemon-client/src/pane-stream-client.ts

@@ -1,5 +1,12 @@
 import {
   PANE_STREAM_ISSUE_PATH,
+  decodeTerminalDeliveryBinaryChunk,
+  decodeTerminalGraphicsBinary,
+  TERMINAL_DELIVERY_BINARY_CAPABILITY_VERSION,
+  TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION,
+  PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION,
+  PaneStreamInputLifetimeSchemaZ,
+  type PaneStreamInputLifetime,
   PANE_STREAM_PROTOCOL_VERSION,
   PaneStreamClientFrameSchemaZ,
   PaneStreamIssueMutationRequestSchemaZ,
@@ -116,6 +123,7 @@ function createRuntimeTimer(callback: () => void, delayMs: number): RuntimeTimer
 
 export interface PaneStreamClientSocket {
   readonly readyState: number;
+  binaryType?: string;
   /** Optional native/socket queue watermark in bytes. */
   readonly bufferedAmount?: number;
   addEventListener(type: SocketEventType, listener: SocketListener): void;
@@ -343,6 +351,8 @@ export interface PaneStreamRuntimeClient {
   readonly effectiveViewerMode: PaneStreamIssueDescriptor["effectiveViewerMode"];
   readonly authoritySnapshot: SessionRuntimeAuthoritySnapshot | null;
   readonly connectionClientId: string | null;
+  readonly supportsInputLifetime?: boolean;
+  readonly supportsInputBytes?: boolean;
   ownsConnectionAuthority(authority: SessionRuntimeAuthorityKind): boolean;
   connectionAuthorityClientId(authority: SessionRuntimeAuthorityKind): string | null;
   setPresence(state: SessionRuntimePresenceState): void;
@@ -358,6 +368,7 @@ export interface PaneStreamRuntimeClient {
     input: SessionRuntimeTerminalInput,
     performanceTraceId?: string,
     causalProbe?: CausalCellProbeRequestV1,
+    expectedLifetime?: PaneStreamInputLifetime,
   ): Promise<SessionRuntimeTerminalInputResult>;
   sendText(pane: string, text: string, performanceTraceId?: string): void;
   sendKey(pane: string, key: string, performanceTraceId?: string): void;
@@ -452,6 +463,7 @@ export async function connectIssuedPaneStreamRuntimeClient(
     "X-Tmux-Ide-Host-Client-Id": options.hostClientId,
     "X-Tmux-Ide-Request-Id": descriptor.requestId,
   });
+  socket.binaryType = "arraybuffer";
   options.onConnectionDiagnostic?.("socket-created", { requestId: descriptor.requestId });
   const releaseSocketResource = acquireRuntimeResource("pane-stream-socket");
   const releaseSocketListenerResources = acquireRuntimeResource("socket-listener", 4);
@@ -470,6 +482,13 @@ export async function connectIssuedPaneStreamRuntimeClient(
   };
   let closed = false;
   let verified = false;
+  const binaryPanes = new Set<string>();
+  const binaryGraphicsPanes = new Set<string>();
+  const offeredBinary = options.stream.terminalDelivery.protocolVersions.some(
+    (version) =>
+      version === TERMINAL_DELIVERY_BINARY_CAPABILITY_VERSION ||
+      version === TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION,
+  );
   let layoutTopologyEpoch = -1;
   let windowLinks: WindowLinkTopology | null = null;
   let resolveReady!: (client: PaneStreamRuntimeClient) => void;
@@ -984,13 +1003,24 @@ export async function connectIssuedPaneStreamRuntimeClient(
     connectionAuthorityReleases.set(authority, release);
     return release;
   };
+  let supportsInputLifetime = false;
+  let supportsInputBytes = false;
   const sendTerminalInput = (
     target: TerminalReplicaAddress,
     rawInput: SessionRuntimeTerminalInput,
     performanceTraceId?: string,
     causalProbeRequest?: CausalCellProbeRequestV1,
+    expectedLifetime?: PaneStreamInputLifetime,
   ): Promise<SessionRuntimeTerminalInputResult> => {
+    if (expectedLifetime && !supportsInputLifetime)
+      return Promise.reject(new Error("Input lifetime capability unavailable"));
+    const lifetime =
+      expectedLifetime === undefined
+        ? undefined
+        : PaneStreamInputLifetimeSchemaZ.parse(expectedLifetime);
     const input = SessionRuntimeTerminalInputSchemaZ.parse(rawInput);
+    if (input.kind === "bytes" && !supportsInputBytes)
+      return Promise.reject(new Error("Byte input capability unavailable"));
     const pane = target.semanticPaneId;
     if (!descriptor.panes.includes(pane)) {
       return Promise.reject(
@@ -1087,6 +1117,7 @@ export async function connectIssuedPaneStreamRuntimeClient(
             seq: sequence,
             ...(performanceTraceId ? { performanceTraceId } : {}),
             ...(causalProbe ? { causalProbe } : {}),
+            ...(lifetime ? { expectedLifetime: lifetime } : {}),
           },
           Boolean(transportStage),
         );
@@ -1234,7 +1265,41 @@ export async function connectIssuedPaneStreamRuntimeClient(
     );
   };
   const onMessage: SocketListener = (event) => {
-    if (closed || typeof event.data !== "string") return fail("Pane-stream frame was not text");
+    if (closed) return;
+    if (typeof event.data !== "string") {
+      if (!verified) return fail("Binary pane-stream frame before readiness");
+      const data =
+        event.data instanceof ArrayBuffer
+          ? new Uint8Array(event.data)
+          : event.data instanceof Uint8Array
+            ? event.data
+            : null;
+      if (!data) return fail("Unsupported binary pane-stream data");
+      try {
+        if (data[0] === 84 && data[1] === 68 && data[2] === 67 && data[3] === 49) {
+          const { header, bytes } = decodeTerminalDeliveryBinaryChunk(data);
+          if (!descriptor.panes.includes(header.pane) || !binaryPanes.has(header.pane))
+            return fail("Unnegotiated binary terminal delivery");
+          options.onTerminalDelivery(header.pane, {
+            type: "terminal.delivery.chunk",
+            transactionId: header.transactionId,
+            index: header.index,
+            bytes:
+              bytes.buffer instanceof ArrayBuffer
+                ? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+                : bytes.slice(),
+          });
+        } else {
+          const { header, bytes } = decodeTerminalGraphicsBinary(data);
+          if (!descriptor.panes.includes(header.pane) || !binaryGraphicsPanes.has(header.pane))
+            return fail("Unnegotiated binary graphics delivery");
+          options.onTerminalGraphicsBlob?.(header.pane, header.blob, bytes);
+        }
+      } catch {
+        return fail("Invalid binary pane-stream frame");
+      }
+      return;
+    }
     const arrivedAtMicros = options.onTerminalFrameArrival
       ? Math.floor(performance.now() * 1_000)
       : 0;
@@ -1285,6 +1350,12 @@ export async function connectIssuedPaneStreamRuntimeClient(
       )
         return fail("Pane-stream peer client identity did not match the redeemed connection");
       connectionClientId = frame.connectionClientId ?? null;
+      supportsInputLifetime = frame.inputLifetime === true;
+      supportsInputBytes =
+        frame.inputBytes === true &&
+        options.stream.terminalDelivery.protocolVersions.includes(
+          PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION,
+        );
       verified = true;
       options.onConnectionDiagnostic?.("ready-frame", {
         requestId: descriptor.requestId,
@@ -1370,7 +1441,21 @@ export async function connectIssuedPaneStreamRuntimeClient(
       options.onCausalCellFailure?.(frame.failure);
       return;
     }
+    if (frame.type === "terminal-graphics") {
+      if (!descriptor.panes.includes(frame.pane)) return fail("Unissued graphics pane");
+      if (frame.state.binaryBlobs === true) binaryGraphicsPanes.add(frame.pane);
+      else binaryGraphicsPanes.delete(frame.pane);
+    }
     if (frame.type === "terminal-delivery-ready") {
+      if (!descriptor.panes.includes(frame.pane)) return fail("Unissued terminal pane");
+      binaryPanes.delete(frame.pane);
+      if (
+        frame.negotiation.accepted &&
+        frame.negotiation.negotiated.encoding === "semantic-binary-v1"
+      ) {
+        if (!offeredBinary) return fail("Unsolicited binary terminal negotiation");
+        binaryPanes.add(frame.pane);
+      }
       if (frame.negotiation.accepted) {
         negotiatedDeliveries.set(frame.pane, {
           generation: frame.negotiation.negotiated.generation,
@@ -1553,6 +1638,12 @@ export async function connectIssuedPaneStreamRuntimeClient(
       send({ type: "activity", generation: descriptor.daemonInstanceId, activity }),
     requestAuthority,
     releaseAuthority,
+    get supportsInputBytes() {
+      return supportsInputBytes;
+    },
+    get supportsInputLifetime() {
+      return supportsInputLifetime;
+    },
     sendTerminalInput,
     sendText: (pane, text, performanceTraceId) => {
       void sendTerminalInput(