tmux-ide 2.9.4 → 2.9.5

package/packages/core/src/terminal-replica-hash-cache.ts

@@ -1,16 +1,31 @@
+import {
+  isSchemaValidProjectedTerminalReplicaRow,
+  TERMINAL_REPLICA_DEFAULT_COLOR,
+} from "./terminal-replica-owned-row.ts";
 import type { TerminalReplicaColor, TerminalReplicaRow } from "@tmux-ide/contracts";
 import { createBufferedFnv64, type BufferedFnv64 } from "./terminal-fnv64-wasm.ts";
 
 const ROW_HASH_CACHE = new WeakMap<object, string>();
 const DEEPLY_FROZEN_ROWS = new WeakSet<object>();
 const UTF8_ENCODER = new TextEncoder();
+// Fixed ASCII headers cover common terminal strings without retaining values.
+const SHORT_ASCII_HEADERS = Array.from({ length: 33 }, (_, length) => `s${length}:`);
 
 interface CanonicalKeyOrder {
-  readonly original: string[];
-  readonly sorted: string[];
+  readonly original: readonly string[];
+  readonly sorted: readonly string[];
   readonly tokens: readonly (string | null)[] | null;
 }
 
+// Only this exact internally constructed singleton proves the fixed layout.
+// Foreign defaults (including frozen lookalikes) retain generic key discovery.
+const DEFAULT_COLOR_KEYS = Object.freeze(["kind"]);
+const DEFAULT_COLOR_KEY_ORDER: CanonicalKeyOrder = Object.freeze({
+  original: DEFAULT_COLOR_KEYS,
+  sorted: DEFAULT_COLOR_KEYS,
+  tokens: Object.freeze(["s4:kind;"]),
+});
+
 /**
  * Streaming FNV-1a64 writer for the canonical terminal encoding.
  *
@@ -43,6 +58,7 @@ class CanonicalFnv64 {
   #keyOrders: CanonicalKeyOrder[] | null = null;
 
   keyOrder(record: Record<string, unknown>): CanonicalKeyOrder {
+    if (record === TERMINAL_REPLICA_DEFAULT_COLOR) return DEFAULT_COLOR_KEY_ORDER;
     const keys = Object.keys(record);
     if (keys.length > 32) return { original: keys, sorted: keys.sort(), tokens: null };
     for (const order of this.#keyOrders ?? []) {
@@ -116,7 +132,7 @@ class CanonicalFnv64 {
       }
     }
     if (ascii) {
-      this.ascii(`s${value.length}:`);
+      this.ascii(SHORT_ASCII_HEADERS[value.length] ?? `s${value.length}:`);
       this.ascii(value);
       this.ascii(";");
       return value.length;
@@ -129,6 +145,12 @@ class CanonicalFnv64 {
   }
 
   number(value: number): void {
+    // Common terminal widths and default attributes share exact canonical bytes.
+    // Equality intentionally preserves String(-0) === "0"; all other numbers
+    // retain the original formatting path.
+    if (value === 0) return void this.ascii("d1:0;");
+    if (value === 1) return void this.ascii("d1:1;");
+    if (value === 2) return void this.ascii("d1:2;");
     const text = String(value);
     this.ascii(`d${text.length}:${text};`);
   }
@@ -137,6 +159,36 @@ class CanonicalFnv64 {
     this.ascii(value ? "b1;" : "b0;");
   }
 
+  #projectedRow(row: TerminalReplicaRow): void {
+    this.ascii("o2:s5:cells;");
+    const cells = row.cells;
+    this.ascii(`a${cells.length}:`);
+    let index = 0;
+    // Preserve dynamic array iteration. A replaced inherited iterator can yield
+    // foreign values; only the exact immutable cell at this slot earns the path.
+    for (const cell of cells) {
+      if (index < cells.length && cell === cells[index]) {
+        this.ascii("o5:s10:attributes;");
+        this.number(cell.attributes);
+        this.ascii("s10:background;");
+        writeColor(this, cell.background);
+        this.ascii("s10:foreground;");
+        writeColor(this, cell.foreground);
+        this.ascii("s8:grapheme;");
+        this.string(cell.grapheme);
+        this.ascii("s5:width;");
+        this.number(cell.width);
+        this.ascii(";");
+      } else {
+        this.value(cell);
+      }
+      index++;
+    }
+    this.ascii(";s7:wrapped;");
+    this.boolean(row.wrapped);
+    this.ascii(";");
+  }
+
   value(value: unknown): void {
     if (value === null) {
       this.ascii("n;");
@@ -160,6 +212,10 @@ class CanonicalFnv64 {
       this.ascii(";");
       return;
     }
+    if (isSchemaValidProjectedTerminalReplicaRow(value)) {
+      this.#projectedRow(value as TerminalReplicaRow);
+      return;
+    }
     const record = value as Record<string, unknown>;
     const { sorted: keys, tokens } = this.keyOrder(record);
     this.ascii(`o${keys.length}:`);
@@ -198,22 +254,22 @@ export async function hashCanonicalTerminalValueCooperatively(
     work = 0;
     return true;
   };
-  type WorkItem =
-    | { readonly kind: "value"; readonly value: unknown }
-    | { readonly kind: "ascii"; readonly value: string }
-    | { readonly kind: "string"; readonly value: string };
-  const stack: WorkItem[] = [{ kind: "value", value }];
-  while (stack.length > 0) {
-    const item = stack.pop()!;
-    if (item.kind === "ascii") {
-      if (checkpoint(hash.ascii(item.value))) await yieldControl();
+  // Parallel stacks preserve the traversal and yield order without allocating
+  // a wrapper object for every value/key/token. pop() drops consumed references.
+  const kinds: ("value" | "ascii" | "string")[] = ["value"];
+  const values: unknown[] = [value];
+  while (values.length > 0) {
+    const kind = kinds.pop()!;
+    const value = values.pop();
+    if (kind === "ascii") {
+      if (checkpoint(hash.ascii(value as string))) await yieldControl();
       continue;
     }
-    if (item.kind === "string") {
-      if (checkpoint(hash.string(item.value) + 8)) await yieldControl();
+    if (kind === "string") {
+      if (checkpoint(hash.string(value as string) + 8)) await yieldControl();
       continue;
     }
-    const entry = item.value;
+    const entry = value;
     if (entry === null) {
       hash.ascii("n;");
       if (checkpoint(2)) await yieldControl();
@@ -235,19 +291,23 @@ export async function hashCanonicalTerminalValueCooperatively(
     }
     if (Array.isArray(entry)) {
       if (checkpoint(hash.ascii(`a${entry.length}:`) + 1)) await yieldControl();
-      stack.push({ kind: "ascii", value: ";" });
-      for (let index = entry.length - 1; index >= 0; index -= 1)
-        stack.push({ kind: "value", value: entry[index] });
+      kinds.push("ascii");
+      values.push(";");
+      for (let index = entry.length - 1; index >= 0; index -= 1) {
+        kinds.push("value");
+        values.push(entry[index]);
+      }
       continue;
     }
     const record = entry as Record<string, unknown>;
     const keys = hash.keyOrder(record).sorted;
     if (checkpoint(hash.ascii(`o${keys.length}:`) + keys.length)) await yieldControl();
-    stack.push({ kind: "ascii", value: ";" });
+    kinds.push("ascii");
+    values.push(";");
     for (let index = keys.length - 1; index >= 0; index -= 1) {
       const key = keys[index]!;
-      stack.push({ kind: "value", value: record[key] });
-      stack.push({ kind: "string", value: key });
+      kinds.push("value", "string");
+      values.push(record[key], key);
     }
   }
   return hash.digest();
@@ -473,6 +533,87 @@ export async function hashTerminalReplicaRowRunsCooperatively(
   return digest;
 }
 
+// Scalar colors: -1 default, -2 RGB negative zero, 0..255 indexed,
+// and 0x1000000 + value for other RGB values. No caller-owned color is adopted.
+const DECODED_DEFAULT_COLOR = Object.freeze({ kind: "default" } as const);
+function decodedScalarColor(value: number): TerminalReplicaColor {
+  if (value === -1) return DECODED_DEFAULT_COLOR;
+  if (value === -2) return Object.freeze({ kind: "rgb", value: -0 });
+  if (Number.isInteger(value) && value >= 0 && value <= 255)
+    return Object.freeze({ kind: "indexed", index: value });
+  if (Number.isInteger(value) && value >= 0x1000000 && value <= 0x1ffffff)
+    return Object.freeze({ kind: "rgb", value: value - 0x1000000 });
+  throw new TypeError("Invalid decoded scalar color");
+}
+
+/** Internal scalar construction only; no supplied graph, digest, or hash cache. */
+class DecodedTerminalReplicaRowBuilder {
+  readonly #cells: TerminalReplicaRow["cells"][number][] = [];
+  #finished = false;
+
+  appendRun(
+    count: number,
+    grapheme: string,
+    width: 0 | 1 | 2,
+    foreground: number,
+    background: number,
+    attributes: number,
+  ): void {
+    this.#assertOpen();
+    if (
+      !Number.isSafeInteger(count) ||
+      count < 1 ||
+      count > 16384 ||
+      typeof grapheme !== "string" ||
+      (width !== 0 && width !== 1 && width !== 2) ||
+      !Number.isInteger(attributes) ||
+      attributes < 0 ||
+      attributes > 255
+    )
+      throw new TypeError("Invalid decoded scalar run");
+    const cell = Object.freeze({
+      grapheme,
+      width,
+      foreground: decodedScalarColor(foreground),
+      background: decodedScalarColor(background),
+      attributes,
+    });
+    for (let index = 0; index < count; index += 1) this.#cells.push(cell);
+  }
+
+  finish(wrapped: boolean, cols: number | null): TerminalReplicaRow {
+    this.#assertOpen();
+    const cells = this.#cells;
+    // As in compact expansion, sum-width checks happen after every run parses.
+    if (cols !== null && cells.length !== cols) throw new TypeError("Compact row width mismatch");
+    if (cells.length < 1 || cells.length > 16384)
+      throw new TypeError("Compact row width is out of bounds");
+    for (let index = 0; index < cells.length; index += 1) {
+      if (cells[index]!.width === 2 && cells[index + 1]?.width !== 0)
+        throw new TypeError("Malformed compact wide cell");
+      if (cells[index]!.width === 0 && (index === 0 || cells[index - 1]?.width !== 2))
+        throw new TypeError("Malformed compact continuation cell");
+    }
+    if (typeof wrapped !== "boolean") throw new TypeError("Invalid decoded scalar wrapped");
+    this.#finished = true;
+    const row = Object.freeze({
+      cells: Object.freeze(cells),
+      wrapped,
+    }) as unknown as TerminalReplicaRow;
+    // Earn only deep immutability. Existing row hashing remains lazy and unchanged.
+    DEEPLY_FROZEN_ROWS.add(row);
+    return row;
+  }
+
+  #assertOpen(): void {
+    if (this.#finished) throw new Error("Decoded terminal row already finished");
+  }
+}
+
+export function createDecodedTerminalReplicaRowBuilder() {
+  return new DecodedTerminalReplicaRowBuilder();
+}
+
 /** Package-private verified-decoder seam; this module is not a package export. */
 export function primeTerminalReplicaRowHash(row: TerminalReplicaRow, digest: string): void {
   if (!/^[0-9a-f]{16}$/u.test(digest) || !isTerminalReplicaRowDeeplyFrozen(row))

package/packages/core/src/terminal-replica-owned-row.ts

@@ -1,8 +1,60 @@
-import type { TerminalReplicaRow } from "@tmux-ide/contracts";
+import type {
+  TerminalReplicaCell,
+  TerminalReplicaColor,
+  TerminalReplicaRow,
+} from "@tmux-ide/contracts";
 
 // Ownership proves immutable, ordinary data properties, not schema validity.
 // There is no registration API: callers can only obtain ownership by copying.
 const OWNED_ROWS = new WeakSet<TerminalReplicaRow>();
+// Earned only by exact scalar construction, never by immutable foreign copies.
+const SCHEMA_VALID_PROJECTED_ROWS = new WeakSet<TerminalReplicaRow>();
+
+export function isSchemaValidProjectedTerminalReplicaRow(row: unknown): boolean {
+  return (
+    typeof row === "object" &&
+    row !== null &&
+    SCHEMA_VALID_PROJECTED_ROWS.has(row as TerminalReplicaRow)
+  );
+}
+
+export const TERMINAL_REPLICA_DEFAULT_COLOR = Object.freeze({ kind: "default" } as const);
+
+// Trusted immutable producer values only. Empty storage and a literal space
+// remain distinct for reflow; foreign equivalent cells are still copied.
+export const TERMINAL_REPLICA_EMPTY_CELL: Readonly<TerminalReplicaCell> = Object.freeze({
+  grapheme: "",
+  width: 1,
+  attributes: 0,
+  foreground: TERMINAL_REPLICA_DEFAULT_COLOR,
+  background: TERMINAL_REPLICA_DEFAULT_COLOR,
+});
+export const TERMINAL_REPLICA_SPACE_CELL: Readonly<TerminalReplicaCell> = Object.freeze({
+  ...TERMINAL_REPLICA_EMPTY_CELL,
+  grapheme: " ",
+});
+
+function freezeColor(color: TerminalReplicaColor): TerminalReplicaColor {
+  if (color === TERMINAL_REPLICA_DEFAULT_COLOR) return color;
+  // Copy first: external objects (including getters) keep the existing detached
+  // data contract. Share only the exact default shape, without erasing fields.
+  const copy = { ...color };
+  return copy.kind === "default" && Reflect.ownKeys(copy).length === 1
+    ? TERMINAL_REPLICA_DEFAULT_COLOR
+    : Object.freeze(copy);
+}
+
+// Internal copy seam shared by row ownership and cooperative seed admission.
+// Exact trusted values may be shared; foreign objects always remain detached.
+export function freezeOwnedTerminalReplicaCell(cell: TerminalReplicaCell): TerminalReplicaCell {
+  return cell === TERMINAL_REPLICA_EMPTY_CELL || cell === TERMINAL_REPLICA_SPACE_CELL
+    ? cell
+    : Object.freeze({
+        ...cell,
+        foreground: freezeColor(cell.foreground),
+        background: freezeColor(cell.background),
+      });
+}
 
 export function isOwnedTerminalReplicaRow(row: unknown): row is TerminalReplicaRow {
   return typeof row === "object" && row !== null && OWNED_ROWS.has(row as TerminalReplicaRow);
@@ -12,16 +64,119 @@ export function freezeOwnedTerminalReplicaRow(row: TerminalReplicaRow): Terminal
   if (OWNED_ROWS.has(row)) return row;
   const frozen = Object.freeze({
     wrapped: row.wrapped,
-    cells: Object.freeze(
-      Array.from(row.cells, (cell) =>
-        Object.freeze({
-          ...cell,
-          foreground: Object.freeze({ ...cell.foreground }),
-          background: Object.freeze({ ...cell.background }),
-        }),
-      ),
-    ),
+    cells: Object.freeze(Array.from(row.cells, freezeOwnedTerminalReplicaCell)),
   }) as unknown as TerminalReplicaRow;
   OWNED_ROWS.add(frozen);
   return frozen;
 }
+
+/** Internal incremental copy seam. No caller-owned array or row can be branded.
+ * Ownership establishes detached immutable data, never schema validity. */
+export function createOwnedTerminalReplicaRowBuilder() {
+  const cells: TerminalReplicaCell[] = [];
+  let finished = false;
+  const assertOpen = () => {
+    if (finished) throw new Error("Terminal replica row builder already finished");
+  };
+  return Object.freeze({
+    append(source: TerminalReplicaCell): TerminalReplicaCell {
+      assertOpen();
+      const cell = freezeOwnedTerminalReplicaCell(source);
+      cells.push(cell);
+      return cell;
+    },
+    finish(source: TerminalReplicaRow, wrapped: boolean): TerminalReplicaRow {
+      assertOpen();
+      finished = true;
+      const row = Object.freeze({
+        ...source,
+        wrapped,
+        cells: Object.freeze(cells),
+      }) as unknown as TerminalReplicaRow;
+      OWNED_ROWS.add(row);
+      return row;
+    },
+  });
+}
+
+/** Parser construction seam: accepts primitives, never caller-owned objects or
+ * arrays. Ownership proves detached immutable data, not schema validity. */
+class ProjectedTerminalReplicaRowBuilder {
+  readonly #cells: TerminalReplicaCell[] = [];
+  #finished = false;
+  #schemaValid = true;
+
+  append(
+    grapheme: string,
+    width: 0 | 1 | 2,
+    attributes: number,
+    foregroundKind: TerminalReplicaColor["kind"],
+    foregroundValue: number,
+    backgroundKind: TerminalReplicaColor["kind"],
+    backgroundValue: number,
+  ): void {
+    this.#assertOpen();
+    if (typeof grapheme !== "string" || typeof width !== "number" || typeof attributes !== "number")
+      throw new TypeError("Projected terminal cell values must be primitive");
+    const foreground = projectedColor(foregroundKind, foregroundValue);
+    const background = projectedColor(backgroundKind, backgroundValue);
+    const cell =
+      width === 1 &&
+      attributes === 0 &&
+      foreground === TERMINAL_REPLICA_DEFAULT_COLOR &&
+      background === TERMINAL_REPLICA_DEFAULT_COLOR &&
+      (grapheme === "" || grapheme === " ")
+        ? grapheme === ""
+          ? TERMINAL_REPLICA_EMPTY_CELL
+          : TERMINAL_REPLICA_SPACE_CELL
+        : Object.freeze({ grapheme, width, foreground, background, attributes });
+    this.#cells.push(cell);
+    // Describe the emitted exact-key cell, preserving all original throws and
+    // invalid-but-owned construction. Default color does not emit its value.
+    this.#schemaValid =
+      this.#schemaValid &&
+      (width === 0 || width === 1 || width === 2) &&
+      Number.isInteger(attributes) &&
+      attributes >= 0 &&
+      attributes <= 0xff &&
+      projectedColorIsSchemaValid(foregroundKind, foregroundValue) &&
+      projectedColorIsSchemaValid(backgroundKind, backgroundValue);
+  }
+
+  finish(wrapped: boolean): TerminalReplicaRow {
+    this.#assertOpen();
+    if (typeof wrapped !== "boolean") throw new TypeError("Projected row wrapped must be boolean");
+    this.#finished = true;
+    const row = Object.freeze({
+      wrapped,
+      cells: Object.freeze(this.#cells),
+    }) as unknown as TerminalReplicaRow;
+    OWNED_ROWS.add(row);
+    if (this.#schemaValid) SCHEMA_VALID_PROJECTED_ROWS.add(row);
+    return row;
+  }
+
+  #assertOpen(): void {
+    if (this.#finished) throw new Error("Projected terminal row already finished");
+  }
+}
+
+function projectedColorIsSchemaValid(kind: TerminalReplicaColor["kind"], value: number): boolean {
+  return (
+    kind === "default" ||
+    (Number.isInteger(value) && value >= 0 && value <= (kind === "indexed" ? 255 : 0xffffff))
+  );
+}
+
+function projectedColor(kind: TerminalReplicaColor["kind"], value: number): TerminalReplicaColor {
+  if (typeof value !== "number")
+    throw new TypeError("Projected terminal color value must be primitive");
+  if (kind === "default") return TERMINAL_REPLICA_DEFAULT_COLOR;
+  if (kind === "indexed") return Object.freeze({ kind, index: value });
+  if (kind === "rgb") return Object.freeze({ kind, value });
+  throw new TypeError("Unknown projected terminal color kind");
+}
+
+export function createProjectedTerminalReplicaRowBuilder() {
+  return new ProjectedTerminalReplicaRowBuilder();
+}

package/packages/core/src/terminal-replica.ts

@@ -9,8 +9,22 @@ import type {
   TerminalReplicaSnapshot,
   TerminalReplicaTombstonePayload,
 } from "@tmux-ide/contracts";
-import { consumeCompactReplicaCapability } from "./terminal-compact-capability.ts";
-import { freezeOwnedTerminalReplicaRow as freezeRow } from "./terminal-replica-owned-row.ts";
+import {
+  consumeCompactReplicaCapability,
+  consumeVerifiedTombstoneInterval,
+} from "./terminal-compact-capability.ts";
+import {
+  freezeOwnedTerminalReplicaRow as freezeRow,
+  createOwnedTerminalReplicaRowBuilder,
+  isOwnedTerminalReplicaRow,
+  TERMINAL_REPLICA_DEFAULT_COLOR,
+} from "./terminal-replica-owned-row.ts";
+export {
+  createProjectedTerminalReplicaRowBuilder,
+  TERMINAL_REPLICA_DEFAULT_COLOR,
+  TERMINAL_REPLICA_EMPTY_CELL,
+  TERMINAL_REPLICA_SPACE_CELL,
+} from "./terminal-replica-owned-row.ts";
 import {
   hashCanonicalTerminalValue,
   hashCanonicalTerminalValueCooperatively,
@@ -24,7 +38,6 @@ import {
 // External Object.freeze calls do not establish this provenance.
 const VALIDATED_PATCH_ROWS = new WeakSet<TerminalReplicaRow>();
 
-const DEFAULT_COLOR = Object.freeze({ kind: "default" } as const);
 const ROW_ARRAY_HASH_CACHE = new WeakMap<
   object,
   { readonly hash: bigint; readonly length: number }
@@ -128,6 +141,10 @@ export function blankTerminalReplicaSnapshot(cols: number, rows: number): Termin
   });
 }
 
+// Only accepted verified coalesced tombstones need their original interval for replay.
+// Weak state keys preserve exact-duplicate idempotency without retaining retired replicas.
+const verifiedTombstoneBases = new WeakMap<TerminalReplicaState, number>();
+
 export function applyTerminalReplicaUpdate(
   current: TerminalReplicaState | null,
   update: CanonicalTerminalReplicaUpdate,
@@ -208,7 +225,8 @@ export function applyTerminalReplicaUpdate(
     if (update.type === "terminal.tombstone") {
       return complete(
         update.revision === current.revision &&
-          update.baseRevision === current.revision - 1 &&
+          (update.baseRevision === current.revision - 1 ||
+            verifiedTombstoneBases.get(current) === update.baseRevision) &&
           update.stateHash === current.hash &&
           current.tombstone?.reason === update.tombstone.reason &&
           current.frameHash === receivedFrameHash
@@ -231,7 +249,20 @@ export function applyTerminalReplicaUpdate(
           : { status: "stale", state: current },
     );
   }
-  if (update.baseRevision !== current.revision || update.revision !== current.revision + 1) {
+  const verifiedTombstoneJump =
+    update.type === "terminal.tombstone" &&
+    update.revision > current.revision + 1 &&
+    consumeVerifiedTombstoneInterval(
+      update.tombstone,
+      current.snapshot,
+      update.stateHash,
+      update.baseRevision,
+      update.revision,
+    );
+  if (
+    update.baseRevision !== current.revision ||
+    (update.revision !== current.revision + 1 && !verifiedTombstoneJump)
+  ) {
     return complete({
       status: "gap",
       state: current,
@@ -263,6 +294,7 @@ export function applyTerminalReplicaUpdate(
       hash,
       frameHash: receivedFrameHash,
     });
+    if (verifiedTombstoneJump) verifiedTombstoneBases.set(state, update.baseRevision);
     return complete({ status: "applied", state });
   }
   if (current.snapshot === null) {
@@ -498,33 +530,23 @@ export async function applyTerminalReplicaUpdateCooperatively(
     ] as const) {
       for (const row of sources) {
         if (row.cells.length !== cols) return complete(conflict());
-        const cells: TerminalReplicaRow["cells"] = [];
+        const owned = isOwnedTerminalReplicaRow(row);
+        const builder = owned ? null : createOwnedTerminalReplicaRowBuilder();
         let priorWidth = -1;
         const wrapped = row.wrapped;
         for (let index = 0; index < cols; index++) {
           const sourceCell = row.cells[index]!;
-          const cell = Object.freeze({
-            ...sourceCell,
-            foreground: Object.freeze({ ...sourceCell.foreground }),
-            background: Object.freeze({ ...sourceCell.background }),
-          });
+          const cell = owned ? sourceCell : builder!.append(sourceCell);
           if ((priorWidth === 2 && cell.width !== 0) || (cell.width === 0 && priorWidth !== 2))
             return complete(conflict());
           priorWidth = cell.width;
-          cells.push(cell);
           if (++work >= 256) {
             work = 0;
             await yieldControl();
           }
         }
         if (priorWidth === 2) return complete(conflict());
-        target.push(
-          Object.freeze({
-            ...row,
-            wrapped,
-            cells: Object.freeze(cells),
-          }) as unknown as TerminalReplicaRow,
-        );
+        target.push(owned ? row : builder!.finish(row, wrapped));
       }
     }
     const placements: TerminalReplicaSnapshot["placements"] = [];
@@ -827,8 +849,8 @@ function blankRow(cols: number): TerminalReplicaRow {
         Object.freeze({
           grapheme: " ",
           width: 1 as const,
-          foreground: DEFAULT_COLOR,
-          background: DEFAULT_COLOR,
+          foreground: TERMINAL_REPLICA_DEFAULT_COLOR,
+          background: TERMINAL_REPLICA_DEFAULT_COLOR,
           attributes: 0,
         }),
       ),

package/packages/daemon/dist/lib/daemon-embed.js

@@ -37,6 +37,7 @@ import { startOwnedEmbeddedDaemon } from "./embedded-daemon-lifecycle.js";
 import { execFileSync } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
+import { createRuntimeTraceWriter } from "./runtime-trace-writer.js";
 import { createServer } from "node:http";
 import { createRequire } from "node:module";
 import { performance } from "node:perf_hooks";
@@ -965,15 +966,11 @@ async function startEmbeddedDaemonGeneration(opts) {
                     throw new Error("Default tmux owner is retired");
             },
         });
-        let runtimeTraceStream = null;
-        const closeRuntimeTraceStream = async () => {
+        let runtimeTraceWriter = null;
+        const closeRuntimeTraceStream = async (incomplete = false) => {
             externalInteractionObserver.setDiagnostics(null);
             setFleetFactsObserverDiagnostics(null);
-            const stream = runtimeTraceStream;
-            runtimeTraceStream = null;
-            if (!stream || stream.closed || stream.destroyed)
-                return;
-            await new Promise((resolve) => stream.end(resolve));
+            await runtimeTraceWriter?.close(incomplete);
         };
         let startedServer;
         try {
@@ -1001,16 +998,9 @@ async function startEmbeddedDaemonGeneration(opts) {
                 return workspaceMultiplexer.mutate({ operationId, expectedDaemonInstanceId: instanceId, intent }, timing, execution);
             };
             const runtimeTracePath = process.env.TMUX_IDE_SESSION_RUNTIME_TRACE_LOG;
-            runtimeTraceStream = runtimeTracePath
-                ? createWriteStream(runtimeTracePath, { flags: "a", highWaterMark: 64 * 1_024 })
+            runtimeTraceWriter = runtimeTracePath
+                ? createRuntimeTraceWriter(createWriteStream(runtimeTracePath, { flags: "a", highWaterMark: 64 * 1024 }), { processId: `daemon:${process.pid}`, daemonInstanceId: instanceId })
                 : null;
-            let runtimeTraceSaturated = false;
-            runtimeTraceStream?.on("error", () => {
-                runtimeTraceSaturated = true;
-            });
-            runtimeTraceStream?.on("drain", () => {
-                runtimeTraceSaturated = false;
-            });
             const runtimeObservability = runtimeTracePath
                 ? createSessionRuntimeObservability({
                     // The JSONL stream is the qualifying record. Keep only a small
@@ -1019,27 +1009,22 @@ async function startEmbeddedDaemonGeneration(opts) {
                     // pauses on the daemon's input/output event loop.
                     capacity: 1_024,
                     onSpan: (span) => {
-                        if (!runtimeTraceStream || runtimeTraceSaturated)
-                            return;
-                        runtimeTraceSaturated = !runtimeTraceStream.write(`${JSON.stringify({ version: 1, type: "performance.stage", ...span })}\n`);
+                        runtimeTraceWriter?.append(() => ({
+                            version: 1,
+                            type: "performance.stage",
+                            ...span,
+                        }));
                     },
                 })
                 : undefined;
             if (runtimeTracePath) {
                 const publishObserverDiagnostic = (event) => {
-                    try {
-                        if (!runtimeTraceStream || runtimeTraceSaturated)
-                            return;
-                        runtimeTraceSaturated = !runtimeTraceStream.write(`${JSON.stringify({
-                            version: 1,
-                            type: "performance.daemon-observer",
-                            ...event,
-                            generation: instanceId,
-                        })}\n`);
-                    }
-                    catch {
-                        // Qualification diagnostics never alter daemon observation.
-                    }
+                    runtimeTraceWriter?.append(() => ({
+                        version: 1,
+                        type: "performance.daemon-observer",
+                        ...event,
+                        generation: instanceId,
+                    }));
                 };
                 const diagnostics = {
                     nowMicros: () => Math.floor(performance.now() * 1_000),
@@ -1438,7 +1423,7 @@ async function startEmbeddedDaemonGeneration(opts) {
                 appWindowMutation.dispose(),
                 workspaceMultiplexer.dispose(),
                 disposeInteractionObservation(),
-                closeRuntimeTraceStream(),
+                closeRuntimeTraceStream(true),
             ]);
             // The pane-stream coordinator may still hold runtime consumers while it
             // drains. Preserve the normal shutdown order on startup rollback too:
@@ -1487,7 +1472,7 @@ async function startEmbeddedDaemonGeneration(opts) {
                 appWindowMutationDisposal,
                 workspaceMultiplexerDisposal,
                 externalInteractionDisposal,
-                closeRuntimeTraceStream(),
+                closeRuntimeTraceStream(true),
                 Promise.resolve().then(() => closeClients()),
                 ...[...sockets].map((socket) => Promise.resolve().then(() => socket.destroy())),
                 Promise.race([closePromise, delay(100)]),