tmux-ide 2.9.2 → 2.9.4

package/packages/core/src/optimistic-projection-conformance.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  runOptimisticProjectionConformance,
-  type OptimisticConformanceFixture,
-} from "./optimistic-projection-conformance.ts";
-
-interface Intent {
-  readonly client: "react" | "opentui" | "sdk";
-  readonly delta: number;
-}
-const options = {
-  predict: (value: number, intent: Intent) => value + intent.delta,
-  terminalHistoryLimit: 8,
-};
-const fixture: OptimisticConformanceFixture<number, Intent> = {
-  name: "ordered-interleaving-receipts-and-generation",
-  committed: { generation: "daemon-a", revision: 7, value: 10 },
-  commands: [
-    {
-      type: "enqueue",
-      operationId: "react-1",
-      intent: { client: "react", delta: 2 },
-      acceptedAtMs: 1,
-      deadlineAtMs: 100,
-    },
-    {
-      type: "enqueue",
-      operationId: "tui-1",
-      intent: { client: "opentui", delta: 3 },
-      acceptedAtMs: 2,
-      deadlineAtMs: 100,
-    },
-    {
-      type: "enqueue",
-      operationId: "sdk-1",
-      intent: { client: "sdk", delta: -1 },
-      acceptedAtMs: 3,
-      deadlineAtMs: 100,
-    },
-    { type: "receipt", operationId: "tui-1", phase: "observed" },
-    { type: "receipt", operationId: "tui-1", phase: "rejected" },
-    {
-      type: "replace",
-      committed: { generation: "daemon-b", revision: 0, value: 12 },
-      observedOperationIds: ["react-1"],
-      nowMs: 10,
-    },
-    { type: "receipt", operationId: "sdk-1", phase: "observed" },
-    { type: "receipt", operationId: "react-1", phase: "observed" },
-  ],
-};
-describe("React/OpenTUI/SDK optimistic projection conformance", () => {
-  it("produces identical ordered observations for each adapter label", () => {
-    const traces = (["react", "opentui", "sdk"] as const).map(() =>
-      runOptimisticProjectionConformance(fixture, options),
-    );
-    expect(traces[1]).toEqual(traces[0]);
-    expect(traces[2]).toEqual(traces[0]);
-    expect(traces[0]).toContainEqual(
-      expect.objectContaining({ derived: 14, pending: ["react-1", "tui-1", "sdk-1"] }),
-    );
-    expect(traces[0]).toContainEqual(
-      expect.objectContaining({
-        generation: "daemon-b",
-        revision: 0,
-        derived: 11,
-        pending: ["sdk-1"],
-      }),
-    );
-    expect(traces[0]!.at(-1)).toEqual(expect.objectContaining({ derived: 12, pending: [] }));
-  });
-  it("does not republish duplicate or reordered terminal receipts", () => {
-    expect(runOptimisticProjectionConformance(fixture, options)).toHaveLength(7);
-  });
-});

package/packages/core/src/optimistic-projection.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  createOptimisticProjection,
-  deriveOptimisticProjection,
-  enqueueOptimisticOperation,
-  expireOptimisticOperations,
-  reconcileOptimisticOperation,
-  replaceCommittedProjection,
-} from "./optimistic-projection.ts";
-
-interface CounterIntent {
-  readonly client: string;
-  readonly delta: number;
-}
-
-const options = {
-  predict: (value: number, intent: CounterIntent) => value + intent.delta,
-  terminalHistoryLimit: 4,
-};
-
-function enqueue(
-  state: ReturnType<typeof createOptimisticProjection<number, CounterIntent>>,
-  operationId: string,
-  client: string,
-  delta: number,
-) {
-  return enqueueOptimisticOperation(state, {
-    operationId,
-    intent: { client, delta },
-    acceptedAtMs: 10,
-    deadlineAtMs: 1_000,
-  });
-}
-
-describe("committed/pending/derived projection", () => {
-  it("applies interleaved client predictions in admission order", () => {
-    let state = createOptimisticProjection<number, CounterIntent>({
-      generation: "daemon-a",
-      revision: 1,
-      value: 10,
-    });
-    state = enqueue(state, "web-1", "web", 2);
-    state = enqueue(state, "tui-1", "tui", 3);
-    state = enqueue(state, "sdk-1", "sdk", -1);
-    expect(deriveOptimisticProjection(state, options)).toBe(14);
-    expect(state.pending.map(({ operationId }) => operationId)).toEqual([
-      "web-1",
-      "tui-1",
-      "sdk-1",
-    ]);
-  });
-
-  it("settles duplicate and reordered terminal receipts exactly once", () => {
-    let state = createOptimisticProjection<number, CounterIntent>({
-      generation: "daemon-a",
-      revision: 1,
-      value: 0,
-    });
-    state = enqueue(state, "web-1", "web", 4);
-    state = enqueue(state, "tui-1", "tui", 5);
-    state = reconcileOptimisticOperation(state, "tui-1", "observed", options);
-    const settled = state;
-    state = reconcileOptimisticOperation(state, "tui-1", "rejected", options);
-    expect(state).toBe(settled);
-    expect(deriveOptimisticProjection(state, options)).toBe(4);
-
-    const terminalFirst = reconcileOptimisticOperation(
-      createOptimisticProjection<number, CounterIntent>({
-        generation: "daemon-a",
-        revision: 1,
-        value: 0,
-      }),
-      "late-admission",
-      "observed",
-      options,
-    );
-    expect(enqueue(terminalFirst, "late-admission", "sdk", 10)).toBe(terminalFirst);
-  });
-
-  it("retains safe pending intent across generations until observed or expired", () => {
-    let state = createOptimisticProjection<number, CounterIntent>({
-      generation: "daemon-a",
-      revision: 8,
-      value: 10,
-    });
-    state = enqueue(state, "web-1", "web", 2);
-    state = enqueue(state, "tui-1", "tui", 3);
-    state = replaceCommittedProjection(
-      state,
-      { generation: "daemon-b", revision: 0, value: 12 },
-      { observedOperationIds: ["web-1"], nowMs: 20 },
-    );
-    expect(state.pending.map(({ operationId }) => operationId)).toEqual(["tui-1"]);
-    expect(deriveOptimisticProjection(state, options)).toBe(15);
-    expect(enqueue(state, "web-1", "web", 99)).toBe(state);
-    state = expireOptimisticOperations(state, 1_000, options);
-    expect(state.pending).toEqual([]);
-    expect(deriveOptimisticProjection(state, options)).toBe(12);
-  });
-
-  it("rejects stale same-generation commits and duplicate operation admission", () => {
-    let state = createOptimisticProjection<number, CounterIntent>({
-      generation: "daemon-a",
-      revision: 5,
-      value: 10,
-    });
-    state = enqueue(state, "same", "web", 1);
-    expect(enqueue(state, "same", "web", 99)).toBe(state);
-    expect(
-      replaceCommittedProjection(
-        state,
-        { generation: "daemon-a", revision: 4, value: 999 },
-        { nowMs: 20 },
-      ),
-    ).toBe(state);
-  });
-});

package/packages/core/src/performance-metrics.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { LocalPerformanceAggregator } from "./performance-metrics.ts";
-
-const authority = {
-  daemonInstanceId: "00000000-0000-4000-8000-000000000001",
-  workspaceName: "workspace",
-  generation: "00000000-0000-4000-8000-000000000001",
-  incarnation: "pane-a:1",
-} as const;
-
-function aggregator(capacity = 4): LocalPerformanceAggregator {
-  return new LocalPerformanceAggregator({ source: "opentui", authority, sampleCapacity: capacity });
-}
-
-describe("LocalPerformanceAggregator", () => {
-  it("is explicitly opt-in and disabled record paths are allocation-free no-ops", () => {
-    const metrics = aggregator();
-    metrics.recordFrame(Number.NaN);
-    metrics.recordDirtyRows(-1);
-    metrics.recordParse(Number.NaN);
-    metrics.recordPaint(-1);
-    metrics.recordQueueDepth(-1, -1);
-    metrics.recordRevisionLag(-1);
-    metrics.recordReseed();
-    expect(metrics.enabled).toBe(false);
-    expect(metrics.snapshot()).toBeNull();
-    expect(metrics.disable()).toBe(false);
-  });
-
-  it("retains a fixed-capacity nearest-rank window and exact local summaries", () => {
-    const metrics = aggregator(4);
-    expect(metrics.enable()).toBe(true);
-    expect(metrics.enable()).toBe(false);
-    for (const value of [100, 2, 4, 8, 16]) metrics.recordParse(value);
-    for (const value of [1, 3, 5]) metrics.recordDirtyRows(value);
-    metrics.recordPaint(2.5);
-    metrics.recordFrame(20);
-    metrics.recordQueueDepth(3, 8);
-    metrics.recordQueueDepth(5, 12);
-    metrics.recordQueueDepth(2, 6);
-    metrics.recordRevisionLag(4);
-    metrics.recordRevisionLag(1);
-    metrics.recordReseed();
-
-    expect(metrics.snapshot()).toMatchObject({
-      source: "opentui",
-      activeFps: 50,
-      dirtyRows: { count: 3, latest: 5, p50: 3, p95: 5, max: 5 },
-      parseMs: { count: 4, latest: 16, p50: 4, p95: 16, max: 16 },
-      paintMs: { count: 1, latest: 2.5, p50: 2.5, p95: 2.5, max: 2.5 },
-      queueDepth: {
-        current: 2,
-        peak: 5,
-        capacity: { current: 6, peak: 12 },
-      },
-      revisionLag: { current: 1, peak: 4 },
-      reseeds: 1,
-    });
-  });
-
-  it("resets measurements on a new activation without reusing the sequence", () => {
-    const metrics = aggregator();
-    metrics.enable();
-    metrics.recordParse(3);
-    const before = metrics.snapshot()!;
-    expect(before.sampleSequence).toBe(1);
-    expect(metrics.disable()).toBe(true);
-    expect(metrics.snapshot()).toBeNull();
-    expect(metrics.enable()).toBe(true);
-    const reset = metrics.snapshot()!;
-    expect(reset.sampleSequence).toBe(before.sampleSequence);
-    expect(reset.parseMs.count).toBe(0);
-    expect(reset.activeFps).toBeNull();
-    expect(reset.reseeds).toBe(0);
-    metrics.recordReseed();
-    expect(metrics.snapshot()!.sampleSequence).toBeGreaterThan(before.sampleSequence);
-  });
-
-  it("advances sequence only for admitted events, never for snapshot reads", () => {
-    const metrics = aggregator();
-    metrics.enable();
-    expect(metrics.snapshot()!.sampleSequence).toBe(0);
-    expect(metrics.snapshot()!.sampleSequence).toBe(0);
-    metrics.recordFrame(10);
-    metrics.recordDirtyRows(1);
-    metrics.recordParse(1);
-    metrics.recordPaint(1);
-    metrics.recordQueueDepth(0, 4);
-    metrics.recordRevisionLag(0);
-    metrics.recordReseed();
-    expect(metrics.snapshot()!.sampleSequence).toBe(7);
-    expect(metrics.snapshot()!.sampleSequence).toBe(7);
-  });
-
-  it("preserves unavailable capacities and revision lag instead of inventing zero", () => {
-    const metrics = aggregator();
-    metrics.enable();
-    expect(metrics.snapshot()).toMatchObject({
-      queueDepth: { capacity: { current: null, peak: null } },
-      revisionLag: { current: null, peak: null },
-    });
-    metrics.recordQueueDepth(4);
-    metrics.recordQueueDepth(1, 8);
-    expect(metrics.snapshot()).toMatchObject({
-      queueDepth: { current: 1, peak: 4, capacity: { current: 8, peak: null } },
-    });
-  });
-
-  it("validates enabled observations without timing or I/O of its own", () => {
-    const metrics = aggregator();
-    metrics.enable();
-    expect(() => metrics.recordFrame(0)).toThrow(/positive/u);
-    expect(() => metrics.recordFrame(Number.MIN_VALUE)).toThrow(/finite frame rate/u);
-    expect(() => metrics.recordDirtyRows(1.5)).toThrow(/integer/u);
-    expect(() => metrics.recordParse(Number.NaN)).toThrow(/finite/u);
-    expect(() => metrics.recordPaint(-1)).toThrow(/non-negative/u);
-    expect(() => metrics.recordQueueDepth(2, 1)).toThrow(/capacity/u);
-    expect(() => metrics.recordRevisionLag(-1)).toThrow(/non-negative/u);
-  });
-});

package/packages/core/src/performance-qualification.test.ts

@@ -1,283 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  PERFORMANCE_STAGE_ORDER,
-  type ClientConvergenceObservationV1,
-  type MutationQualificationAcceptanceV1,
-  type MutationTerminalOutcomeV1,
-  type PerformanceTraceV1,
-} from "@tmux-ide/contracts";
-
-import {
-  createStateConvergenceIdentity,
-  deterministicPercentile,
-  evaluateMutationOutcomes,
-  evaluatePerformanceBudget,
-  evaluateQueueBounds,
-  evaluateQueuePlateau,
-  evaluateSlowClientIsolation,
-  evaluateStateConvergence,
-} from "./performance-qualification.ts";
-import { blankTerminalReplicaSnapshot, hashTerminalReplicaSnapshot } from "./terminal-replica.ts";
-
-const generation = "00000000-0000-4000-8000-000000000001";
-
-function trace(index: number, durationMicros: number): PerformanceTraceV1 {
-  return {
-    version: 1,
-    traceId: `00000000-0000-4000-8000-${String(index).padStart(12, "0")}`,
-    scenario: "leading-edge-input",
-    stages: PERFORMANCE_STAGE_ORDER.map((stage, stageIndex) => {
-      const local = stage === "input" || stage === "paint";
-      const startedAtMicros =
-        stage === "input"
-          ? 1_000_000
-          : stage === "paint"
-            ? 1_000_000 + durationMicros - 100
-            : stageIndex * 10_000;
-      return {
-        version: 1,
-        stage,
-        processId: local ? "web-a" : "daemon-a",
-        clockId: local ? "browser" : "node",
-        clockKind: local ? "performance-now" : "hrtime",
-        startedAtMicros,
-        endedAtMicros: startedAtMicros + (local ? 100 : stageIndex + 1_000),
-      };
-    }),
-    localInputToPaint: {
-      version: 1,
-      processId: "web-a",
-      clockId: "browser",
-      clockKind: "performance-now",
-      startedAtMicros: 1_000_000,
-      endedAtMicros: 1_000_000 + durationMicros,
-    },
-  };
-}
-
-describe("performance qualification", () => {
-  it("uses deterministic nearest-rank percentiles and the exact 60 Hz budget", () => {
-    const values = Array.from({ length: 20 }, (_, index) => index + 1);
-    expect(deterministicPercentile(values, 0.95)).toBe(19);
-    expect(deterministicPercentile([...values].reverse(), 0.95)).toBe(19);
-    expect(() => deterministicPercentile([1, Number.NaN], 0.95)).toThrow(/finite/u);
-
-    const atBudget = evaluatePerformanceBudget(
-      Array.from({ length: 20 }, (_, index) => trace(index + 1, index === 19 ? 30_000 : 16_670)),
-    );
-    expect(atBudget.inputToPaint.p95Ms).toBe(16.67);
-    expect(atBudget.passed).toBe(true);
-    expect(evaluatePerformanceBudget([trace(99, 16_669)]).passed).toBe(true);
-    const overBudget = evaluatePerformanceBudget(
-      Array.from({ length: 20 }, (_, index) => trace(index + 21, index < 19 ? 16_671 : 30_000)),
-    );
-    expect(overBudget.passed).toBe(false);
-  });
-
-  it("summarizes each stage from local spans and is input-order invariant", () => {
-    const base = trace(1, 8_000);
-    const crossClock: PerformanceTraceV1 = {
-      ...base,
-      stages: base.stages.map((span, index) =>
-        index === 1
-          ? { ...span, startedAtMicros: 9_000_000_000, endedAtMicros: 9_000_001_000 }
-          : span,
-      ),
-    };
-    const forward = [crossClock, trace(2, 12_000), trace(3, 10_000)];
-    expect(evaluatePerformanceBudget(forward)).toEqual(
-      evaluatePerformanceBudget([...forward].reverse()),
-    );
-    expect(evaluatePerformanceBudget(forward).stages.tmux.p95Ms).toBe(1.001);
-    expect(evaluatePerformanceBudget(forward).stages.paint.p95Ms).toBe(0.1);
-  });
-
-  it("preserves the canonical terminal hash and converges 2/4/8 clients", () => {
-    const snapshot = blankTerminalReplicaSnapshot(4, 2);
-    const canonicalStateHash = hashTerminalReplicaSnapshot(snapshot);
-    const expected = createStateConvergenceIdentity(generation, "pane-a:1", 42, canonicalStateHash);
-    expect(expected.stateHash).toBe(canonicalStateHash);
-    expect(expected.hashAlgorithm).toBe("fnv1a64-v1");
-    expect(() =>
-      createStateConvergenceIdentity(generation, "pane-a:1", 42, "not-a-hash"),
-    ).toThrow();
-    for (const count of [2, 4, 8]) {
-      const observations: ClientConvergenceObservationV1[] = Array.from(
-        { length: count },
-        (_, index) => ({
-          version: 1,
-          clientId: `client-${index}`,
-          disposition: "healthy",
-          identity: expected,
-        }),
-      );
-      const result = evaluateStateConvergence(expected, observations.reverse());
-      expect(result.converged).toBe(true);
-      expect(result.matchingClientIds).toEqual(
-        Array.from({ length: count }, (_, index) => `client-${index}`).sort(),
-      );
-    }
-
-    const divergent = createStateConvergenceIdentity(
-      generation,
-      "pane-a:1",
-      43,
-      hashTerminalReplicaSnapshot(blankTerminalReplicaSnapshot(5, 2)),
-    );
-    expect(
-      evaluateStateConvergence(expected, [
-        { version: 1, clientId: "slow", disposition: "slow", identity: divergent },
-        { version: 1, clientId: "healthy", disposition: "healthy", identity: expected },
-      ]),
-    ).toMatchObject({ converged: true, excludedClientIds: ["slow"] });
-    const newerIncarnation = createStateConvergenceIdentity(
-      generation,
-      "pane-a:2",
-      42,
-      canonicalStateHash,
-    );
-    expect(
-      evaluateStateConvergence(expected, [
-        { version: 1, clientId: "healthy", disposition: "healthy", identity: newerIncarnation },
-      ]),
-    ).toMatchObject({ converged: false, divergentClientIds: ["healthy"] });
-  });
-
-  it("qualifies bounded slow-client queues and healthy-client p95 isolation", () => {
-    expect(
-      evaluateQueueBounds([
-        {
-          version: 1,
-          clientId: "slow",
-          disposition: "slow",
-          queue: "terminal",
-          sampleOrdinal: 0,
-          depthItems: 32,
-          capacityItems: 32,
-          bytes: 4_096,
-          capacityBytes: 4_096,
-          coalesced: 100,
-          dropped: 2,
-        },
-      ]),
-    ).toEqual({ bounded: true, maxDepthItems: 32, maxBytes: 4096, coalesced: 100, dropped: 2 });
-
-    const baseline = [trace(1, 10_000), trace(2, 11_000)];
-    expect(
-      evaluateSlowClientIsolation(baseline, [trace(3, 10_500), trace(4, 11_500)], 0.5),
-    ).toEqual({
-      passed: true,
-      baselineP95Ms: 11,
-      contendedP95Ms: 11.5,
-      regressionMs: 0.5,
-      allowedRegressionMs: 0.5,
-    });
-
-    const queueSample = (sampleOrdinal: number, depthItems: number, bytes: number) => ({
-      version: 1 as const,
-      clientId: "slow",
-      disposition: "slow" as const,
-      queue: "terminal" as const,
-      sampleOrdinal,
-      depthItems,
-      capacityItems: 32,
-      bytes,
-      capacityBytes: 4_096,
-      coalesced: 0,
-      dropped: 0,
-    });
-    expect(
-      evaluateQueuePlateau([
-        queueSample(0, 8, 1_024),
-        queueSample(1, 8, 1_024),
-        queueSample(2, 8, 1_024),
-        queueSample(3, 8, 1_024),
-      ]),
-    ).toMatchObject({ plateaued: true, itemSlopePerSample: 0, byteSlopePerSample: 0 });
-    expect(
-      evaluateQueuePlateau([
-        queueSample(0, 1, 100),
-        queueSample(1, 2, 200),
-        queueSample(2, 3, 300),
-        queueSample(3, 4, 400),
-      ]),
-    ).toMatchObject({ plateaued: false, itemSlopePerSample: 1, byteSlopePerSample: 100 });
-    expect(() =>
-      evaluateQueuePlateau([
-        queueSample(0, 1, 100),
-        queueSample(1, 2, 200),
-        queueSample(1, 3, 300),
-        queueSample(3, 4, 400),
-      ]),
-    ).toThrow(/ordinals must increase/u);
-  });
-
-  it("rejects mutation limbo, duplicate terminals and unknown outcomes", () => {
-    const accepted = (index: number): MutationQualificationAcceptanceV1 => ({
-      version: 1,
-      mutationId: `10000000-0000-4000-8000-${String(index).padStart(12, "0")}`,
-      processId: "daemon-a",
-      clockId: "node-hrtime",
-      clockKind: "hrtime",
-      acceptedAtMicros: index * 100,
-      deadlineAtMicros: index * 100 + 1_000,
-    });
-    const outcome = (
-      acceptance: MutationQualificationAcceptanceV1,
-      status: "observed" | "rejected" | "timed-out",
-    ): MutationTerminalOutcomeV1 => ({
-      version: 1,
-      mutationId: acceptance.mutationId,
-      processId: acceptance.processId,
-      clockId: acceptance.clockId,
-      clockKind: acceptance.clockKind,
-      occurredAtMicros:
-        status === "timed-out" ? acceptance.deadlineAtMicros : acceptance.acceptedAtMicros + 1,
-      status,
-      ...(status === "observed"
-        ? {
-            identity: createStateConvergenceIdentity(
-              generation,
-              "pane-a:1",
-              1,
-              hashTerminalReplicaSnapshot(blankTerminalReplicaSnapshot(1, 1)),
-            ),
-          }
-        : { reason: status }),
-    });
-    const a = accepted(1);
-    const b = accepted(2);
-    expect(evaluateMutationOutcomes([a, b], [outcome(a, "observed")])).toMatchObject({
-      complete: false,
-      limboMutationIds: [b.mutationId],
-    });
-    expect(
-      evaluateMutationOutcomes([a, b], [outcome(a, "observed"), outcome(b, "timed-out")]),
-    ).toMatchObject({ complete: true, terminalCount: 2 });
-    expect(
-      evaluateMutationOutcomes([a], [outcome(a, "rejected"), outcome(a, "timed-out")]),
-    ).toMatchObject({ complete: false, duplicateMutationIds: [a.mutationId] });
-    const unknown = accepted(3);
-    expect(evaluateMutationOutcomes([a], [outcome(unknown, "rejected")])).toMatchObject({
-      complete: false,
-      limboMutationIds: [a.mutationId],
-      unknownMutationIds: [unknown.mutationId],
-    });
-    expect(
-      evaluateMutationOutcomes(
-        [a],
-        [{ ...outcome(a, "observed"), occurredAtMicros: a.deadlineAtMicros + 1 }],
-      ),
-    ).toMatchObject({ complete: false, lateMutationIds: [a.mutationId] });
-    expect(
-      evaluateMutationOutcomes([a], [{ ...outcome(a, "rejected"), clockId: "other-clock" }]),
-    ).toMatchObject({ complete: false, clockDomainMismatchMutationIds: [a.mutationId] });
-    expect(
-      evaluateMutationOutcomes(
-        [a],
-        [{ ...outcome(a, "timed-out"), occurredAtMicros: a.deadlineAtMicros - 1 }],
-      ),
-    ).toMatchObject({ complete: false, prematureTimeoutMutationIds: [a.mutationId] });
-  });
-});

package/packages/core/src/saved-machines.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SavedMachineRegistrySchema } from "@tmux-ide/contracts";
-import { changeSavedMachines, machineResourceKey } from "./saved-machines.ts";
-const id = "a1ea9939-7496-4a45-bae2-7e611aecc011";
-const other = "a1ea9939-7496-4a45-bae2-7e611aecc012";
-const machine = { id, label: "Build host", sshTarget: "dev@build", enabled: true };
-const initial = { version: 1 as const, machines: [machine] };
-describe("saved machine identity", () => {
-  it("preserves identity through edits and leaves the original immutable", () => {
-    const result = changeSavedMachines(initial, {
-      type: "update",
-      id,
-      patch: { label: "New name", enabled: false },
-    });
-    expect(result.machines[0]).toEqual({ ...machine, label: "New name", enabled: false });
-    expect(initial.machines[0]).toEqual(machine);
-    expect(changeSavedMachines(result, { type: "remove", id }).machines).toEqual([]);
-    expect(() => changeSavedMachines(result, { type: "remove", id: other })).toThrow("not found");
-  });
-  it("rejects collisions, reserved Local labels, credentials, unknown versions and excess records", () => {
-    for (const extra of [
-      { ...machine },
-      { ...machine, id: other, label: "BUILD HOST" },
-      { ...machine, id: other, label: "Local" },
-    ]) {
-      expect(() => changeSavedMachines(initial, { type: "add", machine: extra })).toThrow();
-    }
-    expect(() => SavedMachineRegistrySchema.parse({ ...initial, version: 2 })).toThrow();
-    expect(() =>
-      SavedMachineRegistrySchema.parse({
-        version: 1,
-        machines: Array.from({ length: 65 }, (_, index) => ({
-          ...machine,
-          id: `a1ea9939-7496-4a45-bae2-${index.toString(16).padStart(12, "0")}`,
-          label: `Host ${index}`,
-        })),
-      }),
-    ).toThrow();
-    for (const field of ["password", "privateKey", "token"]) {
-      expect(() =>
-        SavedMachineRegistrySchema.parse({
-          ...initial,
-          machines: [{ ...machine, [field]: "secret" }],
-        }),
-      ).toThrow();
-    }
-    expect(() => changeSavedMachines(initial, { type: "remove", id: "local" })).toThrow();
-  });
-  it("accepts SSH aliases and destinations without allowing command or credential syntax", () => {
-    for (const sshTarget of ["work", "user@server.example", "user@[::1]"]) {
-      expect(
-        SavedMachineRegistrySchema.parse({ ...initial, machines: [{ ...machine, sshTarget }] })
-          .machines[0]?.sshTarget,
-      ).toBe(sshTarget);
-    }
-    for (const sshTarget of [
-      "-oProxyCommand=evil",
-      "host;cmd",
-      "host\ncmd",
-      "ssh://host",
-      "user:password@host",
-      "host command",
-      "$(command)",
-    ]) {
-      expect(() =>
-        SavedMachineRegistrySchema.parse({ ...initial, machines: [{ ...machine, sshTarget }] }),
-      ).toThrow();
-    }
-  });
-  it("namespaces identical tmux IDs across machines and resource kinds", () => {
-    const keys = [
-      machineResourceKey("local", "pane", "%1"),
-      machineResourceKey(id, "pane", "%1"),
-      machineResourceKey(other, "pane", "%1"),
-      machineResourceKey(id, "session", "%1"),
-    ];
-    expect(new Set(keys).size).toBe(4);
-    expect(machineResourceKey(id.toUpperCase(), "pane", "%1")).toBe(keys[1]);
-  });
-});