tmux-ide 2.9.2 → 2.9.4

package/packages/core/src/terminal-fnv64-wasm.test.ts

@@ -1,61 +0,0 @@
-import { afterEach, expect, it, vi } from "vitest";
-import { createBufferedFnv64 } from "./terminal-fnv64-wasm.ts";
-
-const reference = (bytes: Uint8Array): string => {
-  let state = 0xcbf29ce484222325n;
-  for (const byte of bytes) state = BigInt.asUintN(64, (state ^ BigInt(byte)) * 0x100000001b3n);
-  return state.toString(16).padStart(16, "0");
-};
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.resetModules();
-});
-
-it("matches exact FNV across scratch boundaries, UTF-8 and every byte value", () => {
-  for (const length of [0, 1, 4095, 4096, 4097, 16385]) {
-    const bytes = Uint8Array.from({ length }, (_, index) => index % 256);
-    const writer = createBufferedFnv64();
-    expect(writer).not.toBeNull();
-    writer!.bytes(bytes);
-    expect(writer!.digest()).toBe(reference(bytes));
-    expect(writer!.digest()).toBe(reference(bytes));
-  }
-  for (const text of ["é", "😀", "\ud800", "a\udc00z"]) {
-    const writer = createBufferedFnv64()!;
-    const bytes = new TextEncoder().encode(text);
-    writer.ascii("prefix");
-    writer.bytes(bytes);
-    writer.boolean(true);
-    expect(writer.digest()).toBe(reference(new TextEncoder().encode(`prefix${text}b1;`)));
-  }
-});
-
-it("keeps concurrent partially buffered writers independent across async yields", async () => {
-  await Promise.all(
-    Array.from({ length: 16 }, async (_, index) => {
-      const writer = createBufferedFnv64()!;
-      const parts = Array.from({ length: 20 }, (_, part) => `${index}:${part}:`.repeat(150));
-      for (const part of parts) {
-        expect(writer.ascii(part)).toBe(part.length);
-        await Promise.resolve();
-      }
-      expect(writer.digest()).toBe(reference(new TextEncoder().encode(parts.join(""))));
-    }),
-  );
-});
-
-it("returns the JS-fallback signal when WASM is unavailable or initialization is blocked", async () => {
-  vi.stubGlobal("WebAssembly", undefined);
-  vi.resetModules();
-  expect((await import("./terminal-fnv64-wasm.ts")).createBufferedFnv64()).toBeNull();
-  const blocked = vi.fn(function () {
-    throw new Error("WASM blocked");
-  });
-  vi.stubGlobal("WebAssembly", { Module: blocked });
-  vi.resetModules();
-  const module = await import("./terminal-fnv64-wasm.ts");
-  expect(module.createBufferedFnv64()).toBeNull();
-  expect(module.createBufferedFnv64()).toBeNull();
-  expect(blocked).toHaveBeenCalledTimes(1);
-});

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

@@ -1,31 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-describe("terminal replica cold Bun process", () => {
-  it("applies the first 132x41 last-column patch inside one frame", () => {
-    const fixture = fileURLToPath(
-      new URL("../test-support/terminal-replica-cold-process.ts", import.meta.url),
-    );
-    const result = spawnSync("bun", [fixture], { encoding: "utf8", timeout: 10_000 });
-    expect(result.status, result.stderr).toBe(0);
-    const measurement = JSON.parse(result.stdout.trim()) as {
-      durationMs: number;
-      profile: {
-        reusedAuthenticatedFrameHash: boolean;
-        phaseMicros: Record<string, number>;
-        counts: Record<string, number>;
-      };
-    };
-    expect(measurement.durationMs).toBeLessThanOrEqual(16.67);
-    expect(measurement.profile.reusedAuthenticatedFrameHash).toBe(true);
-    expect(measurement.profile.phaseMicros.updateHash).toBe(0);
-    expect(measurement.profile.counts).toMatchObject({
-      patchedRows: 1,
-      validatedCells: 132,
-      frozenCells: 132,
-      comparedCells: 132,
-      rowHashMisses: 1,
-    });
-  });
-});

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

@@ -1,170 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { CanonicalTerminalReplicaSeed } from "@tmux-ide/contracts";
-import {
-  applyTerminalReplicaUpdate,
-  applyTerminalReplicaUpdateCooperatively,
-  blankTerminalReplicaSnapshot,
-  hashTerminalReplicaSnapshot,
-  terminalReplicaUpdateNeedsCooperativeReduction,
-} from "./terminal-replica.ts";
-import {
-  decodeVerifiedCompactSemanticTerminalUpdate,
-  encodeCompactSemanticTerminalUpdate,
-} from "./terminal-delivery.ts";
-
-function seed(cols = 128, rows = 64): CanonicalTerminalReplicaSeed {
-  const snapshot = blankTerminalReplicaSnapshot(cols, rows);
-  return {
-    type: "terminal.seed",
-    workspaceName: "workspace",
-    semanticPaneId: "pane",
-    generation: "00000000-0000-4000-8000-000000000001",
-    incarnation: "00000000-0000-4000-8000-000000000001:0",
-    revision: 0,
-    cols,
-    rows,
-    snapshot,
-    stateHash: hashTerminalReplicaSnapshot(snapshot),
-    hashAlgorithm: "fnv1a64-v1",
-  };
-}
-const yielding = { yieldControl: async () => {} };
-describe("cooperative terminal seed reduction", () => {
-  it("matches ordinary state and exact frame hash for large seeds and replay", async () => {
-    const update = seed();
-    const sync = applyTerminalReplicaUpdate(null, update);
-    const asyncResult = await applyTerminalReplicaUpdateCooperatively(null, update, yielding);
-    expect(asyncResult).toEqual(sync);
-    expect(Object.isFrozen(asyncResult.state!.snapshot!.grid[0]!.cells[0])).toBe(true);
-    expect(
-      await applyTerminalReplicaUpdateCooperatively(asyncResult.state, update, yielding),
-    ).toEqual(applyTerminalReplicaUpdate(sync.state, update));
-  });
-  it.each([
-    "hash",
-    "dimensions",
-    "cursor",
-    "wide",
-    "placement",
-    "generation",
-    "incarnation",
-    "stale",
-  ])("preserves %s rejection/order semantics", async (kind) => {
-    const initial = seed();
-    const current = applyTerminalReplicaUpdate(null, initial).state;
-    const update = { ...structuredClone(initial) };
-    update.revision = 1;
-    if (kind === "hash") update.stateHash = "0000000000000000";
-    if (kind === "dimensions") update.cols++;
-    if (kind === "cursor") update.snapshot.cursor.x = update.cols;
-    if (kind === "wide") update.snapshot.grid[0]!.cells[0]!.width = 2;
-    if (kind === "placement")
-      update.snapshot.placements.push({
-        id: "p",
-        kind: "test",
-        row: 1000,
-        column: 0,
-        rows: 1,
-        columns: 1,
-        contentDigest: "x",
-      });
-    if (kind === "generation") update.generation = "00000000-0000-4000-8000-000000000002";
-    if (kind === "incarnation") update.incarnation = "other";
-    const baseline = kind === "stale" ? { ...current!, revision: 5 } : current;
-    expect(await applyTerminalReplicaUpdateCooperatively(baseline, update, yielding)).toEqual(
-      applyTerminalReplicaUpdate(baseline, update),
-    );
-  });
-  it("preserves existing upstream-validated boundary rather than silently changing schemas", async () => {
-    const update = { ...structuredClone(seed()) };
-    update.snapshot.cursor.x = -1;
-    update.stateHash = hashTerminalReplicaSnapshot(update.snapshot);
-    expect(await applyTerminalReplicaUpdateCooperatively(null, update, yielding)).toEqual(
-      applyTerminalReplicaUpdate(null, update),
-    );
-  });
-  it("yields during cell copying before traversing the complete snapshot and aborts cleanly", async () => {
-    const update = { ...structuredClone(seed()) };
-    let reads = 0;
-    for (const row of update.snapshot.grid)
-      for (const cell of row.cells)
-        Object.defineProperty(cell, "grapheme", {
-          enumerable: true,
-          get: () => {
-            reads++;
-            return "";
-          },
-        });
-    update.stateHash = hashTerminalReplicaSnapshot(update.snapshot);
-    reads = 0;
-    const controller = new AbortController();
-    const reason = new Error("owner retired");
-    await expect(
-      applyTerminalReplicaUpdateCooperatively(null, update, {
-        signal: controller.signal,
-        yieldControl: async () => {
-          expect(reads).toBe(256);
-          controller.abort(reason);
-        },
-      }),
-    ).rejects.toBe(reason);
-    expect(reads).toBe(256);
-  });
-  it("permits actual I/O turns while reducing wide rows and supports cancellation during hashing", async () => {
-    const update = seed(4096, 2);
-    let turns = 0;
-    const result = await applyTerminalReplicaUpdateCooperatively(null, update, {
-      yieldControl: () =>
-        new Promise<void>((resolve) =>
-          setImmediate(() => {
-            turns++;
-            resolve();
-          }),
-        ),
-    });
-    expect(result.status).toBe("applied");
-    expect(turns).toBeGreaterThan(32);
-    const controller = new AbortController();
-    let slices = 0;
-    await expect(
-      applyTerminalReplicaUpdateCooperatively(null, update, {
-        signal: controller.signal,
-        yieldControl: async () => {
-          if (++slices === 40) controller.abort();
-        },
-      }),
-    ).rejects.toMatchObject({ name: "AbortError" });
-  });
-  it("keeps small seed/patch reduction synchronous within the wrapper", async () => {
-    const update = seed(4, 2);
-    let yields = 0;
-    expect(terminalReplicaUpdateNeedsCooperativeReduction(update)).toBe(false);
-    const result = await applyTerminalReplicaUpdateCooperatively(null, update, {
-      yieldControl: async () => {
-        yields++;
-      },
-    });
-    expect(result).toEqual(applyTerminalReplicaUpdate(null, update));
-    expect(yields).toBe(0);
-  });
-  it("preserves verified compact adoption and authenticated frame hash", async () => {
-    const original = seed();
-    const verified = decodeVerifiedCompactSemanticTerminalUpdate(
-      encodeCompactSemanticTerminalUpdate({
-        frame: "seed",
-        revision: 0,
-        snapshot: original.snapshot,
-      }),
-      null,
-      original.stateHash,
-      { grantReducerAdoption: true },
-    );
-    const update = { ...original, snapshot: verified.canonicalSnapshot! };
-    const result = await applyTerminalReplicaUpdateCooperatively(null, update, {
-      ...yielding,
-      authenticatedFrameHash: "1234567890abcdef",
-    });
-    expect(result.state!.snapshot).toBe(verified.canonicalSnapshot);
-    expect(result.state!.frameHash).toBe("1234567890abcdef");
-  });
-});

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

@@ -1,283 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import * as bufferedHash from "./terminal-fnv64-wasm.ts";
-import type { TerminalReplicaRow, TerminalReplicaSnapshot } from "@tmux-ide/contracts";
-import { blankTerminalReplicaSnapshot, hashTerminalReplicaSnapshot } from "./terminal-replica.ts";
-import {
-  hashCanonicalTerminalValue,
-  hashTerminalReplicaRowCached,
-  hashTerminalReplicaRowRunsCooperatively,
-  TerminalReplicaRunEncodingCache,
-} from "./terminal-replica-hash-cache.ts";
-
-const canonicalEncode = (value: unknown): string => {
-  if (value === null) return "n;";
-  if (typeof value === "boolean") return value ? "b1;" : "b0;";
-  if (typeof value === "number") return `d${String(value).length}:${String(value)};`;
-  if (typeof value === "string") {
-    const length = new TextEncoder().encode(value).length;
-    return `s${length}:${value};`;
-  }
-  if (Array.isArray(value)) return `a${value.length}:${value.map(canonicalEncode).join("")};`;
-  const record = value as Record<string, unknown>;
-  const keys = Object.keys(record).sort();
-  return `o${keys.length}:${keys
-    .map((key) => `${canonicalEncode(key)}${canonicalEncode(record[key])}`)
-    .join("")};`;
-};
-
-const referenceHash = (value: unknown): string => {
-  const bytes = new TextEncoder().encode(canonicalEncode(value));
-  let hash = 0xcbf29ce484222325n;
-  for (const byte of bytes) {
-    hash ^= BigInt(byte);
-    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
-  }
-  return hash.toString(16).padStart(16, "0");
-};
-
-describe("terminal canonical hash cache", () => {
-  it("accelerates substantial transactions without changing hashes or cooperative checkpoints", async () => {
-    const cache = new TerminalReplicaRunEncodingCache();
-    const factory = vi.spyOn(bufferedHash, "createBufferedFnv64");
-    const cell = {
-      ...blankTerminalReplicaSnapshot(1, 1).grid[0]!.cells[0]!,
-      grapheme: "界e\u0301\ud800",
-    };
-    const row = { wrapped: true, cells: Array.from({ length: 1_024 }, () => cell) };
-    const expected = hashTerminalReplicaRowCached(row);
-    const decode = async (encodingCache: TerminalReplicaRunEncodingCache) => {
-      let checkpoints = 0;
-      const digest = await hashTerminalReplicaRowRunsCooperatively(
-        true,
-        row.cells.length,
-        [[row.cells.length, cell]],
-        async () => {
-          checkpoints += 1;
-        },
-        64,
-        undefined,
-        encodingCache,
-      );
-      expect(digest).toBe(expected);
-      expect(checkpoints).toBe(16);
-    };
-    try {
-      await decode(cache);
-      expect(factory).not.toHaveBeenCalled();
-      await Promise.all([decode(cache), decode(cache)]);
-      expect(factory).toHaveBeenCalledTimes(2);
-      expect(factory.mock.results.every((result) => result.value !== null)).toBe(true);
-      // A separate client/delivery does not inherit another transaction's work.
-      await decode(new TerminalReplicaRunEncodingCache());
-      expect(factory).toHaveBeenCalledTimes(2);
-      factory.mockReturnValue(null);
-      await decode(cache);
-      expect(factory).toHaveBeenCalledTimes(3);
-    } finally {
-      factory.mockRestore();
-    }
-  });
-
-  it("preserves carries and wraparound over every indexed color and RGB byte extreme", () => {
-    const colors = [
-      { kind: "default" },
-      ...Array.from({ length: 256 }, (_, index) => ({ kind: "indexed", index })),
-      ...[0, 0xff, 0xff00, 0xff0000, 0xffffff].map((value) => ({ kind: "rgb", value })),
-    ];
-    const values = colors.map((foreground, index) => [
-      String.fromCharCode(index % 128),
-      index % 3,
-      foreground,
-      colors[colors.length - index - 1],
-      index * 257,
-    ]);
-    expect(hashCanonicalTerminalValue([true, values])).toBe(referenceHash([true, values]));
-  });
-
-  it("preserves exact UTF-8 hashes across ASCII boundaries and malformed surrogates", () => {
-    const values = [
-      "",
-      " ",
-      Array.from({ length: 128 }, (_, index) => String.fromCharCode(index)).join(""),
-      "a".repeat(1024),
-      "\u007f\u0080",
-      "ASCII界",
-      "e\u0301",
-      "😀",
-      "\ud800",
-      "\udc00",
-      "a\ud800z",
-    ];
-    for (const value of values) {
-      expect(hashCanonicalTerminalValue(value)).toBe(referenceHash(value));
-      expect(hashCanonicalTerminalValue({ [value]: [value, "", "tail"] })).toBe(
-        referenceHash({ [value]: [value, "", "tail"] }),
-      );
-    }
-  });
-
-  it("matches the prior canonical BigInt hash for nested UTF-8 values", () => {
-    const corpus = [
-      null,
-      true,
-      false,
-      0,
-      -17,
-      "ASCII",
-      "界e\u0301\ud800",
-      [null, true, 17, "wide界"],
-      { z: [1, 2], a: { kind: "rgb", value: 0xff00aa } },
-    ];
-    for (const value of corpus)
-      expect(hashCanonicalTerminalValue(value)).toBe(referenceHash(value));
-  });
-
-  it("matches the prior row hash for indexed, RGB, wide and combining cells", () => {
-    const blank = blankTerminalReplicaSnapshot(3, 1);
-    const row = Object.freeze({
-      wrapped: true,
-      cells: Object.freeze([
-        Object.freeze({
-          ...blank.grid[0]!.cells[0]!,
-          grapheme: "界",
-          width: 2 as const,
-          foreground: Object.freeze({ kind: "indexed" as const, index: 75 }),
-        }),
-        Object.freeze({
-          ...blank.grid[0]!.cells[1]!,
-          grapheme: "",
-          width: 0 as const,
-          background: Object.freeze({ kind: "rgb" as const, value: 0x112233 }),
-        }),
-        Object.freeze({ ...blank.grid[0]!.cells[2]!, grapheme: "e\u0301", attributes: 7 }),
-      ]),
-    }) as unknown as TerminalReplicaRow;
-    const projected = [
-      row.wrapped,
-      row.cells.map((cell) => [
-        cell.grapheme,
-        cell.width,
-        cell.foreground,
-        cell.background,
-        cell.attributes,
-      ]),
-    ];
-    expect(hashTerminalReplicaRowCached(row)).toBe(referenceHash(projected));
-    expect(hashTerminalReplicaRowCached(row)).toBe(referenceHash(projected));
-  });
-
-  it("replays one UTF-8 encoding per compact run with exhaustive row-hash parity", async () => {
-    const blank = blankTerminalReplicaSnapshot(5, 1);
-    const cells = [
-      Object.freeze({
-        ...blank.grid[0]!.cells[0]!,
-        grapheme: "界",
-        width: 2 as const,
-        foreground: Object.freeze({ kind: "indexed" as const, index: 75 }),
-      }),
-      Object.freeze({
-        ...blank.grid[0]!.cells[0]!,
-        grapheme: "",
-        width: 0 as const,
-        background: Object.freeze({ kind: "rgb" as const, value: 0x112233 }),
-      }),
-      Object.freeze({
-        ...blank.grid[0]!.cells[0]!,
-        grapheme: "e\u0301",
-        attributes: 0xff,
-      }),
-    ];
-    const row = Object.freeze({
-      wrapped: true,
-      cells: Object.freeze([cells[0]!, cells[1]!, cells[2]!, cells[2]!, cells[2]!]),
-    }) as unknown as TerminalReplicaRow;
-    const encodedRuns: number[] = [];
-    const digest = await hashTerminalReplicaRowRunsCooperatively(
-      true,
-      5,
-      [
-        [1, cells[0]!],
-        [1, cells[1]!],
-        [3, cells[2]!],
-      ],
-      async () => {},
-      2,
-      (bytes) => encodedRuns.push(bytes),
-    );
-    expect(digest).toBe(hashTerminalReplicaRowCached(row));
-    expect(encodedRuns).toEqual([3, 0, 3]);
-  });
-
-  it("never caches a shallow-frozen snapshot whose nested canonical state remains mutable", () => {
-    const blank = blankTerminalReplicaSnapshot(2, 1);
-    const cursor = { ...blank.cursor };
-    const modes = { ...blank.modes };
-    const placements = [
-      {
-        id: "placement-a",
-        kind: "image",
-        row: 0,
-        column: 0,
-        columns: 1,
-        rows: 1,
-        contentDigest: "digest-a",
-      },
-    ];
-    const history: TerminalReplicaRow[] = [];
-    const snapshot = Object.freeze({
-      ...blank,
-      grid: [...blank.grid],
-      history,
-      cursor,
-      modes,
-      placements,
-    }) as unknown as TerminalReplicaSnapshot;
-    const initial = hashTerminalReplicaSnapshot(snapshot);
-    cursor.x = 1;
-    const cursorChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(cursorChanged).not.toBe(initial);
-    modes.insert = true;
-    const modesChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(modesChanged).not.toBe(cursorChanged);
-    placements[0]!.contentDigest = "digest-b";
-    const placementChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(placementChanged).not.toBe(modesChanged);
-    history.push(blank.grid[0]!);
-    expect(hashTerminalReplicaSnapshot(snapshot)).not.toBe(placementChanged);
-  });
-
-  it("never caches frozen row arrays or rows with mutable nested cells and colors", () => {
-    const blank = blankTerminalReplicaSnapshot(1, 1);
-    const foreground = { kind: "rgb" as const, value: 0x112233 };
-    const background = { kind: "rgb" as const, value: 0x445566 };
-    const cell = {
-      ...blank.grid[0]!.cells[0]!,
-      foreground,
-      background,
-    };
-    const row = Object.freeze({ wrapped: false, cells: Object.freeze([cell]) });
-    const snapshot = Object.freeze({
-      ...blank,
-      grid: Object.freeze([row]),
-    }) as unknown as TerminalReplicaSnapshot;
-    const initial = hashTerminalReplicaSnapshot(snapshot);
-    cell.grapheme = "x";
-    const graphemeChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(graphemeChanged).not.toBe(initial);
-    cell.attributes = 7;
-    const styleChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(styleChanged).not.toBe(graphemeChanged);
-    foreground.value = 0xaabbcc;
-    const colorChanged = hashTerminalReplicaSnapshot(snapshot);
-    expect(colorChanged).not.toBe(styleChanged);
-
-    const mutableRow = { wrapped: false, cells: blank.grid[0]!.cells };
-    const mutableRowSnapshot = Object.freeze({
-      ...blank,
-      grid: Object.freeze([mutableRow]),
-    }) as unknown as TerminalReplicaSnapshot;
-    const rowInitial = hashTerminalReplicaSnapshot(mutableRowSnapshot);
-    mutableRow.wrapped = true;
-    expect(hashTerminalReplicaSnapshot(mutableRowSnapshot)).not.toBe(rowInitial);
-  });
-});