tmux-ide 2.9.4 → 2.9.6

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/command-center/resources/application-shell.js

@@ -43,7 +43,7 @@ function label(value, fallback) {
     const normalized = withoutControls.replace(/\s+/gu, " ").trim().slice(0, 160);
     return normalized || fallback;
 }
-function fallbackPaneId(session, pane) {
+export function fallbackPaneId(session, pane) {
     // Runtime identity is hashed, never serialized. Unlike title/command/index,
     // it is stable for the lifetime of a pane across resource refreshes.
     return semanticId("terminal.discovered", JSON.stringify({

package/packages/daemon/dist/command-center/tmux-server-editor-context.js

@@ -0,0 +1,45 @@
+import { PaneEditorContextResponseSchemaZ, PaneEditorContextTargetSchemaZ, TmuxServerScopeSchemaZ, } from "@tmux-ide/contracts";
+import { TmuxServerScopeError } from "../lib/tmux-server-owners.js";
+/** Mount only below the enclosing owner-authenticated, no-store scoped router. */
+export function mountTmuxServerEditorContextRoute(app, options) {
+    app.post(`${options.scopedPath}/pane-editor-context`, async (c) => {
+        const scope = TmuxServerScopeSchemaZ.safeParse({
+            serverId: c.req.param("serverId"),
+            generation: c.req.param("generation"),
+        });
+        if (!scope.success)
+            return c.json({ error: { code: "invalid-request" } }, 400);
+        let body;
+        try {
+            body = await options.readBody(c.req.raw);
+        }
+        catch {
+            return c.json({ error: { code: "invalid-request" } }, 400);
+        }
+        const target = PaneEditorContextTargetSchemaZ.safeParse(body);
+        if (!target.success)
+            return c.json({ error: { code: "invalid-request" } }, 400);
+        if (target.data.generation !== scope.data.generation)
+            return c.json({ error: { code: "stale-generation" } }, 409);
+        try {
+            c.req.raw.signal.throwIfAborted();
+            const context = await options.owners.withOwner(scope.data, (owner) => owner.resolvePaneEditorContext(target.data, c.req.raw.signal));
+            c.req.raw.signal.throwIfAborted();
+            const response = PaneEditorContextResponseSchemaZ.safeParse({
+                version: 1,
+                server: scope.data,
+                context,
+            });
+            if (!response.success ||
+                Object.entries(target.data).some(([key, value]) => context[key] !== value))
+                throw new Error("Invalid editor context observation");
+            return c.json(response.data);
+        }
+        catch (error) {
+            // Never serialize cwd, filesystem errors, raw owner messages or validation issues.
+            if (error instanceof TmuxServerScopeError)
+                return c.json({ error: { code: "scope-unavailable" } }, error.code === "not-found" ? 404 : 409);
+            return c.json({ error: { code: "editor-context-unavailable" } }, 503);
+        }
+    });
+}