tmux-ide 2.9.10 → 2.9.12

package/packages/daemon/src/terminal/mirror/session-channel.ts

@@ -507,6 +507,8 @@ export class SessionChannel {
   private readonly fittedWindows = new Map<string, { cols: number; rows: number }>();
   private cancelSync: (() => void) | null = null;
   private syncOrdinal = 0;
+  private identityJoinOrdinal = 0;
+  private trustedInventoryJoinsMissing = false;
   private completedSyncOrdinal = 0;
   private lastDisplayNameSyncAtMs = 0;
   private disposed = false;
@@ -799,22 +801,36 @@ export class SessionChannel {
 
   /**
    * Strict daemon-internal inventory from this channel's current tmux truth.
-   * Unlike the background discovery path, this query awaits descriptor
-   * reconciliation before projecting and rejects incomplete identity rather
-   * than returning the previous descriptor snapshot.
+   * Unlike background discovery, this query verifies current native membership
+   * before projecting and rejects incomplete identity. Stream admission may
+   * explicitly join missing pane records after that verification; ordinary
+   * inventory readers retain their existing fail-closed no-join contract.
    */
   describeTrustedInventory(
     expectedRuntimeSessionId: string,
+    joinMissingPanes = false,
   ): Promise<TrustedMirrorSessionInventory> {
     if (this.disposed) {
       return Promise.reject(new Error(`mirror session ${this.opts.session} is disposed`));
     }
     if (this.trustedInventoryFlight) {
+      // A default read can fail precisely because it does not join new panes.
+      // Preserve that failure for its caller, then qualify admission separately.
+      if (
+        joinMissingPanes &&
+        !this.trustedInventoryJoinsMissing &&
+        this.trustedInventoryFlightSessionId === expectedRuntimeSessionId
+      )
+        return this.trustedInventoryFlight.then(
+          () => this.describeTrustedInventory(expectedRuntimeSessionId, true),
+          () => this.describeTrustedInventory(expectedRuntimeSessionId, true),
+        );
       return this.trustedInventoryFlightSessionId === expectedRuntimeSessionId
         ? this.trustedInventoryFlight
         : Promise.reject(new Error(`trusted inventory identity changed for ${this.opts.session}`));
     }
-    const flight = this.refreshTrustedInventory(expectedRuntimeSessionId)
+    this.trustedInventoryJoinsMissing = joinMissingPanes;
+    const flight = this.refreshTrustedInventory(expectedRuntimeSessionId, 0, joinMissingPanes)
       .catch((error) => {
         this.windowLinkAuthority?.invalidate();
         this.latestWindowStage = null;
@@ -3387,6 +3403,7 @@ export class SessionChannel {
   private async refreshTrustedInventory(
     expectedRuntimeSessionId: string,
     attempt = 0,
+    joinMissingPanes = false,
   ): Promise<TrustedMirrorSessionInventory> {
     const authorityOrdinal = this.windowIdentityOrdinal;
     const beforeLines = await this.io.request(
@@ -3486,7 +3503,11 @@ export class SessionChannel {
     ) {
       if (attempt >= 1)
         throw new Error(`trusted inventory for ${this.opts.session} did not settle`);
-      return await this.refreshTrustedInventory(expectedRuntimeSessionId, attempt + 1);
+      return await this.refreshTrustedInventory(
+        expectedRuntimeSessionId,
+        attempt + 1,
+        joinMissingPanes,
+      );
     }
     if (this.disposed) throw new Error(`mirror session ${this.opts.session} is disposed`);
     const activeWindowId = activeWindowIds.values().next().value;
@@ -3521,7 +3542,28 @@ export class SessionChannel {
       stagedPaneIds.size !== descriptors.length ||
       [...computedWindowCounts.keys()].some(
         (runtimeWindowId) => !confirmedWindowStage.windows.has(runtimeWindowId),
-      ) ||
+      )
+    )
+      throw new Error(`trusted inventory for ${this.opts.session} lacks verified identity`);
+    // Fresh native inventory can beat background discovery after window creation.
+    // Join verified stable membership before projecting semantic records.
+    if (
+      joinMissingPanes &&
+      descriptors.some(
+        (pane) => this.panesByRuntime.get(pane.runtimePaneId)?.semanticId !== pane.semanticPaneId,
+      )
+    ) {
+      this.discovery.invalidate();
+      await this.reconcileIdentity(
+        descriptors,
+        runtimePaneIds,
+        () => authorityOrdinal === this.windowIdentityOrdinal,
+        false,
+      );
+    }
+    if (this.disposed || authorityOrdinal !== this.windowIdentityOrdinal)
+      throw new Error(`trusted inventory for ${this.opts.session} changed during identity join`);
+    if (
       descriptors.some((descriptor) => {
         const pane = this.panesByRuntime.get(descriptor.runtimePaneId);
         const window = confirmedWindowStage.windows.get(descriptor.windowId!);
@@ -3934,7 +3976,10 @@ export class SessionChannel {
   private async reconcileIdentity(
     descriptors: readonly SessionPaneDescriptor[],
     listed: ReadonlySet<string>,
+    current: () => boolean = () => true,
+    publish = true,
   ): Promise<boolean> {
+    const joinOrdinal = ++this.identityJoinOrdinal;
     if (this.disposed) return false;
     if (this.opts.hasSharedWindowConflict?.()) {
       this.settleFirstJoin();
@@ -3973,7 +4018,8 @@ export class SessionChannel {
           ),
       ),
     );
-    if (this.disposed) return plan.stampEffects.length > 0;
+    if (this.disposed || !current() || joinOrdinal !== this.identityJoinOrdinal)
+      return plan.stampEffects.length > 0;
     const reconciliation = finalizeWorkspaceTmuxReconciliation(plan, outcomes);
     const descriptorByRuntime = new Map(descriptors.map((d) => [d.runtimePaneId, d]));
     for (const verified of reconciliation.panes) {
@@ -4080,8 +4126,10 @@ export class SessionChannel {
      * without this the new pane stays invisible until something else happens to
      * move a layout, and a split looks like it did not reach the view.
      */
-    for (const runtimeId of this.layoutByWindow.keys()) this.emitLayout(runtimeId);
-    this.emitLayoutAuthority();
+    if (publish) {
+      for (const runtimeId of this.layoutByWindow.keys()) this.emitLayout(runtimeId);
+      this.emitLayoutAuthority();
+    }
     this.settleFirstJoin();
     return plan.stampEffects.length > 0;
   }

package/packages/daemon/src/terminal/pane-stream/pane-stream-websocket.ts

@@ -1,3 +1,15 @@
+import {
+  TERMINAL_PROJECTION_CAPABILITY_VERSION,
+  TERMINAL_PROJECTION_LOCAL_CAPABILITY_VERSION,
+  type TerminalProjectionReceipt,
+  type TerminalProjectionMaterialize,
+} from "@tmux-ide/contracts";
+import type { LocalImageOwner } from "../graphics/local-image-owner.ts";
+import {
+  PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION,
+  PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION,
+  type PaneStreamInputLifetime,
+} from "@tmux-ide/contracts";
 import { inflateSync } from "node:zlib";
 import { PaneStreamLayoutSnapshotFrameSchemaZ, type WindowLinkTopology } from "@tmux-ide/contracts";
 import type { TerminalDeliveryGraphics } from "../session-runtime/terminal-delivery-hub.ts";
@@ -11,6 +23,12 @@ import {
   PANE_STREAM_REDEEM_PATH,
   PANE_STREAM_WEBSOCKET_SUBPROTOCOL,
   TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES,
+  TERMINAL_DELIVERY_BINARY_CAPABILITY_VERSION,
+  TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION,
+  TERMINAL_GRAPHICS_BINARY_CAPABILITY_VERSION,
+  TERMINAL_GRAPHICS_LOCAL_CAPABILITY_VERSION,
+  encodeTerminalGraphicsBinary,
+  encodeTerminalDeliveryBinaryChunk,
   TERMINAL_GRAPHICS_CELL_PIXELS_CAPABILITY_VERSION,
   TERMINAL_GRAPHICS_PRECISE_PIXELS_CAPABILITY_VERSION,
   TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES,
@@ -149,6 +167,7 @@ export interface PaneStreamMirror {
   describeSession(session: string): Promise<MirrorSessionDescription>;
   describeSessionAuthority?(
     session: string,
+    expectedSemanticPaneIds?: readonly string[],
   ): Promise<{ readonly description: MirrorSessionDescription; readonly runtimeSessionId: string }>;
   subscribe(request: MirrorSubscribeRequest): Promise<MirrorSubscription>;
   subscribeLayout?(
@@ -240,6 +259,7 @@ export interface PaneStreamAdmissionSnapshot {
 }
 
 export interface PaneStreamAdmissionCoordinatorOptions {
+  readonly localImages?: LocalImageOwner;
   readonly daemonInstanceId: string;
   readonly webSocketUrl: string;
   readonly leaseManager: PaneStreamLeaseAuthority;
@@ -304,6 +324,7 @@ export interface SessionRuntimePaneStreamTransportBinding {
     performanceTraceId?: string,
     causalProbe?: CausalCellProbeV1,
     onCausalResult?: (result: CausalCellLedgerResult) => void,
+    expectedLifetime?: PaneStreamInputLifetime,
   ): void;
   fitViewport(
     lease: SessionRuntimeAuthorityLease,
@@ -320,6 +341,8 @@ export interface SessionRuntimeTerminalDeliveryConnection {
   readonly closed?: Promise<"closed" | "sink-failed">;
   readonly negotiation: TerminalDeliveryNegotiationResult;
   ack(ack: TerminalDeliveryAck): void;
+  projectionReceipt?(receipt: TerminalProjectionReceipt): void;
+  materialize?(request: TerminalProjectionMaterialize): void;
   nack(nack: TerminalDeliveryNack): void;
   setVisibility(visibility: TerminalDeliveryVisibility): void;
   close(): Promise<void>;
@@ -382,6 +405,7 @@ function errorFrameCode(error: unknown): PaneStreamErrorFrameCode {
  * ticket digests; a daemon restart makes every prior descriptor inert.
  */
 export class PaneStreamAdmissionCoordinator {
+  readonly #localImages: LocalImageOwner | undefined;
   readonly #instanceId: string;
   readonly #webSocketUrl: string;
   readonly #leaseManager: PaneStreamLeaseAuthority;
@@ -415,6 +439,7 @@ export class PaneStreamAdmissionCoordinator {
   #shutdownPromise: Promise<void> | null = null;
 
   constructor(options: PaneStreamAdmissionCoordinatorOptions) {
+    this.#localImages = options.localImages;
     this.#instanceId = BindingIdSchemaZ.parse(options.daemonInstanceId);
     this.#webSocketUrl = PaneStreamLoopbackWebSocketUrlSchemaZ.parse(options.webSocketUrl);
     this.#leaseManager = options.leaseManager;
@@ -493,7 +518,10 @@ export class PaneStreamAdmissionCoordinator {
       try {
         const describeStartedAtMicros = trace ? this.#observability!.nowMicros() : 0;
         if (this.#mirror.describeSessionAuthority) {
-          const authority = await this.#mirror.describeSessionAuthority(context.sessionName);
+          const authority = await this.#mirror.describeSessionAuthority(
+            context.sessionName,
+            request.panes,
+          );
           described = authority.description;
           runtimeSessionId = authority.runtimeSessionId;
         } else {
@@ -783,6 +811,7 @@ export class PaneStreamAdmissionCoordinator {
         let live: PaneStreamLiveConnection;
         try {
           live = new PaneStreamLiveConnection({
+            localImages: this.#localImages,
             clientId: `psc-${this.#clientCounter}`,
             socket,
             descriptor: structuredClone(descriptor),
@@ -1001,6 +1030,7 @@ class PreAuthAdmission implements PaneStreamPreAuthAdmission {
 }
 
 interface LiveConnectionOptions {
+  readonly localImages?: LocalImageOwner;
   readonly clientId: string;
   readonly socket: DirectTerminalSocket;
   readonly descriptor: PaneStreamLeaseDescriptor;
@@ -1057,6 +1087,10 @@ interface PaneChannel {
   graphicsServed: Map<number, string>;
   graphicsState: TerminalGraphicsState | null;
   graphicsZlib?: boolean;
+  graphicsBinary?: boolean;
+  binaryCells?: boolean;
+  graphicsLocal?: boolean;
+  graphicsInline?: Set<string>;
 }
 
 interface QueuedSend {
@@ -1088,6 +1122,8 @@ export function rawGraphicsState(state: TerminalGraphicsState): TerminalGraphics
 const GRAPHICS_SEND_WINDOW_BYTES = 2 * 1024 * 1024;
 
 export class PaneStreamLiveConnection {
+  readonly #localImages: LocalImageOwner | undefined;
+  readonly #localLeases = new Map<string, { pane: string; expiresAt: number }>();
   readonly #clientId: string;
   readonly #socket: DirectTerminalSocket;
   readonly #descriptor: PaneStreamLeaseDescriptor;
@@ -1212,6 +1248,7 @@ export class PaneStreamLiveConnection {
   }
 
   constructor(options: LiveConnectionOptions) {
+    this.#localImages = options.localImages;
     this.#clientId = options.clientId;
     this.#socket = options.socket;
     this.#descriptor = options.descriptor;
@@ -1279,6 +1316,18 @@ export class PaneStreamLiveConnection {
     try {
       sendControl(this.#socket, {
         type: "ready",
+        ...(this.#sessionRuntimeBinding &&
+        this.#descriptor.terminalDelivery?.protocolVersions.includes(
+          PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION,
+        )
+          ? { inputLifetime: true as const }
+          : {}),
+        ...(this.#sessionRuntimeBinding &&
+        this.#descriptor.terminalDelivery?.protocolVersions.includes(
+          PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION,
+        )
+          ? { inputBytes: true as const }
+          : {}),
         protocolVersion: PANE_STREAM_PROTOCOL_VERSION,
         daemonInstanceId: this.#binding.daemonInstanceId,
         requestId: this.#binding.requestId,
@@ -1321,6 +1370,14 @@ export class PaneStreamLiveConnection {
     this.#stopAuthoritySnapshots?.();
     this.#stopAuthoritySnapshots = null;
     const closures: Promise<unknown>[] = [];
+    this.#localLeases.clear();
+    if (this.#localImages)
+      closures.push(
+        this.#localImages.releaseClient({
+          generation: this.#localImages.identity.generation,
+          client: this.#descriptor.leaseId,
+        }),
+      );
     const layoutSubscription = this.#layoutSubscription;
     this.#layoutSubscription = null;
     if (layoutSubscription) closures.push(layoutSubscription.close().catch(() => undefined));
@@ -1549,7 +1606,8 @@ export class PaneStreamLiveConnection {
       if (negotiated.generation !== this.#binding.daemonInstanceId) return true;
       let incarnation: string | null = null;
       for (const message of pending) {
-        if (message.type !== "terminal.delivery") continue;
+        if (message.type !== "terminal.delivery" && message.type !== "terminal.projection")
+          continue;
         if (
           message.workspaceName !== this.#descriptor.workspaceName ||
           message.semanticPaneId !== channel.semanticPaneId ||
@@ -1671,13 +1729,19 @@ export class PaneStreamLiveConnection {
   }
 
   async #sendTerminalDelivery(pane: string, message: TerminalDeliveryServerMessage): Promise<void> {
-    if (message.type === "terminal.delivery") {
+    if (message.type === "terminal.projection") {
+      const channel = this.#panes.get(pane);
+      if (channel?.deliveryAddress) channel.deliveryAddress.incarnation = message.incarnation;
+      if (channel) channel.binaryCells = true;
+      this.#sendFrame(pane, { type: "terminal-projection-envelope", pane, envelope: message });
+    } else if (message.type === "terminal.delivery") {
       if (!this.#diagnosticFirstSeedObserved) {
         this.#diagnosticFirstSeedObserved = true;
         this.#recordDiagnosticLifecycle("pane-stream-first-seed");
       }
       const channel = this.#panes.get(pane);
       if (channel?.deliveryAddress) channel.deliveryAddress.incarnation = message.incarnation;
+      if (channel) channel.binaryCells = message.encoding === "semantic-binary-v1";
       // The trusted lease address was fixed at delivery admission; preserve the
       // exact envelope and its observation identity through transmission.
       const detailedDeliveryObservation = this.#observability?.enabled === true;
@@ -1760,13 +1824,26 @@ export class PaneStreamLiveConnection {
         }
       }
     } else if (message.type === "terminal.delivery.chunk") {
-      this.#sendFrame(pane, {
-        type: "terminal-delivery-chunk",
-        pane,
-        transactionId: message.transactionId,
-        index: message.index,
-        data: Buffer.from(message.bytes).toString("base64"),
-      });
+      if (this.#panes.get(pane)?.binaryCells) {
+        this.#sendEncoded(
+          pane,
+          Buffer.from(
+            encodeTerminalDeliveryBinaryChunk(
+              { pane, transactionId: message.transactionId, index: message.index },
+              message.bytes,
+            ),
+          ),
+          true,
+        );
+      } else {
+        this.#sendFrame(pane, {
+          type: "terminal-delivery-chunk",
+          pane,
+          transactionId: message.transactionId,
+          index: message.index,
+          data: Buffer.from(message.bytes).toString("base64"),
+        });
+      }
     } else {
       this.#sendFrame(pane, { type: "terminal-delivery-fault", pane, fault: message });
       // Lifecycle/control truth must never queue behind bulk terminal bytes.
@@ -1788,6 +1865,25 @@ export class PaneStreamLiveConnection {
         TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION,
       ) === true;
     channel.graphicsZlib = zlib;
+    channel.graphicsLocal =
+      !!this.#localImages &&
+      this.#descriptor.terminalDelivery?.protocolVersions.some(
+        (version) =>
+          version === TERMINAL_GRAPHICS_LOCAL_CAPABILITY_VERSION ||
+          version === TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION ||
+          version === TERMINAL_PROJECTION_LOCAL_CAPABILITY_VERSION,
+      ) === true;
+    channel.graphicsInline = new Set();
+    channel.graphicsBinary =
+      this.#descriptor.terminalDelivery?.protocolVersions.some(
+        (version) =>
+          version === TERMINAL_GRAPHICS_BINARY_CAPABILITY_VERSION ||
+          version === TERMINAL_GRAPHICS_LOCAL_CAPABILITY_VERSION ||
+          version === TERMINAL_DELIVERY_BINARY_CAPABILITY_VERSION ||
+          version === TERMINAL_PROJECTION_CAPABILITY_VERSION ||
+          version === TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION ||
+          version === TERMINAL_PROJECTION_LOCAL_CAPABILITY_VERSION,
+      ) === true;
     // Renderers that report cell pixels learn up front that this daemon
     // accepts them, before any image exists.
     const cellPixels =
@@ -1819,6 +1915,8 @@ export class PaneStreamLiveConnection {
           ...(zlib ? state : rawGraphicsState(state)),
           ...(cellPixels ? { cellPixels: true as const } : {}),
           ...(preciseCellPixels ? { preciseCellPixels: true as const } : {}),
+          ...(channel.graphicsBinary ? { binaryBlobs: true as const } : {}),
+          ...(channel.graphicsLocal ? { localFiles: true as const } : {}),
         },
       });
       if (pushed.length > 0) this.#queueGraphics(channel, pushed);
@@ -1834,15 +1932,23 @@ export class PaneStreamLiveConnection {
           placements: [],
           cellPixels: true,
           ...(preciseCellPixels ? { preciseCellPixels: true as const } : {}),
+          ...(channel.graphicsBinary ? { binaryBlobs: true as const } : {}),
+          ...(channel.graphicsLocal ? { localFiles: true as const } : {}),
         },
       });
     }
   }
 
-  #requestGraphics(pane: string, digests: readonly string[]): void {
+  #requestGraphics(pane: string, digests: readonly string[], preferInline = false): void {
     const channel = this.#panes.get(pane);
     // Requests are only meaningful after an announcement; ignore stray ones.
     if (!channel || channel.closed || !channel.graphicsAnnounced) return;
+    if (preferInline && channel.graphicsLocal) {
+      for (const digest of digests) {
+        if ((channel.graphicsInline?.size ?? 0) < GRAPHICS_MAX_QUEUED_DIGESTS)
+          channel.graphicsInline?.add(digest);
+      }
+    }
     this.#queueGraphics(channel, digests);
   }
 
@@ -1866,6 +1972,7 @@ export class PaneStreamLiveConnection {
     try {
       while (!this.#closed && !channel.closed && channel.graphicsQueue.length > 0) {
         const digest = channel.graphicsQueue.shift()!;
+        const inline = channel.graphicsInline?.delete(digest) ?? false;
         const graphics = channel.delivery?.graphics;
         const image = graphics?.image(digest);
         if (!graphics || !image) continue;
@@ -1887,6 +1994,47 @@ export class PaneStreamLiveConnection {
           continue;
         const format = raw ? (image.format === "rgba-zlib" ? "rgba" : "rgb") : image.format;
         const total = data.byteLength;
+        if (!inline && channel.graphicsLocal && !raw && this.#localImages) {
+          for (const [id, lease] of this.#localLeases)
+            if (lease.expiresAt <= Date.now()) this.#localLeases.delete(id);
+          if (this.#localLeases.size < 64) {
+            try {
+              const lease = await this.#localImages.acquire({
+                generation: this.#localImages.identity.generation,
+                client: this.#descriptor.leaseId,
+                digest,
+                bytes: data,
+              });
+              if (this.#closed || channel.closed || graphics.image(digest) !== image) {
+                await this.#localImages.release(lease);
+                continue;
+              }
+              this.#localLeases.set(lease.id, {
+                pane: channel.semanticPaneId,
+                expiresAt: lease.expiresAt,
+              });
+              this.#sendFrame(null, {
+                type: "terminal-graphics-local",
+                pane: channel.semanticPaneId,
+                generation: lease.generation,
+                leaseId: lease.id,
+                path: lease.path,
+                expiresAt: lease.expiresAt,
+                blob: {
+                  digest,
+                  format,
+                  width: image.width,
+                  height: image.height,
+                  total,
+                  offset: 0,
+                },
+              });
+              continue;
+            } catch {
+              /* Optional transport: retain the negotiated inline fallback. */
+            }
+          }
+        }
         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) return;
@@ -1897,6 +2045,29 @@ export class PaneStreamLiveConnection {
           // 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);
+          if (channel.graphicsBinary) {
+            this.#sendEncoded(
+              null,
+              Buffer.from(
+                encodeTerminalGraphicsBinary(
+                  {
+                    pane: channel.semanticPaneId,
+                    blob: {
+                      digest,
+                      format,
+                      width: image.width,
+                      height: image.height,
+                      total,
+                      offset,
+                    },
+                  },
+                  data.subarray(offset, end),
+                ),
+              ),
+              true,
+            );
+            continue;
+          }
           this.#sendFrame(null, {
             type: "terminal-graphics-blob",
             pane: channel.semanticPaneId,
@@ -2230,7 +2401,12 @@ export class PaneStreamLiveConnection {
   #sendFrame(pane: string | null, frame: Record<string, unknown>): void {
     if (this.#closed || this.#socket.readyState !== WS_OPEN) return;
     const encoded = JSON.stringify(frame);
-    const bytes = Buffer.byteLength(encoded, "utf8");
+    this.#sendEncoded(pane, encoded, false);
+  }
+
+  #sendEncoded(pane: string | null, encoded: string | Buffer, binary: boolean): void {
+    if (this.#closed || this.#socket.readyState !== WS_OPEN) return;
+    const bytes = Buffer.byteLength(encoded);
     if (pane !== null) {
       this.#ledger.take(this.#clientId, pane, "ws-send-buffer", bytes);
       if (this.#deliveryAcks) this.#ledger.take(this.#clientId, pane, "renderer-backlog", 1);
@@ -2238,7 +2414,7 @@ export class PaneStreamLiveConnection {
     this.#sendQueue.push({ pane, remaining: bytes });
     this.#sentBytesTotal += bytes;
     try {
-      this.#socket.send(encoded, { binary: false });
+      this.#socket.send(encoded, { binary });
     } catch {
       this.close(1011, "stream-unavailable");
       return;
@@ -2460,6 +2636,20 @@ export class PaneStreamLiveConnection {
       });
       return;
     }
+    if (frame.type === "terminal-projection-receipt") {
+      const channel = this.#deliveryChannel(frame.receipt);
+      if (!channel) return;
+      if (!channel.delivery?.projectionReceipt) return this.#failProtocol("protocol-error");
+      channel.delivery.projectionReceipt(frame.receipt);
+      return;
+    }
+    if (frame.type === "terminal-projection-materialize") {
+      const channel = this.#deliveryChannel(frame.request);
+      if (!channel) return;
+      if (!channel.delivery?.materialize) return this.#failProtocol("protocol-error");
+      channel.delivery.materialize(frame.request);
+      return;
+    }
     if (frame.type === "terminal-delivery-ack") {
       const channel = this.#deliveryChannel(frame.ack);
       if (!channel) return;
@@ -2489,7 +2679,25 @@ export class PaneStreamLiveConnection {
       return;
     }
     if (frame.type === "terminal-graphics-request") {
-      this.#requestGraphics(frame.pane, frame.digests);
+      this.#requestGraphics(frame.pane, frame.digests, frame.preferInline === true);
+      return;
+    }
+    if (frame.type === "terminal-graphics-local-release") {
+      const lease = this.#localLeases.get(frame.leaseId);
+      if (
+        lease &&
+        lease.pane === frame.pane &&
+        frame.generation === this.#localImages?.identity.generation
+      ) {
+        this.#localLeases.delete(frame.leaseId);
+        void this.#localImages
+          ?.release({
+            generation: frame.generation,
+            client: this.#descriptor.leaseId,
+            id: frame.leaseId,
+          })
+          .catch(() => {});
+      }
       return;
     }
     if (frame.type === "terminal-cell-pixels") {
@@ -2560,6 +2768,7 @@ export class PaneStreamLiveConnection {
       ingressAtMicros,
       callbackAtSharedMicros,
       ingressAtSharedMicros,
+      frame.expectedLifetime,
     );
   };
 
@@ -2704,7 +2913,7 @@ export class PaneStreamLiveConnection {
   #acceptInput(
     pane: string,
     seq: number,
-    kind: "text" | "key",
+    kind: "text" | "key" | "bytes",
     data: string,
     frameBytes: number,
     performanceTraceId?: string,
@@ -2712,7 +2921,28 @@ export class PaneStreamLiveConnection {
     ingressAtMicros: number | null = null,
     callbackAtSharedMicros: number | null = null,
     ingressAtSharedMicros: number | null = null,
+    expectedLifetime?: PaneStreamInputLifetime,
   ): void {
+    if (
+      kind === "bytes" &&
+      (!this.#sessionRuntimeBinding ||
+        !this.#descriptor.terminalDelivery?.protocolVersions.includes(
+          PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION,
+        ))
+    ) {
+      this.#failProtocol("input-rejected");
+      return;
+    }
+    if (
+      expectedLifetime &&
+      (!this.#sessionRuntimeBinding ||
+        !this.#descriptor.terminalDelivery?.protocolVersions.includes(
+          PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION,
+        ))
+    ) {
+      this.#failProtocol("input-rejected");
+      return;
+    }
     if (this.#descriptor.viewerMode !== "interactive") {
       this.#failProtocol("input-rejected");
       return;
@@ -2832,9 +3062,11 @@ export class PaneStreamLiveConnection {
                 }
               }
             : undefined,
+          expectedLifetime,
         );
       else if (kind === "text") channel.sub!.sendText(data);
-      else channel.sub!.sendKey(data);
+      else if (kind === "key") channel.sub!.sendKey(data);
+      else throw new Error("Byte input requires semantic runtime");
       let ackStartedAtMicros: number | null = null;
       let ackStartedAtSharedMicros: number | null = null;
       if (trace) {

package/packages/daemon/src/terminal/pane-stream/runtime.ts

@@ -1,3 +1,4 @@
+import type { LocalImageOwner } from "../graphics/local-image-owner.ts";
 import type { SemanticPaneCatalog } from "../attachments/semantic-pane-catalog.ts";
 import type { SessionRuntimeRegistry } from "../session-runtime/registry.ts";
 import { SessionRuntimeTransportBinder } from "../session-runtime/transport-binding.ts";
@@ -9,6 +10,7 @@ import {
 } from "./pane-stream-websocket.ts";
 
 export interface PaneStreamRuntimeOptions {
+  readonly localImages?: LocalImageOwner;
   readonly daemonInstanceId: string;
   readonly webSocketUrl: string;
   /** Canonical daemon-generation session/control owner. */
@@ -38,6 +40,7 @@ export class PaneStreamRuntime {
     const transportBinder = new SessionRuntimeTransportBinder(options.sessionRuntimeRegistry);
     this.coordinator = new PaneStreamAdmissionCoordinator({
       ...options.admission,
+      localImages: options.localImages,
       daemonInstanceId: options.daemonInstanceId,
       webSocketUrl: options.webSocketUrl,
       leaseManager,