tmux-ide 2.9.2 → 2.9.4

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

@@ -1,87 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-describe("compact terminal delivery cold process", () => {
-  it("adopts a unique-row 132x41 seed and 5000-history patch below the event-loop cap", () => {
-    const fixture = fileURLToPath(
-      new URL("../test-support/terminal-compact-cold-process.ts", import.meta.url),
-    );
-    const result = spawnSync(process.execPath, ["--experimental-strip-types", fixture], {
-      encoding: "utf8",
-      timeout: 30_000,
-    });
-    expect(result.status, result.stderr).toBe(0);
-    const measurement = JSON.parse(result.stdout.trim()) as {
-      durationMs: number;
-      timerDelayMs: number;
-      rssBytes: number;
-      heapBytes: number;
-      revision: number;
-      uniqueHistoryRows: number;
-      profiles: Array<Record<string, unknown>>;
-    };
-    expect(measurement).toMatchObject({ revision: 1, uniqueHistoryRows: 5_000 });
-    expect(measurement.rssBytes).toBeLessThan(1_073_741_824);
-    expect(measurement.heapBytes).toBeLessThan(536_870_912);
-    expect(measurement.durationMs).toBeLessThan(30_000);
-    expect(measurement.profiles).toHaveLength(2);
-    expect(measurement.profiles).toEqual([
-      expect.objectContaining({
-        expandedRows: 4_137,
-        expandedCells: 546_084,
-        schemaTraversals: 1,
-        hashTraversals: 1,
-        applyTraversals: 0,
-        trustedAdoption: true,
-        retainedSnapshots: 0,
-      }),
-      expect.objectContaining({
-        expandedRows: 904,
-        expandedCells: 119_328,
-        schemaTraversals: 1,
-        hashTraversals: 1,
-        applyTraversals: 1,
-        trustedAdoption: true,
-        retainedSnapshots: 0,
-      }),
-    ]);
-    expect(measurement.timerDelayMs).toBeLessThanOrEqual(33);
-  }, 35_000);
-
-  it("bounds an 8MiB max-width high-run compact seed through final hash", () => {
-    const fixture = fileURLToPath(
-      new URL("../test-support/terminal-compact-max-cold-process.ts", import.meta.url),
-    );
-    const result = spawnSync(process.execPath, ["--experimental-strip-types", fixture], {
-      encoding: "utf8",
-      timeout: 35_000,
-    });
-    expect(result.status, result.stderr).toBe(0);
-    const measurement = JSON.parse(result.stdout.trim()) as {
-      timerDelayMs: number;
-      maxSliceMs: number;
-      maxSliceStage: string;
-      representationBytes: number;
-      denseRepresentationBytes: number;
-      denseRejected: boolean;
-      rssBytes: number;
-      heapBytes: number;
-      revision: number;
-      hash: string;
-    };
-    expect(measurement).toMatchObject({ revision: 0, denseRejected: true });
-    expect(measurement.hash).toMatch(/^[0-9a-f]{16}$/u);
-    expect(measurement.representationBytes).toBeGreaterThan(8 * 1024 * 1024);
-    expect(measurement.denseRepresentationBytes).toBeGreaterThan(14 * 1024 * 1024);
-    expect(measurement.rssBytes).toBeLessThan(1_073_741_824);
-    expect(measurement.heapBytes).toBeLessThan(536_870_912);
-    // This max-width stress case also parses and rejects a deliberately dense
-    // 15 MB legacy payload. Keep wall-clock scheduler jitter and the measured
-    // CPU slice bounded without conflating this adversarial rejection path with
-    // the 33 ms interactive budget enforced by performance qualification.
-    expect(measurement.timerDelayMs).toBeLessThanOrEqual(60);
-    expect(measurement.maxSliceMs).toBeLessThanOrEqual(150);
-    expect(measurement.maxSliceStage).not.toBe("");
-  }, 40_000);
-});

package/packages/core/src/terminal-conformance.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  TERMINAL_CONFORMANCE_FIXTURES,
-  XTERM_PALETTE,
-  XTERM_PALETTE_HEX,
-} from "./terminal-conformance.ts";
-
-describe("terminal conformance corpus", () => {
-  it("defines one complete, byte-identical xterm palette for every renderer", () => {
-    expect(XTERM_PALETTE).toHaveLength(256);
-    expect(XTERM_PALETTE_HEX).toHaveLength(256);
-    expect(XTERM_PALETTE[0]).toBe(0x000000);
-    expect(XTERM_PALETTE[16]).toBe(0x000000);
-    expect(XTERM_PALETTE[231]).toBe(0xffffff);
-    expect(XTERM_PALETTE[232]).toBe(0x080808);
-    expect(XTERM_PALETTE[255]).toBe(0xeeeeee);
-    for (let index = 0; index < XTERM_PALETTE.length; index += 1) {
-      expect(XTERM_PALETTE_HEX[index]).toBe(
-        `#${XTERM_PALETTE[index]!.toString(16).padStart(6, "0")}`,
-      );
-    }
-  });
-
-  it("keeps fixture ids and asserted cell coordinates unique", () => {
-    const ids = TERMINAL_CONFORMANCE_FIXTURES.map((fixture) => fixture.id);
-    expect(new Set(ids).size).toBe(ids.length);
-    for (const fixture of TERMINAL_CONFORMANCE_FIXTURES) {
-      const cells = fixture.cells.map((cell) => `${cell.row}:${cell.column}`);
-      expect(new Set(cells).size, fixture.id).toBe(cells.length);
-      expect(fixture.writes.join("").length, fixture.id).toBeGreaterThan(0);
-      for (const cell of fixture.cells) {
-        expect(cell.row).toBeLessThan(fixture.rows);
-        expect(cell.column).toBeLessThan(fixture.cols);
-      }
-      for (const row of fixture.wrappedRows ?? []) {
-        expect(row, `${fixture.id} wrapped row`).toBeGreaterThanOrEqual(0);
-        expect(row, `${fixture.id} wrapped row`).toBeLessThan(fixture.rows);
-      }
-      if (fixture.cursor) {
-        expect(fixture.cursor.x, `${fixture.id} cursor x`).toBeLessThan(fixture.cols);
-        expect(fixture.cursor.y, `${fixture.id} cursor y`).toBeLessThan(fixture.rows);
-      }
-      if (fixture.historyRows !== undefined)
-        expect(fixture.historyRows, `${fixture.id} history`).toBeGreaterThanOrEqual(0);
-    }
-  });
-});

package/packages/core/src/terminal-delivery-cache-lifetime.test.ts

@@ -1,167 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { build } from "esbuild";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import {
-  applyTerminalReplicaPatch,
-  blankTerminalReplicaSnapshot,
-  hashTerminalReplicaSnapshot,
-} from "./terminal-replica.ts";
-import {
-  decodeVerifiedCompactSemanticTerminalUpdateCooperatively as decode,
-  encodeCompactSemanticTerminalUpdate,
-} from "./terminal-delivery.ts";
-
-const yieldControl = async () => {};
-
-async function decodedBlank() {
-  const input = blankTerminalReplicaSnapshot(8, 2);
-  return (
-    await decode(
-      encodeCompactSemanticTerminalUpdate({ frame: "seed", revision: 0, snapshot: input }),
-      null,
-      hashTerminalReplicaSnapshot(input),
-      { yieldControl },
-    )
-  ).canonicalSnapshot!;
-}
-
-describe("compact baseline index lifetime", () => {
-  it("reuses a row that entered the current baseline after the first index was built", async () => {
-    let baseline = await decodedBlank();
-    for (let revision = 1; revision <= 3; revision += 1) {
-      const row = structuredClone(baseline.grid[0]!);
-      row.cells[0]!.grapheme = "X";
-      const patch = { rows: [{ index: 1, row }], cursor: { ...baseline.cursor, x: revision } };
-      const expected = applyTerminalReplicaPatch(baseline, patch);
-      let counts: { allocatedCells: number; reusedRows: number } | undefined;
-      const result = await decode(
-        encodeCompactSemanticTerminalUpdate({
-          frame: "patch",
-          baseRevision: revision - 1,
-          revision,
-          patch,
-        }),
-        baseline,
-        hashTerminalReplicaSnapshot(expected),
-        {
-          yieldControl,
-          onComplete: (profile) => {
-            counts = profile;
-          },
-        },
-      );
-      expect(result.canonicalSnapshot).toEqual(expected);
-      expect(counts).toMatchObject(
-        revision === 1
-          ? { allocatedCells: 8, reusedRows: 0 }
-          : { allocatedCells: 0, reusedRows: 1 },
-      );
-      if (revision > 1) expect(result.canonicalSnapshot!.grid[1]).toBe(baseline.grid[1]);
-      baseline = result.canonicalSnapshot!;
-    }
-  });
-
-  it("checks history when a same-hash grid candidate has different bytes", async () => {
-    const blank = blankTerminalReplicaSnapshot(1, 1);
-    const row = (grapheme: string) => ({
-      wrapped: false,
-      cells: [{ ...blank.grid[0]!.cells[0]!, grapheme }],
-    });
-    // These encoded rows collide in the raw FNV32 cache, but differ canonically.
-    const input = { ...blank, grid: [row("dkzbb9")], history: [row("1mu5745")] };
-    const baseline = (
-      await decode(
-        encodeCompactSemanticTerminalUpdate({ frame: "seed", revision: 0, snapshot: input }),
-        null,
-        hashTerminalReplicaSnapshot(input),
-        { yieldControl },
-      )
-    ).canonicalSnapshot!;
-    const patch = { rows: [{ index: 0, row: baseline.history[0]! }] };
-    const expected = applyTerminalReplicaPatch(baseline, patch);
-    let counts: { allocatedCells: number; reusedRows: number } | undefined;
-    const result = await decode(
-      encodeCompactSemanticTerminalUpdate({ frame: "patch", baseRevision: 0, revision: 1, patch }),
-      baseline,
-      hashTerminalReplicaSnapshot(expected),
-      {
-        yieldControl,
-        onComplete: (profile) => {
-          counts = profile;
-        },
-      },
-    );
-    expect(result.canonicalSnapshot).toEqual(expected);
-    expect(result.canonicalSnapshot!.grid[0]).toBe(baseline.history[0]);
-    expect(counts).toMatchObject({ allocatedCells: 0, reusedRows: 1 });
-  });
-
-  // An isolated Node process provides explicit GC without sharing Vitest's
-  // retained assertions, module jobs or heap with the weak-reference probe.
-  let directory: string;
-  let probe: string;
-  beforeAll(async () => {
-    directory = mkdtempSync(join(tmpdir(), "tmux-compact-lifetime-"));
-    probe = join(directory, "probe.mjs");
-    const replica = fileURLToPath(new URL("./terminal-replica.ts", import.meta.url));
-    const delivery = fileURLToPath(new URL("./terminal-delivery.ts", import.meta.url));
-    await build({
-      stdin: {
-        contents: `
-import {blankTerminalReplicaSnapshot,hashTerminalReplicaSnapshot,applyTerminalReplicaPatch} from ${JSON.stringify(replica)};
-import {encodeCompactSemanticTerminalUpdate,decodeVerifiedCompactSemanticTerminalUpdateCooperatively as decode} from ${JSON.stringify(delivery)};
-const yieldControl=async()=>{};
-const blank=blankTerminalReplicaSnapshot(8,1);
-function row(label){const r=structuredClone(blank.grid[0]);r.cells[0].grapheme=label;return r;}
-async function setup(){
- const chain=process.argv[2]==='chain';
- const input={...blank,grid:[row('A')],history:chain?[row('B')]:Array.from({length:2000},(_,i)=>row('old-'+i))};
- let state=(await decode(encodeCompactSemanticTerminalUpdate({frame:'seed',revision:0,snapshot:input}),null,hashTerminalReplicaSnapshot(input),{yieldControl})).canonicalSnapshot;
- const anchor=state.grid[0];const refs=[];let revision=0;
- async function patch(p){const next=applyTerminalReplicaPatch(state,p);state=(await decode(encodeCompactSemanticTerminalUpdate({frame:'patch',baseRevision:revision,revision:++revision,patch:p}),state,hashTerminalReplicaSnapshot(next),{yieldControl})).canonicalSnapshot;}
- if(chain){
-  for(let i=0;i<50;i++){
-   await patch({rows:[{index:0,row:state.history[0]}],history:[row('next-'+i)]});
-   await patch({rows:[],cursor:{...state.cursor,x:0}});
-   refs.push(new WeakRef(state.history[0]));
-  }
- }else{
-  refs.push(new WeakRef(state.history[1000]));
-  await patch({rows:[],historyDelta:{trim:2000,append:[]}});
- }
- return {anchor,refs,current:chain?null:state};
-}
-const result=await setup();
-for(let i=0;i<12;i++){await new Promise(r=>setImmediate(r));global.gc();}
-console.log(JSON.stringify({anchor:result.anchor.cells[0].grapheme,retained:result.refs.filter(r=>r.deref()).length,history:result.current?.history.length??null}));
-`,
-        resolveDir: process.cwd(),
-        loader: "ts",
-      },
-      bundle: true,
-      platform: "node",
-      format: "esm",
-      outfile: probe,
-    });
-  });
-  afterAll(() => {
-    if (directory) rmSync(directory, { recursive: true, force: true });
-  });
-
-  it.each(["trim", "chain"])(
-    "releases obsolete rows after %s while one old row remains alive",
-    (mode) => {
-      const result = JSON.parse(
-        execFileSync(process.execPath, ["--expose-gc", probe, mode], {
-          encoding: "utf8",
-          timeout: 15_000,
-        }),
-      );
-      expect(result).toEqual({ anchor: "A", retained: 0, history: mode === "trim" ? 0 : null });
-    },
-  );
-});

package/packages/core/src/terminal-delivery-encode-cooperative.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  encodeCompactSemanticTerminalUpdate,
-  encodeCompactSemanticTerminalUpdateCooperatively,
-  terminalSemanticUpdateNeedsCooperativeEncoding,
-  TerminalDeliveryStateTooLargeError,
-} from "./terminal-delivery.ts";
-import { blankTerminalReplicaSnapshot } from "./terminal-replica.ts";
-import type { TerminalSemanticDeliveryPayload } from "@tmux-ide/contracts";
-function seed(cols = 128, rows = 64) {
-  return {
-    frame: "seed" as const,
-    revision: 2,
-    snapshot: structuredClone(blankTerminalReplicaSnapshot(cols, rows)),
-  };
-}
-const yielding = { yieldControl: async () => {} };
-describe("cooperative compact seed encoding", () => {
-  it("emits byte-identical dense style, Unicode, wide and history representations", async () => {
-    const input = seed();
-    for (let y = 0; y < input.snapshot.grid.length; y++) {
-      const row = input.snapshot.grid[y]!;
-      row.wrapped = y % 2 === 0;
-      for (let x = 0; x < row.cells.length; x++)
-        row.cells[x] = {
-          ...row.cells[x]!,
-          grapheme: x % 3 === 0 ? '界é🙂\\"\n' : String(x % 10),
-          foreground: { kind: "rgb", value: 0x124578 + x },
-          background: { kind: "indexed", index: y },
-          attributes: x % 256,
-        };
-      row.cells[0]!.width = 2;
-      row.cells[1]!.width = 0;
-    }
-    input.snapshot.history = input.snapshot.grid.slice(0, 3);
-    input.snapshot.placements = [
-      {
-        id: "widget",
-        kind: "plot",
-        row: 0,
-        column: 0,
-        rows: 1,
-        columns: 1,
-        contentDigest: "digest",
-      },
-    ];
-    expect(await encodeCompactSemanticTerminalUpdateCooperatively(input, yielding)).toEqual(
-      encodeCompactSemanticTerminalUpdate(input),
-    );
-  });
-  it("joins runs across validation slices and retains exact key order", async () => {
-    const input = seed(4096, 2);
-    expect(await encodeCompactSemanticTerminalUpdateCooperatively(input, yielding)).toEqual(
-      encodeCompactSemanticTerminalUpdate(input),
-    );
-  });
-  it.each(["envelope", "snapshot", "row", "width", "attributes", "color", "cursor", "placement"])(
-    "rejects malformed %s with the strict schema",
-    async (kind) => {
-      const input = seed();
-      if (kind === "envelope") Object.assign(input, { unknown: true });
-      if (kind === "snapshot") Object.assign(input.snapshot, { unknown: true });
-      if (kind === "row") Object.assign(input.snapshot.grid[0]!, { unknown: true });
-      if (kind === "width") Object.assign(input.snapshot.grid[0]!.cells[0]!, { width: 3 });
-      if (kind === "attributes") input.snapshot.grid[0]!.cells[0]!.attributes = 256;
-      if (kind === "color")
-        Object.assign(input.snapshot.grid[0]!.cells[0]!, {
-          foreground: { kind: "indexed", index: 256 },
-        });
-      if (kind === "cursor") input.snapshot.cursor.x = -1;
-      if (kind === "placement")
-        input.snapshot.placements = [
-          { id: "", kind: "x", row: 0, column: 0, rows: 1, columns: 1, contentDigest: "x" },
-        ];
-      expect(() => encodeCompactSemanticTerminalUpdate(input)).toThrow();
-      await expect(
-        encodeCompactSemanticTerminalUpdateCooperatively(input, yielding),
-      ).rejects.toThrow();
-    },
-  );
-  it("checks aggregate row/cell and representation limits", async () => {
-    const rows = seed();
-    rows.snapshot.history = Array.from({ length: 10001 }, () => rows.snapshot.grid[0]!);
-    await expect(
-      encodeCompactSemanticTerminalUpdateCooperatively(rows, yielding),
-    ).rejects.toBeInstanceOf(TerminalDeliveryStateTooLargeError);
-    const bytes = seed();
-    for (const row of bytes.snapshot.grid)
-      for (let i = 0; i < row.cells.length; i++)
-        row.cells[i]!.grapheme = (i % 2 ? "a" : "b").repeat(4096);
-    expect(() => encodeCompactSemanticTerminalUpdate(bytes)).toThrow(
-      TerminalDeliveryStateTooLargeError,
-    );
-    await expect(
-      encodeCompactSemanticTerminalUpdateCooperatively(bytes, yielding),
-    ).rejects.toBeInstanceOf(TerminalDeliveryStateTooLargeError);
-  });
-  it("yields during validation before reading a whole seed and aborts without bytes", async () => {
-    const input = seed();
-    let reads = 0;
-    for (const row of input.snapshot.grid)
-      for (const cell of row.cells)
-        Object.defineProperty(cell, "grapheme", {
-          enumerable: true,
-          get: () => {
-            reads++;
-            return "";
-          },
-        });
-    const controller = new AbortController(),
-      reason = new Error("client retired");
-    await expect(
-      encodeCompactSemanticTerminalUpdateCooperatively(input, {
-        signal: controller.signal,
-        yieldControl: async () => {
-          expect(reads).toBe(256);
-          controller.abort(reason);
-        },
-      }),
-    ).rejects.toBe(reason);
-    expect(reads).toBe(256);
-  });
-  it("keeps small updates on ordinary encoding with no task yield", async () => {
-    let yields = 0;
-    for (const input of [
-      seed(4, 2),
-      { frame: "patch", baseRevision: 0, revision: 1, patch: { rows: [] } },
-    ] satisfies TerminalSemanticDeliveryPayload[]) {
-      expect(terminalSemanticUpdateNeedsCooperativeEncoding(input)).toBe(false);
-      expect(
-        await encodeCompactSemanticTerminalUpdateCooperatively(input, {
-          yieldControl: async () => {
-            yields++;
-          },
-        }),
-      ).toEqual(encodeCompactSemanticTerminalUpdate(input));
-    }
-    expect(yields).toBe(0);
-  });
-});

package/packages/core/src/terminal-delivery-representation-hash.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  hashTerminalDeliveryRepresentation,
-  splitTerminalDeliveryChunks,
-  TerminalDeliveryAssembler,
-} from "./terminal-delivery.ts";
-import type { TerminalDeliveryEnvelope } from "@tmux-ide/contracts";
-
-// Independent integer arithmetic oracle for the existing two-lane wire digest.
-function referenceHash(bytes: Uint8Array): string {
-  let high = 0x811c9dc5n;
-  let low = 0x9e3779b9n;
-  for (const byte of bytes) {
-    high = ((high ^ BigInt(byte)) * 0x01000193n) & 0xffffffffn;
-    low = ((low ^ BigInt(byte)) * 0x85ebca6bn) & 0xffffffffn;
-  }
-  return high.toString(16).padStart(8, "0") + low.toString(16).padStart(8, "0");
-}
-function slicedBytes(length: number): Uint8Array {
-  const backing = Uint8Array.from({ length: length + 19 }, (_, index) => (index * 131 + 17) % 256);
-  return backing.subarray(7, length + 7);
-}
-function envelope(bytes: Uint8Array, hash: string): TerminalDeliveryEnvelope {
-  return {
-    type: "terminal.delivery",
-    workspaceName: "hash-parity",
-    semanticPaneId: "pane-a",
-    generation: "00000000-0000-4000-8000-000000000001",
-    incarnation: "00000000-0000-4000-8000-000000000001:0",
-    deliveryNonce: "00000000-0000-4000-8000-000000000002",
-    transactionId: "00000000-0000-4000-8000-000000000003",
-    protocolVersion: 1,
-    encoding: "semantic-v1",
-    frame: "seed",
-    baseRevision: null,
-    canonicalRevision: 0,
-    canonicalStateHash: "0000000000000000",
-    representationHash: hash,
-    representationBytes: bytes.byteLength,
-    chunkCount: Math.ceil(bytes.byteLength / (256 * 1024)),
-    canonicalEquivalent: true,
-    history: "complete",
-    richPlacements: false,
-  };
-}
-
-describe("terminal delivery wire hash parity", () => {
-  it("preserves unsigned lane arithmetic for empty, sliced and chunk-boundary bytes", () => {
-    expect(hashTerminalDeliveryRepresentation(new Uint8Array())).toBe("811c9dc59e3779b9");
-    for (const length of [1, 255, 256, 65_537, 262_143, 262_144, 262_145]) {
-      const bytes = slicedBytes(length);
-      expect(bytes.byteOffset).toBe(7);
-      expect(hashTerminalDeliveryRepresentation(bytes)).toBe(referenceHash(bytes));
-    }
-  });
-
-  it("preserves incremental assembly across full and partial chunks and refuses corruption", () => {
-    const bytes = slicedBytes(2 * 256 * 1024 + 17);
-    const expected = referenceHash(bytes);
-    const metadata = envelope(bytes, expected);
-    const chunks = splitTerminalDeliveryChunks(metadata.transactionId, bytes);
-    expect(chunks.map((chunk) => chunk.bytes.length)).toEqual([262_144, 262_144, 17]);
-    const valid = new TerminalDeliveryAssembler(metadata);
-    for (const chunk of chunks) valid.write(chunk);
-    expect(valid.complete()).toEqual(bytes);
-    expect(hashTerminalDeliveryRepresentation(valid.complete())).toBe(expected);
-
-    const corrupt = new TerminalDeliveryAssembler(metadata);
-    for (const chunk of chunks) {
-      const changed = new Uint8Array(chunk.bytes.length + 9).subarray(9);
-      changed.set(chunk.bytes);
-      if (chunk.index === 1) changed[changed.length - 1]! ^= 1;
-      corrupt.write({ ...chunk, bytes: changed });
-    }
-    expect(() => corrupt.complete()).toThrow("representation hash mismatch");
-  });
-});