tmux-ide 2.9.7 → 2.9.8

package/packages/daemon/dist/terminal/mirror/session-channel.js

@@ -853,7 +853,50 @@ export class SessionChannel {
         this.input.flush();
         this.clearWindowViewports();
         this.restoreWindowSizing(this.attachedIdentity?.runtimeSessionId ?? `=${this.opts.session}`);
-        this.io.send(`refresh-client -C ${cols}x${rows}`);
+        this.io.send(`refresh-client -C ${cols}x${rows}${this.cellPixelSuffix()}`);
+        this.clientViewport = { cols, rows };
+    }
+    clientViewport = null;
+    cellPixels = null;
+    /** "/WxH" for tmux's refresh-client -C (patched tmux; stock ignores it). */
+    cellPixelSuffix() {
+        if (!this.cellPixels)
+            return "";
+        const { width, height, precise } = this.cellPixels;
+        return `/${width}x${height}` + (precise ? `/${precise.width}x${precise.height}` : "");
+    }
+    /**
+     * The renderer's cell size in device pixels. tmux answers CSI 14t/16t and
+     * sets TIOCGWINSZ pixels from it, so image programs render 1:1 for the
+     * window. Re-applies the current viewport when the size changes.
+     */
+    setCellPixels(width, height, precise) {
+        if (!Number.isSafeInteger(width) ||
+            !Number.isSafeInteger(height) ||
+            width < 1 ||
+            height < 1 ||
+            width > 1024 ||
+            height > 1024)
+            throw new RangeError("cell pixel size out of range");
+        if (precise &&
+            [precise.width, precise.height].some((value) => !Number.isSafeInteger(value) || value < 1000 || value > 1024000))
+            throw new RangeError("precise cell pixel size out of range");
+        if (this.cellPixels?.width === width &&
+            this.cellPixels.height === height &&
+            this.cellPixels.precise?.width === precise?.width &&
+            this.cellPixels.precise?.height === precise?.height)
+            return;
+        this.cellPixels = { width, height, ...(precise ? { precise } : {}) };
+        if (!this.geometryParticipating)
+            return;
+        this.input.flush();
+        if (this.fittedWindows.size > 0) {
+            for (const [runtimeId, size] of this.fittedWindows)
+                if (this.windowsByRuntime.has(runtimeId))
+                    this.io.send(`refresh-client -C ${runtimeId}:${size.cols}x${size.rows}${this.cellPixelSuffix()}`);
+        }
+        else if (this.clientViewport)
+            this.io.send(`refresh-client -C ${this.clientViewport.cols}x${this.clientViewport.rows}${this.cellPixelSuffix()}`);
     }
     restoreWindowSizing(target) {
         if (!this.geometryParticipating)
@@ -894,7 +937,7 @@ export class SessionChannel {
             return;
         this.input.flush();
         this.restoreWindowSizing(window.runtimeId);
-        this.io.send(`refresh-client -C ${window.runtimeId}:${cols}x${rows}`);
+        this.io.send(`refresh-client -C ${window.runtimeId}:${cols}x${rows}${this.cellPixelSuffix()}`);
         this.fittedWindows.set(window.runtimeId, { cols, rows });
     }
     /** Must also run on geometry-owner handoff, before the next owner fits. */

package/packages/daemon/dist/terminal/pane-stream/pane-stream-websocket.js

@@ -1,6 +1,7 @@
+import { inflateSync } from "node:zlib";
 import { PaneStreamLayoutSnapshotFrameSchemaZ } from "@tmux-ide/contracts";
 import { z } from "zod";
-import { PANE_STREAM_MAX_HELD_DELTAS, PANE_STREAM_MAX_OUTPUT_BYTES, PANE_STREAM_MAX_PANES, PANE_STREAM_MAX_SEED_BYTES, PANE_STREAM_PROTOCOL_VERSION, PANE_STREAM_REDEEM_PATH, PANE_STREAM_WEBSOCKET_SUBPROTOCOL, TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES, PaneStreamClientFrameSchemaZ, PaneStreamLoopbackWebSocketUrlSchemaZ, PaneStreamRedeemFrameSchemaZ, PaneStreamServerFrameSchemaZ, sharedMonotonicMicros, } from "@tmux-ide/contracts";
+import { PANE_STREAM_MAX_HELD_DELTAS, PANE_STREAM_MAX_OUTPUT_BYTES, PANE_STREAM_MAX_PANES, PANE_STREAM_MAX_SEED_BYTES, PANE_STREAM_PROTOCOL_VERSION, PANE_STREAM_REDEEM_PATH, PANE_STREAM_WEBSOCKET_SUBPROTOCOL, TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES, TERMINAL_GRAPHICS_CELL_PIXELS_CAPABILITY_VERSION, TERMINAL_GRAPHICS_PRECISE_PIXELS_CAPABILITY_VERSION, TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES, TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION, PaneStreamClientFrameSchemaZ, PaneStreamLoopbackWebSocketUrlSchemaZ, PaneStreamRedeemFrameSchemaZ, PaneStreamServerFrameSchemaZ, sharedMonotonicMicros, } from "@tmux-ide/contracts";
 import { canonicalOriginOrNull, digestSecret, digestsEqual, rawDataByteLength, rawDataToBuffer, safeCloseSocket, strictJsonParse, } from "../attachments/admission-util.js";
 import { SessionRuntimeControllerLeaseError } from "../session-runtime/registry.js";
 import { terminalDeliveryObservationOrdinal } from "../session-runtime/terminal-delivery-observation-identity.js";
@@ -593,6 +594,23 @@ class PreAuthAdmission {
     }
 }
 const GRAPHICS_MAX_QUEUED_DIGESTS = 256;
+/** Graphics state as renderers without zlib support must see it. */
+export function rawGraphicsState(state) {
+    const legacy = state.images.map((image) => image.format === "rgba-zlib" || image.format === "rgb-zlib"
+        ? {
+            ...image,
+            format: image.format === "rgba-zlib" ? "rgba" : "rgb",
+            bytes: image.width * image.height * (image.format === "rgba-zlib" ? 4 : 3),
+        }
+        : image);
+    const images = legacy.filter((image) => image.bytes <= TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES);
+    const kept = new Set(images.map((image) => image.digest));
+    return {
+        ...state,
+        images,
+        placements: state.placements.filter((placement) => kept.has(placement.digest)),
+    };
+}
 const GRAPHICS_SEND_WINDOW_BYTES = 2 * 1024 * 1024;
 export class PaneStreamLiveConnection {
     #clientId;
@@ -728,6 +746,8 @@ export class PaneStreamLiveConnection {
                 graphicsAnnounced: false,
                 graphicsQueue: [],
                 graphicsSending: false,
+                graphicsServed: new Map(),
+                graphicsState: null,
             });
         }
     }
@@ -1212,18 +1232,65 @@ export class PaneStreamLiveConnection {
         const graphics = channel.delivery?.graphics;
         if (!graphics)
             return;
+        // Renderers that cannot inflate see raw formats; their bytes are inflated
+        // when served.
+        const zlib = this.#descriptor.terminalDelivery?.protocolVersions.includes(TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION) === true;
+        channel.graphicsZlib = zlib;
+        // Renderers that report cell pixels learn up front that this daemon
+        // accepts them, before any image exists.
+        const cellPixels = this.#descriptor.terminalDelivery?.protocolVersions.includes(TERMINAL_GRAPHICS_CELL_PIXELS_CAPABILITY_VERSION) === true;
+        const preciseCellPixels = this.#descriptor.terminalDelivery?.protocolVersions.includes(TERMINAL_GRAPHICS_PRECISE_PIXELS_CAPABILITY_VERSION) === true;
+        let announced = false;
         graphics.subscribe((state) => {
+            announced = true;
             if (this.#closed || channel.closed)
                 return;
             channel.graphicsAnnounced = true;
-            this.#sendFrame(null, { type: "terminal-graphics", pane: channel.semanticPaneId, state });
+            channel.graphicsState = state;
+            // A program redrawing one image id (every frame of an animation or a
+            // page) needs the new bytes at once: push them instead of waiting for
+            // the renderer's round trip.
+            const pushed = [];
+            for (const image of state.images) {
+                const served = channel.graphicsServed.get(image.imageId);
+                if (served !== undefined && served !== image.digest)
+                    pushed.push(image.digest);
+            }
+            this.#sendFrame(null, {
+                type: "terminal-graphics",
+                pane: channel.semanticPaneId,
+                state: {
+                    ...(zlib ? state : rawGraphicsState(state)),
+                    ...(cellPixels ? { cellPixels: true } : {}),
+                    ...(preciseCellPixels ? { preciseCellPixels: true } : {}),
+                },
+            });
+            if (pushed.length > 0)
+                this.#queueGraphics(channel, pushed);
         });
+        if (cellPixels && !announced && !this.#closed && !channel.closed) {
+            channel.graphicsAnnounced = true;
+            this.#sendFrame(null, {
+                type: "terminal-graphics",
+                pane: channel.semanticPaneId,
+                state: {
+                    revision: 0,
+                    images: [],
+                    placements: [],
+                    cellPixels: true,
+                    ...(preciseCellPixels ? { preciseCellPixels: true } : {}),
+                },
+            });
+        }
     }
     #requestGraphics(pane, digests) {
         const channel = this.#panes.get(pane);
         // Requests are only meaningful after an announcement; ignore stray ones.
         if (!channel || channel.closed || !channel.graphicsAnnounced)
             return;
+        this.#queueGraphics(channel, digests);
+    }
+    #queueGraphics(channel, digests) {
         for (const digest of digests)
             if (!channel.graphicsQueue.includes(digest) &&
                 channel.graphicsQueue.length < GRAPHICS_MAX_QUEUED_DIGESTS)
@@ -1241,10 +1308,32 @@ export class PaneStreamLiveConnection {
         try {
             while (!this.#closed && !channel.closed && channel.graphicsQueue.length > 0) {
                 const digest = channel.graphicsQueue.shift();
-                const image = channel.delivery?.graphics?.image(digest);
-                if (!image)
+                const graphics = channel.delivery?.graphics;
+                const image = graphics?.image(digest);
+                if (!graphics || !image)
+                    continue;
+                for (const entry of channel.graphicsState?.images ?? [])
+                    if (entry.digest === digest)
+                        channel.graphicsServed.set(entry.imageId, digest);
+                const raw = !channel.graphicsZlib && image.format.endsWith("-zlib");
+                let data = image.data;
+                if (raw) {
+                    const expected = image.width * image.height * (image.format === "rgba-zlib" ? 4 : 3);
+                    if (expected < 1 || expected > TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES)
+                        continue;
+                    try {
+                        data = inflateSync(image.data, { maxOutputLength: expected });
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (data.byteLength !== expected)
+                        continue;
+                }
+                if (!channel.graphicsZlib && data.byteLength > TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES)
                     continue;
-                const total = image.data.byteLength;
+                const format = raw ? (image.format === "rgba-zlib" ? "rgba" : "rgb") : image.format;
+                const total = data.byteLength;
                 for (let offset = 0; offset < total; offset += TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES) {
                     while ((this.#socket.bufferedAmount ?? 0) > GRAPHICS_SEND_WINDOW_BYTES) {
                         if (this.#closed || channel.closed)
@@ -1253,19 +1342,23 @@ export class PaneStreamLiveConnection {
                     }
                     if (this.#closed || channel.closed)
                         return;
+                    // A superseded frame (the id was redrawn) is abandoned mid-transfer;
+                    // the renderer drops the partial image and shows the newer one.
+                    if (offset > 0 && graphics.image(digest) !== image)
+                        break;
                     const end = Math.min(total, offset + TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES);
                     this.#sendFrame(null, {
                         type: "terminal-graphics-blob",
                         pane: channel.semanticPaneId,
                         blob: {
                             digest,
-                            format: image.format,
+                            format,
                             width: image.width,
                             height: image.height,
                             total,
                             offset,
                         },
-                        data: Buffer.from(image.data.subarray(offset, end)).toString("base64"),
+                        data: Buffer.from(data.subarray(offset, end)).toString("base64"),
                     });
                 }
             }
@@ -1851,6 +1944,15 @@ export class PaneStreamLiveConnection {
             this.#requestGraphics(frame.pane, frame.digests);
             return;
         }
+        if (frame.type === "terminal-cell-pixels") {
+            try {
+                this.#sessionRuntimeBinding?.setCellPixels?.(frame.width, frame.height, frame.precise);
+            }
+            catch {
+                // A retired runtime simply keeps tmux's default cell size.
+            }
+            return;
+        }
         if (frame.type === "viewport") {
             if (!this.#descriptor.terminalDelivery ||
                 this.#descriptor.viewerMode !== "interactive" ||

package/packages/daemon/dist/terminal/session-runtime/registry.js

@@ -1134,6 +1134,11 @@ class SessionRuntime {
             throw new SessionRuntimeControllerLeaseError("invalid-client-capability", "The client does not own this geometry authority lease.");
         }
     }
+    /** Renderer cell size in device pixels; benign, so any connected client may set it. */
+    setCellPixels(clientId, width, height, precise) {
+        this.#assertConnected(clientId);
+        this.#mirror.setCellPixels?.(this.session, width, height, precise);
+    }
     fitViewportWithAuthority(clientId, lease, cols, rows, semanticWindowId) {
         this.assertGeometryAuthority(clientId, lease);
         this.#mirror.setGeometryParticipation(this.session, true);
@@ -1571,6 +1576,10 @@ class SessionRuntimeConsumerImpl {
         this.#assertOpen();
         this.#runtime.fitViewport(this.clientId, lease, cols, rows, semanticWindowId);
     }
+    setCellPixels(width, height, precise) {
+        this.#assertOpen();
+        this.#runtime.setCellPixels(this.clientId, width, height, precise);
+    }
     fitViewportWithAuthority(lease, cols, rows, semanticWindowId) {
         this.#assertOpen();
         this.#runtime.fitViewportWithAuthority(this.clientId, lease, cols, rows, semanticWindowId);

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

@@ -250,8 +250,17 @@ export class TerminalReplicaInterpreter {
             const previous = this.#backend;
             this.#backend = replacement;
             this.#attachKitty(replacement);
-            // tmux never saw cursor-anchored placements; a capture cannot restore them.
-            this.#kitty.dropCursorPlacements();
+            // A capture replay does not erase graphics already observed by this owner.
+            // Keep anchors only when both backends agree on their coordinate basis;
+            // reflow, history replacement and authoritative stream resets are ambiguous.
+            const sameGraphicsBasis = operation.bootstrap === "painted-capture" &&
+                previous.cols === replacement.cols &&
+                previous.rows === replacement.rows &&
+                previous.graphicsViewportTop?.() !== undefined &&
+                previous.graphicsViewportTop?.() === replacement.graphicsViewportTop?.() &&
+                previous.modes().alternateScreen === replacement.modes().alternateScreen;
+            if (!sameGraphicsBasis)
+                this.#kitty.dropCursorPlacements();
             this.#nativeReseedRequested = false;
             this.#scrollback = scrollback;
             this.#bootstrap = {
@@ -290,6 +299,8 @@ export class TerminalReplicaInterpreter {
             return;
         }
         if (operation.type === "resize") {
+            if (operation.cols !== this.#backend.cols || operation.rows !== this.#backend.rows)
+                this.#kitty.dropCursorPlacements();
             this.#causalCell?.fail("geometry-drift");
             if (this.#backend.modes().synchronizedOutput) {
                 // Geometry is part of the admitted FIFO even while publication is
@@ -344,6 +355,12 @@ export class TerminalReplicaInterpreter {
         // Always forward the scanner's output: tmux splits %output (~2 KiB) inside
         // kitty APCs (~4 KiB chunks), so a chunk with no completed command can still
         // be all image payload that must never reach the VT parser as text.
+        // A chunk entirely inside image payload changes nothing the parser can
+        // see. Skipping it matters: every parser write settles on a later timer
+        // turn, so a frame split into dozens of %output chunks would otherwise
+        // serialize dozens of turns and fall behind a 30 fps image stream.
+        if (scanned.forward.byteLength === 0)
+            return;
         await this.#writeToBackend(this.#backend, scanned.forward);
         if (this.#observability.enabled)
             this.#observability.recordSpan("parse", "terminal-replica-write", parseStarted, this.#observability.nowMicros(), trace);

package/packages/daemon/dist/terminal/session-runtime/transport-binding.js

@@ -297,6 +297,10 @@ export class SessionRuntimeTransportBinding {
             throw error;
         }
     }
+    setCellPixels(width, height, precise) {
+        this.#assertOpen();
+        this.#shared.consumer.setCellPixels?.(width, height, precise);
+    }
     fitViewport(expectedLease, cols, rows, semanticWindowId) {
         this.#assertOpen();
         if (this.#shared.geometryTransportLeaseIds.at(-1) !== this.#transportLeaseId) {

package/packages/daemon/src/terminal/attachments/native-runtime.ts

@@ -918,6 +918,11 @@ function parsePaneSnapshot(
  * application-shell inventory. Names are resolved exactly to `$session_id`
  * before any pane query, and a second identity/topology snapshot closes races.
  */
+const INVENTORY_FENCE_ATTEMPTS = 4;
+/** 25, 50, 100 ms: enough for a mutation's identity stamps, bounded for every reader. */
+const settleDelay = (attempt: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, 25 * 2 ** (attempt - 1)));
+
 export async function discoverWorkspaceRegistryTerminalInventory(
   registry: WorkspaceRegistry,
   runner: NativeTerminalInventoryReadRunner,
@@ -941,12 +946,6 @@ export async function discoverWorkspaceRegistryTerminalInventory(
     const argv = ["list-panes", "-s", "-t", identity.id, "-F", PANE_FORMAT] as const;
     const before = await requiredTmuxResult(runner, argv, signal);
     if (before === null) continue;
-    const first = parsePaneSnapshot(before, identity);
-    const panes = first.panes;
-    const after = await requiredTmuxResult(runner, argv, signal);
-    if (after === null) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
-    const second = parsePaneSnapshot(after, identity);
-    const latest = second.panes;
     // Foreground commands, titles, focus and paths can change while the same
     // pane remains valid. Fence binding/topology only, then publish one complete
     // latest snapshot rather than mixing presentation values across reads.
@@ -961,14 +960,30 @@ export async function discoverWorkspaceRegistryTerminalInventory(
       "windowStamp",
       "index",
     ] as const;
-    if (
-      first.linksProof !== second.linksProof ||
-      panes.length !== latest.length ||
-      panes.some((pane, index) => proofKeys.some((key) => pane[key] !== latest[index]![key]))
-    ) {
-      throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+    const matches = (
+      first: ReturnType<typeof parsePaneSnapshot>,
+      second: ReturnType<typeof parsePaneSnapshot>,
+    ) =>
+      first.linksProof === second.linksProof &&
+      first.panes.length === second.panes.length &&
+      first.panes.every((pane, index) =>
+        proofKeys.every((key) => pane[key] === second.panes[index]![key]),
+      );
+    // A just-created window or split is still being stamped, so topology can
+    // move between two reads. Let it settle for a bounded number of re-reads;
+    // only two consecutive matching reads are ever published.
+    let previous = parsePaneSnapshot(before, identity);
+    let stable: ReturnType<typeof parsePaneSnapshot> | null = null;
+    for (let attempt = 0; attempt < INVENTORY_FENCE_ATTEMPTS && !stable; attempt += 1) {
+      if (attempt > 0) await settleDelay(attempt);
+      const after = await requiredTmuxResult(runner, argv, signal);
+      if (after === null) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+      const next = parsePaneSnapshot(after, identity);
+      if (matches(previous, next)) stable = next;
+      else previous = next;
     }
-    bySessionName.set(sessionName, latest);
+    if (!stable) throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+    bySessionName.set(sessionName, stable.panes);
   }
 
   const panes: NativeTerminalInventoryPaneSnapshot[] = [];