tmux-ide 2.9.11 → 2.9.13

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace.tsx

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.ts";
 import { paneInteractionDisplayDestination } from "../ui/pane-interaction-presentation.ts";
 import type { InteractionObservationStatus, NativePaneIdentity } from "@tmux-ide/contracts";
 import { interactionPaneEndpointKey } from "@tmux-ide/core";
@@ -1350,6 +1351,7 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
       return;
     }
     if (event.type === "scroll") {
+      const probeAt = rendererProbe() ? Math.floor(performance.now() * 1000) : 0;
       // A held selection owns the gesture even when the pointer crosses a sibling.
       const activeSelection = selecting;
       const selectionCell =
@@ -1359,7 +1361,10 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
         activeSelection && selectionCell
           ? { frame: activeSelection.frame, ...selectionCell }
           : paneContentAt(point);
-      const before = props.onWheelObservation && hit ? scrollback.offset(hit.frame.paneId) : null;
+      const before =
+        (props.onWheelObservation || rendererProbe()) && hit
+          ? scrollback.offset(hit.frame.paneId)
+          : null;
       const observe = (route: string): void => {
         props.onWheelObservation?.({
           paneId: hit?.frame.paneId ?? null,
@@ -1457,6 +1462,20 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
           scrollback.seek(hit.frame.paneId, { ...origin, y: next.originY });
           setKeyboardCopy({ ...keyboard, cursor: next.cursor });
         } else scrollback.move(hit.frame.paneId, motion.lines);
+        if (rendererProbe() && identity && before !== null)
+          rendererProbe()?.scroll(
+            {
+              pane: hit.frame.paneId,
+              generation: identity.generation,
+              incarnation: identity.incarnation,
+              cols: snapshot.cols,
+              rows: snapshot.rows,
+            },
+            snapshot,
+            before,
+            scrollback.offset(hit.frame.paneId),
+            probeAt,
+          );
         observe("local-history");
         if (selecting?.paneId === hit.frame.paneId) updatePointerSelection(selecting.pointer);
         else {

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/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/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,10 @@
 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,
@@ -118,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;
@@ -346,6 +352,7 @@ export interface PaneStreamRuntimeClient {
   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;
@@ -456,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);
@@ -474,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;
@@ -989,6 +1004,7 @@ export async function connectIssuedPaneStreamRuntimeClient(
     return release;
   };
   let supportsInputLifetime = false;
+  let supportsInputBytes = false;
   const sendTerminalInput = (
     target: TerminalReplicaAddress,
     rawInput: SessionRuntimeTerminalInput,
@@ -1003,6 +1019,8 @@ export async function connectIssuedPaneStreamRuntimeClient(
         ? 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(
@@ -1247,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;
@@ -1299,6 +1351,11 @@ 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,
@@ -1384,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,
@@ -1567,6 +1638,9 @@ export async function connectIssuedPaneStreamRuntimeClient(
       send({ type: "activity", generation: descriptor.daemonInstanceId, activity }),
     requestAuthority,
     releaseAuthority,
+    get supportsInputBytes() {
+      return supportsInputBytes;
+    },
     get supportsInputLifetime() {
       return supportsInputLifetime;
     },