@1agh/maude 0.19.1 → 0.20.0

package/plugins/design/dev-server/test/equal-spacing-detector.test.ts

@@ -0,0 +1,93 @@
+// equal-spacing-detector — T27 (Wave 3). Pure detector fixtures.
+
+import { describe, expect, test } from 'bun:test';
+
+import { detectEqualSpacing } from '../equal-spacing-detector.ts';
+import type { Rect } from '../use-snap-guides.tsx';
+
+const r = (x: number, y: number, w = 100, h = 60): Rect => ({ x, y, w, h });
+
+describe('detectEqualSpacing / preconditions', () => {
+  test('fewer than 3 rects → null', () => {
+    expect(detectEqualSpacing([], 'x')).toBeNull();
+    expect(detectEqualSpacing([r(0, 0)], 'x')).toBeNull();
+    expect(detectEqualSpacing([r(0, 0), r(200, 0)], 'x')).toBeNull();
+  });
+
+  test('overlapping rects → null (gap < 0)', () => {
+    // r1 spans 0..100, r2 starts at 90 (overlap by 10)
+    expect(detectEqualSpacing([r(0, 0), r(90, 0), r(220, 0)], 'x')).toBeNull();
+  });
+});
+
+describe('detectEqualSpacing / horizontal axis', () => {
+  test('3 rects, equal gap 20 → detects with gap=20 + 2 midpoints', () => {
+    // 0..100, 120..220, 240..340 — gap = 20
+    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(240, 0)], 'x');
+    expect(out).not.toBeNull();
+    expect(out?.axis).toBe('x');
+    expect(out?.gapPx).toBe(20);
+    expect(out?.midpoints).toHaveLength(2);
+    expect(out?.midpoints[0]).toEqual({ x: 110, y: 30 });
+    expect(out?.midpoints[1]).toEqual({ x: 230, y: 30 });
+  });
+
+  test('uneven gaps outside tolerance → null', () => {
+    // gaps: 20, 30
+    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(250, 0)], 'x');
+    expect(out).toBeNull();
+  });
+
+  test('within 1 px tolerance is accepted', () => {
+    // gaps: 20, 21 — within default tolerance of 1
+    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(241, 0)], 'x');
+    expect(out).not.toBeNull();
+    expect(out?.gapPx).toBeGreaterThanOrEqual(20);
+    expect(out?.gapPx).toBeLessThanOrEqual(21);
+  });
+
+  test('explicit tolerance allows wider band', () => {
+    // gaps: 20, 25
+    const tightFail = detectEqualSpacing([r(0, 0), r(120, 0), r(245, 0)], 'x');
+    expect(tightFail).toBeNull();
+    const loosePass = detectEqualSpacing([r(0, 0), r(120, 0), r(245, 0)], 'x', {
+      tolerancePx: 5,
+    });
+    expect(loosePass).not.toBeNull();
+  });
+
+  test('rects passed in random order → sorted internally', () => {
+    const out = detectEqualSpacing([r(240, 0), r(0, 0), r(120, 0)], 'x');
+    expect(out).not.toBeNull();
+    expect(out?.gapPx).toBe(20);
+  });
+});
+
+describe('detectEqualSpacing / vertical axis', () => {
+  test('3 rects stacked, equal gap 30 → detects', () => {
+    // y: 0..60, 90..150, 180..240 — gap 30
+    const out = detectEqualSpacing([r(0, 0), r(0, 90), r(0, 180)], 'y');
+    expect(out).not.toBeNull();
+    expect(out?.axis).toBe('y');
+    expect(out?.gapPx).toBe(30);
+    expect(out?.midpoints).toHaveLength(2);
+    expect(out?.midpoints[0]?.y).toBe(75); // 60 + 30/2
+    expect(out?.midpoints[1]?.y).toBe(165);
+  });
+});
+
+describe('detectEqualSpacing / 4+ rects', () => {
+  test('4 rects equally distributed → 3 midpoints', () => {
+    // gaps 20, 20, 20
+    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(240, 0), r(360, 0)], 'x');
+    expect(out).not.toBeNull();
+    expect(out?.midpoints).toHaveLength(3);
+    expect(out?.gapPx).toBe(20);
+  });
+
+  test('one bad gap in a 4-rect set → null', () => {
+    // gaps 20, 50, 20
+    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(270, 0), r(390, 0)], 'x');
+    expect(out).toBeNull();
+  });
+});

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/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);
+  });
+});

package/plugins/design/dev-server/test/use-cursor-modifiers.test.ts

@@ -0,0 +1,59 @@
+// use-cursor-modifiers — T28 (Wave 3). Pure reducer covers the cross-platform
+// Ctrl≡Meta normalization + same-state short-circuit.
+
+import { describe, expect, test } from 'bun:test';
+
+import { type ModifierState, reduceModifiers } from '../use-cursor-modifiers.tsx';
+
+const initial: ModifierState = { alt: false, shift: false, meta: false };
+
+const k = (over: Partial<KeyboardEventInit & { ctrlKey: boolean }> = {}) => ({
+  altKey: false,
+  shiftKey: false,
+  metaKey: false,
+  ctrlKey: false,
+  ...over,
+});
+
+describe('reduceModifiers', () => {
+  test('no change → returns same reference (cheap equality)', () => {
+    const out = reduceModifiers(initial, k());
+    expect(out).toBe(initial);
+  });
+
+  test('alt down → alt:true', () => {
+    const out = reduceModifiers(initial, k({ altKey: true }));
+    expect(out).toEqual({ alt: true, shift: false, meta: false });
+  });
+
+  test('shift down → shift:true', () => {
+    const out = reduceModifiers(initial, k({ shiftKey: true }));
+    expect(out).toEqual({ alt: false, shift: true, meta: false });
+  });
+
+  test('meta down → meta:true', () => {
+    const out = reduceModifiers(initial, k({ metaKey: true }));
+    expect(out).toEqual({ alt: false, shift: false, meta: true });
+  });
+
+  test('ctrl is normalized to meta (cross-platform parity)', () => {
+    const out = reduceModifiers(initial, k({ ctrlKey: true }));
+    expect(out.meta).toBe(true);
+  });
+
+  test('meta + ctrl together → meta:true (not duplicated)', () => {
+    const out = reduceModifiers(initial, k({ metaKey: true, ctrlKey: true }));
+    expect(out).toEqual({ alt: false, shift: false, meta: true });
+  });
+
+  test('alt+shift simultaneously → both true', () => {
+    const out = reduceModifiers(initial, k({ altKey: true, shiftKey: true }));
+    expect(out).toEqual({ alt: true, shift: true, meta: false });
+  });
+
+  test('releasing alt while shift still held → shift only', () => {
+    const both: ModifierState = { alt: true, shift: true, meta: false };
+    const out = reduceModifiers(both, k({ shiftKey: true })); // alt released
+    expect(out).toEqual({ alt: false, shift: true, meta: false });
+  });
+});