@1agh/maude 0.19.1 → 0.21.0

package/plugins/design/dev-server/test/git-lifecycle.test.ts

@@ -0,0 +1,101 @@
+// Unit: Task 7 — `.git/HEAD` watcher. We don't exercise fs.watch directly
+// (flaky across platforms in CI); instead we drive the module's public
+// surface: it gracefully no-ops when no .git/ exists, and the public stop()
+// is idempotent.
+//
+// The flush-before-broadcast invariant is verified separately by the
+// collab-bridge tests and the persistence module's contract — registry
+// already exposes flushAll(). The integration with .git/HEAD writes is
+// exercised manually in the Task 7 acceptance test (Phase 8 plan validate row).
+
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { createGitLifecycle } from '../collab/git-lifecycle.ts';
+import { createRegistry } from '../collab/registry.ts';
+import type { RoomCallbacks } from '../collab/room.ts';
+import { type Context, createBus } from '../context.ts';
+
+function ctxFor(repoRoot: string): Context {
+  return {
+    cfg: {} as Context['cfg'],
+    projectLabel: 'test',
+    paths: {
+      repoRoot,
+      designRel: '.design',
+      designRoot: path.join(repoRoot, '.design'),
+      serverInfoFile: '',
+      activeFile: '',
+      commentsDir: '',
+      canvasStateDir: '',
+      historyDir: '',
+      tokensUrlRel: '',
+      systemDirRel: '',
+    },
+    bus: createBus(),
+  };
+}
+
+function noopCallbacks(): RoomCallbacks {
+  return { async seed() {}, async persistJson() {}, async persistBinary() {} };
+}
+
+describe('git-lifecycle', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(path.join(tmpdir(), 'maude-git-lifecycle-'));
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tmp, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  test('no .git/ directory → silent no-op (still returns a stop function)', () => {
+    const ctx = ctxFor(tmp);
+    const registry = createRegistry(noopCallbacks());
+    expect(existsSync(path.join(tmp, '.git'))).toBe(false);
+    const gl = createGitLifecycle(ctx, registry);
+    expect(typeof gl.stop).toBe('function');
+    gl.stop(); // idempotent
+    gl.stop();
+  });
+
+  test('with .git/HEAD present → watcher attaches without throwing', () => {
+    mkdirSync(path.join(tmp, '.git'), { recursive: true });
+    writeFileSync(path.join(tmp, '.git', 'HEAD'), 'ref: refs/heads/main\n');
+    const ctx = ctxFor(tmp);
+    const registry = createRegistry(noopCallbacks());
+    const gl = createGitLifecycle(ctx, registry);
+    expect(typeof gl.stop).toBe('function');
+    gl.stop();
+  });
+
+  test('emits git-lifecycle bus event on HEAD change (manual rewrite)', async () => {
+    mkdirSync(path.join(tmp, '.git'), { recursive: true });
+    writeFileSync(path.join(tmp, '.git', 'HEAD'), 'ref: refs/heads/main\n');
+    const ctx = ctxFor(tmp);
+    const registry = createRegistry(noopCallbacks());
+    const events: unknown[] = [];
+    ctx.bus.on('git-lifecycle', (e) => events.push(e));
+    const gl = createGitLifecycle(ctx, registry);
+
+    // Rewrite HEAD; the watcher fires + 250 ms debounce + flush. Wait > 500 ms
+    // to be safe with fs.watch + flushAll latency on macOS + Linux.
+    writeFileSync(path.join(tmp, '.git', 'HEAD'), 'ref: refs/heads/other\n');
+    await Bun.sleep(700);
+
+    expect(events.length).toBeGreaterThanOrEqual(1);
+    const evt = events[0] as { reason?: string; head?: string };
+    expect(evt.reason).toBe('head-changed');
+    expect(evt.head).toContain('refs/heads/other');
+    gl.stop();
+  });
+});

package/plugins/design/dev-server/test/input-router.test.ts

@@ -2,7 +2,14 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { type ClassifyInput, type Tool, classify, isEditableTarget } from '../input-router.tsx';
+import {
+  type ClassifyInput,
+  DRAG_THRESHOLD_PX,
+  type Tool,
+  classify,
+  crossedDragThreshold,
+  isEditableTarget,
+} from '../input-router.tsx';
 
 const base = (over: Partial<ClassifyInput>): ClassifyInput => ({
   type: 'pointermove',
@@ -314,3 +321,82 @@ describe('input-router / isEditableTarget', () => {
     expect(isEditableTarget(el)).toBe(true);
   });
 });
+
+// T25 — Drag-vs-click threshold. Centralized here so every drag-class gesture
+// (artboard drag, artboard marquee, element marquee, annotation pen/rect/etc.)
+// reads the same value. Microsoft Win32 SM_CXDRAG default + d3-drag convention.
+describe('input-router / crossedDragThreshold', () => {
+  test('constant is 4', () => {
+    expect(DRAG_THRESHOLD_PX).toBe(4);
+  });
+
+  test('no movement → false', () => {
+    expect(crossedDragThreshold(100, 200, 100, 200)).toBe(false);
+  });
+
+  test('3 px move (sub-threshold) → false', () => {
+    expect(crossedDragThreshold(0, 0, 3, 0)).toBe(false);
+    expect(crossedDragThreshold(0, 0, 2, 2)).toBe(false); // hypot ≈ 2.83
+  });
+
+  test('exactly 4 px → true (boundary inclusive)', () => {
+    expect(crossedDragThreshold(0, 0, 4, 0)).toBe(true);
+    expect(crossedDragThreshold(0, 0, 0, 4)).toBe(true);
+  });
+
+  test('5 px diagonal → true', () => {
+    // 3-4-5 right triangle: hypot = 5
+    expect(crossedDragThreshold(10, 20, 13, 24)).toBe(true);
+  });
+
+  test('negative deltas — hypot is direction-agnostic', () => {
+    expect(crossedDragThreshold(50, 50, 47, 46)).toBe(true); // hypot = 5
+    expect(crossedDragThreshold(50, 50, 48, 49)).toBe(false); // hypot ≈ 2.24
+  });
+});
+
+describe('input-router / keydown — undo + redo (Phase 20)', () => {
+  test('Cmd+Z → undo', () => {
+    expect(classify(base({ type: 'keydown', key: 'z', metaKey: true })).kind).toBe('undo');
+  });
+
+  test('Cmd+Shift+Z → redo', () => {
+    expect(classify(base({ type: 'keydown', key: 'z', metaKey: true, shiftKey: true })).kind).toBe(
+      'redo'
+    );
+  });
+
+  test('Ctrl+Z → undo (Windows / Linux mac-less)', () => {
+    expect(classify(base({ type: 'keydown', key: 'z', ctrlKey: true })).kind).toBe('undo');
+  });
+
+  test('Ctrl+Y → redo (Windows convention)', () => {
+    expect(classify(base({ type: 'keydown', key: 'y', ctrlKey: true })).kind).toBe('redo');
+  });
+
+  test('Cmd+Y → redo (mac users with Windows muscle-memory)', () => {
+    expect(classify(base({ type: 'keydown', key: 'y', metaKey: true })).kind).toBe('redo');
+  });
+
+  test('Cmd+Z inside editable → no-op (browser native text undo wins)', () => {
+    expect(
+      classify(base({ type: 'keydown', key: 'z', metaKey: true, isEditable: true })).kind
+    ).toBe('no-op');
+  });
+
+  test('Cmd+Opt+Z → no-op (Alt is reserved for browser text gestures)', () => {
+    expect(classify(base({ type: 'keydown', key: 'z', metaKey: true, altKey: true })).kind).toBe(
+      'no-op'
+    );
+  });
+
+  test('bare Z → no-op (Z is not a tool letter; needs Cmd)', () => {
+    expect(classify(base({ type: 'keydown', key: 'z' })).kind).toBe('no-op');
+  });
+
+  test('Cmd+Shift+Y → no-op (only Cmd+Y; we do not over-claim)', () => {
+    expect(classify(base({ type: 'keydown', key: 'y', metaKey: true, shiftKey: true })).kind).toBe(
+      'no-op'
+    );
+  });
+});

package/plugins/design/dev-server/test/marquee-overlay.test.ts

@@ -0,0 +1,94 @@
+// marquee-overlay — T26 (Wave 3). Aseprite-vocabulary modifier semantics
+// table tests + applyMarqueeMode set-algebra tests. Pure functions, no DOM.
+
+import { describe, expect, test } from 'bun:test';
+
+import { applyMarqueeMode, modeOf } from '../marquee-overlay.tsx';
+import type { Selection } from '../use-selection-set.tsx';
+
+describe('marquee-overlay / modeOf', () => {
+  test('no modifiers → replace', () => {
+    expect(modeOf({ shiftKey: false, altKey: false })).toBe('replace');
+  });
+  test('shift → add', () => {
+    expect(modeOf({ shiftKey: true, altKey: false })).toBe('add');
+  });
+  test('alt → subtract', () => {
+    expect(modeOf({ shiftKey: false, altKey: true })).toBe('subtract');
+  });
+  test('shift+alt → intersect', () => {
+    expect(modeOf({ shiftKey: true, altKey: true })).toBe('intersect');
+  });
+});
+
+describe('marquee-overlay / applyMarqueeMode', () => {
+  // Stub `selSet` that records the last call so the test can assert outcome.
+  type Recorded = { method: 'replace' | 'add'; payload: Selection[] };
+  const makeStub = () => {
+    const log: Recorded[] = [];
+    const stub = {
+      replace: (s: Selection | Selection[]) => {
+        log.push({ method: 'replace', payload: Array.isArray(s) ? s : [s] });
+      },
+      add: (s: Selection | Selection[]) => {
+        log.push({ method: 'add', payload: Array.isArray(s) ? s : [s] });
+      },
+    };
+    return { stub, log };
+  };
+
+  const sel = (id: string): Selection => ({ id, selector: `[data-cd-id="${id}"]` });
+
+  test('replace with empty hits → no-op (selection preserved)', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'replace', [sel('a')], []);
+    expect(log).toHaveLength(0);
+  });
+
+  test('replace with hits → swaps to hits', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'replace', [sel('a')], [sel('b'), sel('c')]);
+    expect(log).toEqual([{ method: 'replace', payload: [sel('b'), sel('c')] }]);
+  });
+
+  test('add with empty hits → no-op', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'add', [sel('a')], []);
+    expect(log).toHaveLength(0);
+  });
+
+  test('add with hits → adds to existing', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'add', [sel('a')], [sel('b')]);
+    expect(log).toEqual([{ method: 'add', payload: [sel('b')] }]);
+  });
+
+  test('subtract removes the hit ids from startSet', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'subtract', [sel('a'), sel('b'), sel('c')], [sel('b')]);
+    expect(log).toEqual([{ method: 'replace', payload: [sel('a'), sel('c')] }]);
+  });
+
+  test('subtract with no overlap → identity (replace with startSet)', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'subtract', [sel('a'), sel('b')], [sel('z')]);
+    expect(log).toEqual([{ method: 'replace', payload: [sel('a'), sel('b')] }]);
+  });
+
+  test('intersect keeps only ids present in both sets', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(
+      stub,
+      'intersect',
+      [sel('a'), sel('b'), sel('c')],
+      [sel('b'), sel('c'), sel('d')]
+    );
+    expect(log).toEqual([{ method: 'replace', payload: [sel('b'), sel('c')] }]);
+  });
+
+  test('intersect with empty hits → clears (empty replace)', () => {
+    const { stub, log } = makeStub();
+    applyMarqueeMode(stub, 'intersect', [sel('a'), sel('b')], []);
+    expect(log).toEqual([{ method: 'replace', payload: [] }]);
+  });
+});

package/plugins/design/dev-server/test/move-artboards-command.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, mock, test } from 'bun:test';
+
+import {
+  type ArtboardLayoutEntry,
+  createMoveArtboardsCommand,
+  diffLayoutPositions,
+} from '../commands/move-artboards-command.ts';
+
+const A: ArtboardLayoutEntry = { id: 'a', x: 0, y: 0, w: 100, h: 80 };
+const B: ArtboardLayoutEntry = { id: 'b', x: 200, y: 0, w: 100, h: 80 };
+const A2: ArtboardLayoutEntry = { id: 'a', x: 50, y: 25, w: 100, h: 80 };
+const B2: ArtboardLayoutEntry = { id: 'b', x: 260, y: 0, w: 100, h: 80 };
+
+describe('createMoveArtboardsCommand', () => {
+  test('do() patches with the AFTER snapshot', async () => {
+    const patchFn = mock(() => {});
+    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B], patchFn });
+    await cmd.do();
+    expect(patchFn).toHaveBeenCalledTimes(1);
+    const arg = patchFn.mock.calls[0]?.[0];
+    expect(arg).toEqual([A2, B]);
+  });
+
+  test('undo() patches with the BEFORE snapshot', async () => {
+    const patchFn = mock(() => {});
+    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B], patchFn });
+    await cmd.undo();
+    expect(patchFn).toHaveBeenCalledTimes(1);
+    const arg = patchFn.mock.calls[0]?.[0];
+    expect(arg).toEqual([A, B]);
+  });
+
+  test('redo idempotence — do() twice yields the same patch payload', async () => {
+    const patchFn = mock(() => {});
+    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B2], patchFn });
+    await cmd.do();
+    await cmd.do();
+    expect(patchFn).toHaveBeenCalledTimes(2);
+    expect(patchFn.mock.calls[0]?.[0]).toEqual([A2, B2]);
+    expect(patchFn.mock.calls[1]?.[0]).toEqual([A2, B2]);
+  });
+
+  test('snapshots are deep-cloned — mutating the source after construction has no effect', async () => {
+    const before: ArtboardLayoutEntry[] = [{ ...A }, { ...B }];
+    const after: ArtboardLayoutEntry[] = [{ ...A2 }, { ...B }];
+    const patchFn = mock(() => {});
+    const cmd = createMoveArtboardsCommand({ before, after, patchFn });
+    // Poison the source arrays in place.
+    // biome-ignore lint/style/noNonNullAssertion: test invariant — arrays literally constructed two lines above
+    after[0]!.x = 9999;
+    // biome-ignore lint/style/noNonNullAssertion: test invariant — arrays literally constructed two lines above
+    before[1]!.y = -777;
+    await cmd.do();
+    expect(patchFn.mock.calls[0]?.[0]).toEqual([A2, B]);
+    await cmd.undo();
+    expect(patchFn.mock.calls[1]?.[0]).toEqual([A, B]);
+  });
+
+  test('label defaults to "move N artboards" with correct count', () => {
+    const cmd = createMoveArtboardsCommand({
+      before: [A, B],
+      after: [A2, B],
+      patchFn: () => {},
+    });
+    expect(cmd.label).toBe('move 1 artboard');
+
+    const cmd2 = createMoveArtboardsCommand({
+      before: [A, B],
+      after: [A2, B2],
+      patchFn: () => {},
+    });
+    expect(cmd2.label).toBe('move 2 artboards');
+  });
+
+  test('label override (equal-spacing wraps with its own copy)', () => {
+    const cmd = createMoveArtboardsCommand({
+      before: [A, B],
+      after: [A2, B2],
+      patchFn: () => {},
+      label: 'equal-space 2 artboards',
+    });
+    expect(cmd.label).toBe('equal-space 2 artboards');
+  });
+});
+
+describe('diffLayoutPositions', () => {
+  test('identical → null (skip push)', () => {
+    expect(diffLayoutPositions([A, B], [A, B])).toBeNull();
+    expect(diffLayoutPositions([A, B], [{ ...A }, { ...B }])).toBeNull();
+  });
+
+  test('1 moved → { changed: 1 }', () => {
+    expect(diffLayoutPositions([A, B], [A2, B])).toEqual({ changed: 1 });
+  });
+
+  test('both moved → { changed: 2 }', () => {
+    expect(diffLayoutPositions([A, B], [A2, B2])).toEqual({ changed: 2 });
+  });
+
+  test('different array lengths → reports max (defensive — real flows align ids)', () => {
+    expect(diffLayoutPositions([A], [A, B])).toEqual({ changed: 2 });
+  });
+
+  test('size-only diff (no position change) → null', () => {
+    const Aresized: ArtboardLayoutEntry = { id: 'a', x: 0, y: 0, w: 200, h: 160 };
+    expect(diffLayoutPositions([A], [Aresized])).toBeNull();
+  });
+});

package/plugins/design/dev-server/test/participants-chrome.test.ts

@@ -0,0 +1,30 @@
+// Unit: pure helpers from participants-chrome.tsx.
+
+import { describe, expect, test } from 'bun:test';
+
+import { initialsFor } from '../participants-chrome.tsx';
+
+describe('initialsFor', () => {
+  test('two-word name → uppercase first letters', () => {
+    expect(initialsFor('Alice Smith')).toBe('AS');
+    expect(initialsFor('michał dovrtěl')).toBe('MD');
+  });
+
+  test('single-word name → first two letters uppercased', () => {
+    expect(initialsFor('alice')).toBe('AL');
+    expect(initialsFor('A')).toBe('A');
+  });
+
+  test('many-word name → first letter of first two words', () => {
+    expect(initialsFor('John Ronald Reuel Tolkien')).toBe('JR');
+  });
+
+  test('empty / whitespace → ?', () => {
+    expect(initialsFor('')).toBe('?');
+    expect(initialsFor('   ')).toBe('?');
+  });
+
+  test('handles extra whitespace', () => {
+    expect(initialsFor('  Alice   Smith  ')).toBe('AS');
+  });
+});

package/plugins/design/dev-server/test/undo-stack.test.ts

@@ -0,0 +1,211 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import {
+  type CommandRecord,
+  MAX_DEPTH,
+  _clearBuilderRegistry,
+  _clearStackStore,
+  canRedo,
+  canUndo,
+  createUndoStackState,
+  loadStackState,
+  peekRedo,
+  peekUndo,
+  rebuildCommand,
+  registerCommand,
+  saveStackState,
+  undoReducer,
+} from '../undo-stack.ts';
+
+afterEach(() => {
+  _clearStackStore();
+});
+
+function rec(label = 'fake', payload: unknown = null): CommandRecord {
+  return { kind: 'test', label, payload };
+}
+
+describe('undoReducer', () => {
+  test('push appends record to past and clears future', () => {
+    const a = rec('a');
+    const b = rec('b');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    expect(s.past).toEqual([a]);
+    expect(s.future).toEqual([]);
+    s = undoReducer(s, { type: 'push', record: b });
+    expect(s.past).toEqual([a, b]);
+    expect(s.future).toEqual([]);
+  });
+
+  test('double push preserves order', () => {
+    const a = rec('a');
+    const b = rec('b');
+    const c = rec('c');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    s = undoReducer(s, { type: 'push', record: b });
+    s = undoReducer(s, { type: 'push', record: c });
+    expect(s.past).toEqual([a, b, c]);
+  });
+
+  test('undo pops past top into future', () => {
+    const a = rec('a');
+    const b = rec('b');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    s = undoReducer(s, { type: 'push', record: b });
+    s = undoReducer(s, { type: 'undo' });
+    expect(s.past).toEqual([a]);
+    expect(s.future).toEqual([b]);
+    expect(peekUndo(s)).toBe(a);
+    expect(peekRedo(s)).toBe(b);
+  });
+
+  test('undo on empty is a no-op (identity)', () => {
+    const s = createUndoStackState();
+    const next = undoReducer(s, { type: 'undo' });
+    expect(next).toBe(s);
+    expect(canUndo(next)).toBe(false);
+  });
+
+  test('redo pops future top back into past', () => {
+    const a = rec('a');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    s = undoReducer(s, { type: 'undo' });
+    s = undoReducer(s, { type: 'redo' });
+    expect(s.past).toEqual([a]);
+    expect(s.future).toEqual([]);
+  });
+
+  test('redo on empty future is a no-op', () => {
+    const a = rec('a');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    const next = undoReducer(s, { type: 'redo' });
+    expect(next).toBe(s);
+    expect(canRedo(next)).toBe(false);
+  });
+
+  test('push discards future branch (canonical undo-stack semantics)', () => {
+    const a = rec('a');
+    const b = rec('b');
+    const c = rec('c');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    s = undoReducer(s, { type: 'push', record: b });
+    s = undoReducer(s, { type: 'undo' });
+    expect(s.future.length).toBe(1);
+    s = undoReducer(s, { type: 'push', record: c });
+    expect(s.past).toEqual([a, c]);
+    expect(s.future).toEqual([]);
+  });
+
+  test('depth cap drops oldest from past (ring buffer)', () => {
+    let s = createUndoStackState();
+    const records: CommandRecord[] = [];
+    for (let i = 0; i < MAX_DEPTH + 5; i++) {
+      const r = rec(`r-${i}`);
+      records.push(r);
+      s = undoReducer(s, { type: 'push', record: r });
+    }
+    expect(s.past.length).toBe(MAX_DEPTH);
+    // biome-ignore lint/style/noNonNullAssertion: records pushed sequentially above; index guaranteed in range
+    expect(s.past[0]).toBe(records[5]!);
+    // biome-ignore lint/style/noNonNullAssertion: records pushed sequentially above; index guaranteed in range
+    expect(s.past[s.past.length - 1]).toBe(records[records.length - 1]!);
+  });
+
+  test('clear resets both stacks', () => {
+    const a = rec('a');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'push', record: a });
+    s = undoReducer(s, { type: 'undo' });
+    s = undoReducer(s, { type: 'clear' });
+    expect(s.past).toEqual([]);
+    expect(s.future).toEqual([]);
+    expect(canUndo(s)).toBe(false);
+    expect(canRedo(s)).toBe(false);
+  });
+
+  test('hydrate replaces both stacks atomically', () => {
+    const a = rec('a');
+    const b = rec('b');
+    let s = createUndoStackState();
+    s = undoReducer(s, { type: 'hydrate', state: { past: [a, b], future: [a] } });
+    expect(s.past).toEqual([a, b]);
+    expect(s.future).toEqual([a]);
+  });
+});
+
+describe('command builder registry', () => {
+  test('registerCommand + rebuildCommand round-trip', () => {
+    _clearBuilderRegistry();
+    registerCommand('test', (record, sinks) => {
+      const fn = sinks.layoutPatchFn as ((layout: unknown) => void) | undefined;
+      if (!fn) return null;
+      return {
+        kind: record.kind,
+        label: record.label,
+        do() {
+          fn(record.payload);
+        },
+        undo() {
+          fn({ undone: true });
+        },
+      };
+    });
+    const record = rec('test-label', { foo: 'bar' });
+    const built = rebuildCommand(record, { layoutPatchFn: () => {} } as never);
+    expect(built).not.toBeNull();
+    expect(built?.label).toBe('test-label');
+  });
+
+  test('rebuildCommand returns null for unknown kind', () => {
+    _clearBuilderRegistry();
+    const out = rebuildCommand({ kind: 'unknown', label: '?', payload: null }, {});
+    expect(out).toBeNull();
+  });
+
+  test('rebuildCommand returns null when required sink is missing', () => {
+    _clearBuilderRegistry();
+    registerCommand('needs-sink', (_record, sinks) => {
+      if (!sinks.layoutPatchFn) return null;
+      return { kind: 'needs-sink', label: '', do() {}, undo() {} };
+    });
+    const out = rebuildCommand({ kind: 'needs-sink', label: '', payload: null }, {});
+    expect(out).toBeNull();
+  });
+});
+
+describe('cross-iframe persistence (loadStackState / saveStackState)', () => {
+  test('round-trips state under a canvas file key', () => {
+    const a = rec('a');
+    const initial = loadStackState('ui/Foo.tsx');
+    expect(initial).toEqual({ past: [], future: [] });
+    saveStackState('ui/Foo.tsx', { past: [a], future: [] });
+    expect(loadStackState('ui/Foo.tsx').past).toEqual([a]);
+  });
+
+  test('isolation across canvas files', () => {
+    saveStackState('ui/Foo.tsx', { past: [rec('foo')], future: [] });
+    saveStackState('ui/Bar.tsx', { past: [rec('bar-1'), rec('bar-2')], future: [] });
+    expect(loadStackState('ui/Foo.tsx').past.length).toBe(1);
+    expect(loadStackState('ui/Bar.tsx').past.length).toBe(2);
+    expect(loadStackState('ui/Baz.tsx').past).toEqual([]);
+  });
+
+  test('survives a "remount" simulation — load → save → reload yields same state', () => {
+    // Simulate: iframe A pushes 2 records, iframe A unmounts, iframe B
+    // mounts for the same canvas → sees both records.
+    saveStackState('ui/Persist.tsx', {
+      past: [rec('e1'), rec('e2')],
+      future: [rec('redo-me')],
+    });
+    // Pretend a remount happens — same window store, fresh load.
+    const reloaded = loadStackState('ui/Persist.tsx');
+    expect(reloaded.past.length).toBe(2);
+    expect(reloaded.future.length).toBe(1);
+  });
+});