@1agh/maude 0.19.0 → 0.20.0

package/plugins/design/dev-server/test/snap-distance-pill.test.ts

@@ -0,0 +1,68 @@
+// snap-distance-pill — DDR-046. Verifies SnapGuide.delta + .kind population
+// in `computeSnap`. The visual `Δ{Math.round(delta)}` pill rendering lives in
+// `SnapGuideOverlay` (`canvas-lib.tsx`); this file covers only the pure-function
+// contract that the overlay reads.
+
+import { describe, expect, test } from 'bun:test';
+
+import { type Rect, type SnapOptions, computeSnap } from '../use-snap-guides.tsx';
+
+const DEFAULTS: SnapOptions = { gridSize: 40, tolerance: 8, disabled: false };
+const rect = (x: number, y: number, w = 100, h = 80): Rect => ({ x, y, w, h });
+
+describe('SnapGuide.delta + .kind (DDR-046)', () => {
+  test('grid snap emits delta + kind=grid', () => {
+    const r = computeSnap(rect(33, 200), [], DEFAULTS);
+    const xg = r.guides.find((g) => g.axis === 'x');
+    expect(xg?.delta).toBe(7); // 40 − 33
+    expect(xg?.kind).toBe('grid');
+  });
+
+  test('grid snap with zero delta (already on grid line) still emits kind=grid', () => {
+    const r = computeSnap(rect(40, 200), [], DEFAULTS);
+    const xg = r.guides.find((g) => g.axis === 'x');
+    expect(xg?.delta).toBe(0);
+    expect(xg?.kind).toBe('grid');
+  });
+
+  test('sibling snap beats grid when both fire (closest |delta| wins)', () => {
+    // proposed x=37: grid candidate at 40 (delta +3), sibling at 35 (delta −2).
+    // |−2| < |3| → sibling wins.
+    const r = computeSnap(rect(37, 200), [rect(35, 0, 50, 50)], DEFAULTS);
+    const xg = r.guides.find((g) => g.axis === 'x');
+    expect(xg?.kind).toBe('sibling');
+    expect(xg?.delta).toBe(-2);
+    expect(r.x).toBe(35);
+  });
+
+  test('sibling snap emits delta + kind=sibling', () => {
+    // proposed x=503, sibling at x=500. Snap left↔left.
+    const r = computeSnap(rect(503, 200), [rect(500, 50, 100, 80)], DEFAULTS);
+    const xg = r.guides.find((g) => g.axis === 'x');
+    expect(xg?.delta).toBe(-3);
+    expect(xg?.kind).toBe('sibling');
+    expect(r.x).toBe(500);
+  });
+
+  test('merged-at-pos guide keeps the larger |delta|', () => {
+    // Two siblings both at x=500 — same edge, different y so merged guide
+    // unions their from/to. Both candidates have identical delta here, but
+    // we still expect the merge code path to preserve a single delta value.
+    const r = computeSnap(
+      rect(503, 200),
+      [rect(500, 50, 100, 50), rect(500, 400, 100, 50)],
+      DEFAULTS
+    );
+    const xg = r.guides.find((g) => g.axis === 'x');
+    expect(xg?.delta).toBe(-3);
+    expect(xg?.kind).toBe('sibling');
+    // Merged span covers both siblings' Y extents.
+    expect(xg?.from).toBe(50);
+    expect(xg?.to).toBe(450);
+  });
+
+  test('disabled mode emits no guides (delta + kind absent)', () => {
+    const r = computeSnap(rect(33, 200), [rect(35, 0)], { ...DEFAULTS, disabled: true });
+    expect(r.guides).toEqual([]);
+  });
+});

package/plugins/design/dev-server/test/system-endpoint.test.ts

@@ -0,0 +1,144 @@
+// /_system-data — bias-free token rendering depends on per-DS scoping.
+// Covers DDR-048: ?ds=<name> scopes payload to one designSystem entry;
+// unknown ds → 404; omitted ds → legacy unscoped behavior for single-DS
+// projects that don't declare `designSystems[]`.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Subprocess } from 'bun';
+import { bootServer, killProc, nextPort } from './_helpers';
+
+interface MultiDsSandbox {
+  root: string;
+  designRoot: string;
+}
+
+function makeMultiDsSandbox(): MultiDsSandbox {
+  const root = mkdtempSync(join(tmpdir(), 'mdcc-multi-ds-'));
+  const designRoot = join(root, '.design');
+  mkdirSync(designRoot, { recursive: true });
+
+  writeFileSync(
+    join(designRoot, 'config.json'),
+    JSON.stringify(
+      {
+        name: 'multi-ds',
+        designRoot: '.design',
+        canvasGroups: [
+          { label: 'Design system', path: 'system' },
+          { label: 'UI', path: 'ui' },
+        ],
+        designSystems: [
+          { name: 'alpha', path: 'system/alpha', description: 'Alpha brand' },
+          { name: 'beta', path: 'system/beta', description: 'Beta brand' },
+        ],
+        defaultDesignSystem: 'alpha',
+      },
+      null,
+      2
+    )
+  );
+
+  // Alpha — periwinkle accent, cream surfaces (mimics StudyFi case).
+  mkdirSync(join(designRoot, 'system', 'alpha', 'preview'), { recursive: true });
+  writeFileSync(
+    join(designRoot, 'system', 'alpha', 'colors_and_type.css'),
+    ":root {\n  --color-bg: #fbfaf7;\n  --accent: #9CACFF;\n  --color-text-primary: #000000;\n  --fs-base: 1rem;\n  --font-body: 'Inter', sans-serif;\n}\n"
+  );
+  writeFileSync(
+    join(designRoot, 'system', 'alpha', 'preview', 'colors-accent.tsx'),
+    'export default function ColorsAccent() { return <div>alpha accent</div>; }\n'
+  );
+
+  // Beta — different palette + names.
+  mkdirSync(join(designRoot, 'system', 'beta', 'preview'), { recursive: true });
+  writeFileSync(
+    join(designRoot, 'system', 'beta', 'colors_and_type.css'),
+    ':root {\n  --bg-0: oklch(13% 0.012 60);\n  --accent: oklch(72% 0.16 55);\n  --type-base: 14px;\n}\n'
+  );
+  writeFileSync(
+    join(designRoot, 'system', 'beta', 'preview', 'colors-accent.tsx'),
+    'export default function ColorsAccent() { return <div>beta accent</div>; }\n'
+  );
+
+  mkdirSync(join(designRoot, 'ui'), { recursive: true });
+  return { root, designRoot };
+}
+
+describe('/_system-data — per-DS scope (DDR-048)', () => {
+  let proc: Subprocess | null = null;
+  let sb: MultiDsSandbox;
+  let port: number;
+
+  beforeEach(async () => {
+    sb = makeMultiDsSandbox();
+    port = nextPort();
+    proc = await bootServer(sb.root, port);
+  });
+
+  afterEach(async () => {
+    if (proc) await killProc(proc);
+    proc = null;
+  });
+
+  test('?ds=alpha → tokens parsed from alpha colors_and_type.css', async () => {
+    const r = await fetch(`http://localhost:${port}/_system-data?ds=alpha`);
+    expect(r.status).toBe(200);
+    const data = (await r.json()) as {
+      tokens: { name: string; value: string }[];
+      ds: { name: string; description: string };
+      tokensPath: string;
+      previewGallery: { label: string }[];
+    };
+    expect(data.ds.name).toBe('alpha');
+    expect(data.ds.description).toBe('Alpha brand');
+    expect(data.tokensPath).toContain('system/alpha/colors_and_type.css');
+    const accent = data.tokens.find((t) => t.name === '--accent');
+    expect(accent?.value).toBe('#9CACFF');
+    const colorBg = data.tokens.find((t) => t.name === '--color-bg');
+    expect(colorBg?.value).toBe('#fbfaf7');
+    // Alpha previews only — no beta leakage.
+    expect(data.previewGallery.some((p) => p.label === 'colors-accent')).toBe(true);
+    expect(data.previewGallery.every((p) => !p.label.includes('beta'))).toBe(true);
+  });
+
+  test('?ds=beta → distinct tokens, distinct previews', async () => {
+    const r = await fetch(`http://localhost:${port}/_system-data?ds=beta`);
+    expect(r.status).toBe(200);
+    const data = (await r.json()) as {
+      tokens: { name: string; value: string }[];
+      ds: { name: string };
+      tokensPath: string;
+    };
+    expect(data.ds.name).toBe('beta');
+    expect(data.tokensPath).toContain('system/beta/colors_and_type.css');
+    const accent = data.tokens.find((t) => t.name === '--accent');
+    expect(accent?.value).toBe('oklch(72% 0.16 55)');
+    const bg0 = data.tokens.find((t) => t.name === '--bg-0');
+    expect(bg0?.value).toBe('oklch(13% 0.012 60)');
+  });
+
+  test('?ds=ghost → 404 + error payload (no silent shell fallback)', async () => {
+    const r = await fetch(`http://localhost:${port}/_system-data?ds=ghost`);
+    expect(r.status).toBe(404);
+    const body = (await r.json()) as { error: string; ds: string };
+    expect(body.error).toBe('unknown design system');
+    expect(body.ds).toBe('ghost');
+  });
+
+  test('unscoped (no ?ds) → availableDesignSystems list + defaultDesignSystem', async () => {
+    const r = await fetch(`http://localhost:${port}/_system-data`);
+    expect(r.status).toBe(200);
+    const data = (await r.json()) as {
+      availableDesignSystems: { name: string; description: string | null }[];
+      defaultDesignSystem: string;
+      ds: unknown;
+    };
+    expect(data.availableDesignSystems).toHaveLength(2);
+    expect(data.availableDesignSystems.map((d) => d.name)).toEqual(['alpha', 'beta']);
+    expect(data.defaultDesignSystem).toBe('alpha');
+    expect(data.ds).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 });
+  });
+});

package/plugins/design/dev-server/test/use-keyboard-discipline.test.ts

@@ -0,0 +1,27 @@
+// use-keyboard-discipline — T29 (Wave 3). Pure nudge-delta fixture.
+
+import { describe, expect, test } from 'bun:test';
+
+import { nudgeDelta } from '../use-keyboard-discipline.tsx';
+
+describe('nudgeDelta', () => {
+  test('non-arrow key → null', () => {
+    expect(nudgeDelta({ key: 'a', shift: false })).toBeNull();
+    expect(nudgeDelta({ key: 'Tab', shift: false })).toBeNull();
+    expect(nudgeDelta({ key: 'Enter', shift: true })).toBeNull();
+  });
+
+  test('arrow without shift → 1 px step', () => {
+    expect(nudgeDelta({ key: 'ArrowLeft', shift: false })).toEqual({ dx: -1, dy: 0 });
+    expect(nudgeDelta({ key: 'ArrowRight', shift: false })).toEqual({ dx: 1, dy: 0 });
+    expect(nudgeDelta({ key: 'ArrowUp', shift: false })).toEqual({ dx: 0, dy: -1 });
+    expect(nudgeDelta({ key: 'ArrowDown', shift: false })).toEqual({ dx: 0, dy: 1 });
+  });
+
+  test('arrow with shift → 10 px step', () => {
+    expect(nudgeDelta({ key: 'ArrowLeft', shift: true })).toEqual({ dx: -10, dy: 0 });
+    expect(nudgeDelta({ key: 'ArrowRight', shift: true })).toEqual({ dx: 10, dy: 0 });
+    expect(nudgeDelta({ key: 'ArrowUp', shift: true })).toEqual({ dx: 0, dy: -10 });
+    expect(nudgeDelta({ key: 'ArrowDown', shift: true })).toEqual({ dx: 0, dy: 10 });
+  });
+});