tmux-ide 2.9.3 → 2.9.5

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

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

package/packages/daemon/src/tui/mirror/runtime/application-terminal-input-ingress.ts

@@ -25,7 +25,7 @@ export function createApplicationTerminalInputIngress(
   generation: () => OpenTuiGenerationHostSnapshot | null,
   sessionOwner: () => OpenTuiSessionOwner | null,
   focusedPane: () => string | null,
-  setNote: (note: string | null) => void,
+  setNote: (note: string | null | ((current: string | null) => string | null)) => void,
 ) {
   const pending = createApplicationPendingTerminalInputOwner();
   let ownsNote = false;
@@ -87,6 +87,20 @@ export function createApplicationTerminalInputIngress(
     left.clientGeneration === right.clientGeneration &&
     left.session === right.session &&
     left.pane === right.pane;
+  // Rejection is an outcome for this exact terminal scope, not queue occupancy.
+  // Successful delivery of the admitted prefix must not hide lost input.
+  let rejectedRecoveryScope: RecoveryScope | null = null;
+  const rejectedRecoveryNote = "some terminal input was not sent during recovery";
+  const rejectedRecoveryAdmissionNote = `terminal input queue full · ${rejectedRecoveryNote}`;
+  const clearRejectedRecovery = () => {
+    if (!rejectedRecoveryScope) return;
+    rejectedRecoveryScope = null;
+    setNote((current) =>
+      current === rejectedRecoveryNote || current === rejectedRecoveryAdmissionNote
+        ? null
+        : current,
+    );
+  };
   let recoveryVersion = 0;
   const cancelRecovery = () => {
     recoveryVersion++;
@@ -105,6 +119,7 @@ export function createApplicationTerminalInputIngress(
       return false;
     const target = scope();
     if (!target) return false;
+    if (rejectedRecoveryScope && !sameScope(rejectedRecoveryScope, target)) clearRejectedRecovery();
     if (recovery && !sameScope(recovery.scope, target)) cancelRecovery();
     if (!recovery) {
       const timer = setTimeout(() => {
@@ -116,7 +131,8 @@ export function createApplicationTerminalInputIngress(
     }
     const weight = bytes.byteLength;
     if (recovery.admitted >= 64 || recovery.weight + weight > 1024 * 1024) {
-      setNote("terminal input queue full · wait for the session to connect");
+      rejectedRecoveryScope = target;
+      setNote(rejectedRecoveryAdmissionNote);
       return true;
     }
     recovery.weight += weight;
@@ -144,7 +160,7 @@ export function createApplicationTerminalInputIngress(
       }
       return true;
     });
-    setNote(`${target.session} · terminal ${kind} queued`);
+    if (!rejectedRecoveryScope) setNote(`${target.session} · terminal ${kind} queued`);
     return true;
   };
   const flushRecovery = () => {
@@ -173,7 +189,11 @@ export function createApplicationTerminalInputIngress(
       }
       if (version === recoveryVersion) {
         cancelRecovery();
-        setNote(null);
+        if (rejectedRecoveryScope) {
+          setNote((current) =>
+            current === rejectedRecoveryAdmissionNote ? rejectedRecoveryNote : current,
+          );
+        } else setNote(null);
       }
     })();
   };
@@ -210,6 +230,7 @@ export function createApplicationTerminalInputIngress(
 
   const cancelInteractionInput = () => {
     cancelRecovery();
+    clearRejectedRecovery();
     interaction.cancelPendingInput();
   };
   return {
@@ -236,6 +257,8 @@ export function createApplicationTerminalInputIngress(
       });
     },
     adopt(terminalsActive = true): void {
+      if (rejectedRecoveryScope && !sameScope(rejectedRecoveryScope, scope()))
+        clearRejectedRecovery();
       if (!terminalsActive) cancelInteractionInput();
       flush();
       flushRecovery();

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

@@ -1,5 +1,12 @@
 /* @jsxImportSource @opentui/solid */
-import { createRenderEffect, onCleanup, untrack, type Accessor } from "solid-js";
+import {
+  createRenderEffect,
+  createSignal,
+  Show,
+  onCleanup,
+  untrack,
+  type Accessor,
+} from "solid-js";
 
 import type {
   PaneSearchHighlight,
@@ -13,6 +20,7 @@ import type { TerminalReplicaSnapshot } from "@tmux-ide/contracts";
 export interface PaneScopedTerminalAdapter {
   readonly renderSource: import("../pane-surface.tsx").TerminalPaneRenderSource;
   paneVersion(paneId: string): number;
+  paneUnavailable?(paneId: string): string | null;
   panePresentationVersion?(paneId: string): number;
   paneSourceEpoch(): number;
   /** Coalesced exceptional recovery when a formerly coherent snapshot is absent. */
@@ -63,6 +71,7 @@ export interface PaneScopedTerminalSurfaceProps {
 /** One Solid owner per terminal pane; terminal output never wakes the root shell. */
 export function PaneScopedTerminalSurface(props: PaneScopedTerminalSurfaceProps) {
   let surface: PaneSurfaceRenderable | undefined;
+  const [unavailable, setUnavailable] = createSignal<string | null>(null);
   let activationEpoch = 0;
   let wasActive = false;
   let hadCanonicalSnapshot = false;
@@ -74,6 +83,9 @@ export function PaneScopedTerminalSurface(props: PaneScopedTerminalSurfaceProps)
     adapter: PaneScopedTerminalAdapter,
     paneId: string,
   ): void => {
+    const message = adapter.paneUnavailable?.(paneId) ?? null;
+    setUnavailable(message);
+    if (message) return;
     const identity = adapter.renderSource.paneCanonicalIdentity?.(paneId) ?? null;
     if (identity) {
       hadCanonicalSnapshot = true;
@@ -122,35 +134,53 @@ export function PaneScopedTerminalSurface(props: PaneScopedTerminalSurfaceProps)
   });
 
   return (
-    <pane_surface
-      ref={(renderable: PaneSurfaceRenderable) => {
-        surface = renderable;
-        renderable.contentVersion = props.adapter.paneVersion(props.paneId);
-        renderable.presentationVersion = props.adapter.panePresentationVersion?.(props.paneId) ?? 0;
-        renderable.sourceEpoch = props.sourceEpoch + props.adapter.paneSourceEpoch();
-        renderable.presentationGeneration = currentPresentationGeneration();
-        ensureRetainedCanonicalState(props.adapter, props.paneId);
-      }}
-      width={props.width}
-      height={props.height}
-      mirror={props.adapter.renderSource}
-      paneId={props.paneId}
-      defaultFg={props.defaultFg}
-      defaultBg={props.defaultBg}
-      terminalPalette={props.terminalPalette}
-      searchHl={props.searchHl}
-      searchCur={props.searchCur}
-      scrollOffset={props.scrollOffset}
-      viewportOrigin={props.viewportOrigin}
-      paneFocused={props.paneFocused}
-      contentVersion={props.adapter.paneVersion(props.paneId)}
-      presentationVersion={props.adapter.panePresentationVersion?.(props.paneId) ?? 0}
-      sourceEpoch={props.sourceEpoch + props.adapter.paneSourceEpoch()}
-      rendererEpoch={props.sourceEpoch}
-      hostFocusTransitionOwner={props.hostFocusTransitionOwner}
-      selRange={props.selRange}
-      copyCursor={props.copyCursor}
-      search={props.search}
-    />
+    <box width={props.width} height={props.height}>
+      <pane_surface
+        ref={(renderable: PaneSurfaceRenderable) => {
+          surface = renderable;
+          renderable.contentVersion = props.adapter.paneVersion(props.paneId);
+          renderable.presentationVersion =
+            props.adapter.panePresentationVersion?.(props.paneId) ?? 0;
+          renderable.sourceEpoch = props.sourceEpoch + props.adapter.paneSourceEpoch();
+          renderable.presentationGeneration = currentPresentationGeneration();
+          ensureRetainedCanonicalState(props.adapter, props.paneId);
+        }}
+        width={props.width}
+        height={props.height}
+        mirror={props.adapter.renderSource}
+        paneId={props.paneId}
+        defaultFg={props.defaultFg}
+        defaultBg={props.defaultBg}
+        terminalPalette={props.terminalPalette}
+        searchHl={props.searchHl}
+        searchCur={props.searchCur}
+        scrollOffset={props.scrollOffset}
+        viewportOrigin={props.viewportOrigin}
+        paneFocused={props.paneFocused}
+        contentVersion={props.adapter.paneVersion(props.paneId)}
+        presentationVersion={props.adapter.panePresentationVersion?.(props.paneId) ?? 0}
+        sourceEpoch={props.sourceEpoch + props.adapter.paneSourceEpoch()}
+        rendererEpoch={props.sourceEpoch}
+        hostFocusTransitionOwner={props.hostFocusTransitionOwner}
+        selRange={props.selRange}
+        copyCursor={props.copyCursor}
+        search={props.search}
+      />
+      <Show when={unavailable()}>
+        {(message) => (
+          <box
+            position="absolute"
+            left={0}
+            top={0}
+            width={props.width}
+            height={props.height}
+            backgroundColor={`#${props.defaultBg.toString(16).padStart(6, "0")}`}
+            padding={1}
+          >
+            <text fg={`#${props.defaultFg.toString(16).padStart(6, "0")}`}>{message()}</text>
+          </box>
+        )}
+      </Show>
+    </box>
   );
 }

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

@@ -155,6 +155,10 @@ export class TerminalFastLaneRendererAdapter implements PaneScopedTerminalAdapte
     this.#resourceSampler = resourceSampler;
   }
 
+  paneUnavailable(paneId: string): string | null {
+    return this.#lane.paneUnavailable(paneId);
+  }
+
   paneVersion(paneId: string): number {
     return this.#panes.get(paneId)?.version ?? 0;
   }
@@ -432,9 +436,33 @@ export class TerminalFastLaneRendererAdapter implements PaneScopedTerminalAdapte
     const interest = this.#interest(paneId);
     interest.listeners.add(listener);
     if (!interest.release) {
-      interest.release = this.#lane.subscribePane(paneId, (publication) => {
-        this.#publish(interest, publication);
-      });
+      interest.release = this.#lane.subscribePane(
+        paneId,
+        (publication) => {
+          this.#publish(interest, publication);
+        },
+        () => {
+          interest.retainedView?.capture?.abort();
+          interest.retainedView = undefined;
+          interest.state = null;
+          interest.pendingTrace = null;
+          interest.pendingHostFrame = null;
+          interest.rowProjectionCache?.clear();
+          interest.version++;
+          for (const listener of [...interest.listeners]) {
+            try {
+              listener(
+                interest.version,
+                this.#sourceEpoch,
+                interest.presentationVersion,
+                "content",
+              );
+            } catch {
+              /* Availability observers cannot interrupt sibling delivery. */
+            }
+          }
+        },
+      );
     }
     // The lane owns a generation-scoped canonical replica even while a pane is
     // off-screen. A newly mounted surface must be invalidated synchronously

package/packages/daemon/src/tui/mirror/runtime/terminal-input-adapter.ts

@@ -53,17 +53,20 @@ export function terminalInputsForPaste(text: string): readonly SessionRuntimeTer
   if (text.includes("\0")) throw new TypeError("terminal paste must not contain NUL");
   const framed = `\u001b[200~${text}\u001b[201~`;
   const inputs: SessionRuntimeTerminalInput[] = [];
-  for (
-    let offset = 0;
-    offset < framed.length;
-    offset += SESSION_RUNTIME_MAX_TERMINAL_INPUT_TEXT_CHARS
-  ) {
+  for (let offset = 0; offset < framed.length; ) {
+    let end = Math.min(offset + SESSION_RUNTIME_MAX_TERMINAL_INPUT_TEXT_CHARS, framed.length);
+    // Messages can be encoded independently. Keep a supplementary code point
+    // intact instead of relying on the receiver to rejoin its UTF-16 halves.
+    const last = framed.charCodeAt(end - 1);
+    const next = framed.charCodeAt(end);
+    if (last >= 0xd800 && last <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) end -= 1;
     inputs.push(
       SessionRuntimeTerminalInputSchemaZ.parse({
         kind: "text",
-        data: framed.slice(offset, offset + SESSION_RUNTIME_MAX_TERMINAL_INPUT_TEXT_CHARS),
+        data: framed.slice(offset, end),
       }),
     );
+    offset = end;
   }
   return Object.freeze(inputs);
 }