@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/use-selection-set.test.tsx

@@ -1,166 +0,0 @@
-// use-selection-set — Phase 4.1 Task 3. Set semantics + wire-shape helpers.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  denormalizeSelectedWrite,
-  normalizeSelectedRead,
-  type Selection,
-} from '../use-selection-set.tsx';
-
-const mkSel = (over: Partial<Selection> = {}): Selection => ({
-  selector: 'section:nth-child(1) > div',
-  ...over,
-});
-
-describe('use-selection-set / normalizeSelectedRead', () => {
-  test('null → []', () => {
-    expect(normalizeSelectedRead(null)).toEqual([]);
-    expect(normalizeSelectedRead(undefined)).toEqual([]);
-  });
-
-  test('single object → length-1 array', () => {
-    const s = mkSel({ id: 'cd-a' });
-    expect(normalizeSelectedRead(s)).toEqual([s]);
-  });
-
-  test('array passes through', () => {
-    const a = mkSel({ id: 'cd-a' });
-    const b = mkSel({ id: 'cd-b' });
-    expect(normalizeSelectedRead([a, b])).toEqual([a, b]);
-  });
-
-  test('array dedupe by data-cd-id', () => {
-    const a = mkSel({ id: 'cd-a' });
-    const aDup = mkSel({ id: 'cd-a', text: 'should be dropped' });
-    expect(normalizeSelectedRead([a, aDup])).toEqual([a]);
-  });
-
-  test('array dedupe by selector when no id', () => {
-    const a = mkSel({ selector: '.card:nth-child(1)' });
-    const b = mkSel({ selector: '.card:nth-child(1)' });
-    expect(normalizeSelectedRead([a, b])).toEqual([a]);
-  });
-
-  test("mixed id / selector keys don't collide", () => {
-    const byId = mkSel({ id: 'cd-a', selector: '.x' });
-    const bySel = mkSel({ selector: 'cd-a' }); // no id, selector happens to be 'cd-a'
-    expect(normalizeSelectedRead([byId, bySel])).toEqual([byId, bySel]);
-  });
-});
-
-describe('use-selection-set / denormalizeSelectedWrite', () => {
-  test('empty → null', () => {
-    expect(denormalizeSelectedWrite([])).toBeNull();
-  });
-
-  test('length-1 → bare object (back-compat with legacy single-element shape)', () => {
-    const s = mkSel({ id: 'cd-a' });
-    expect(denormalizeSelectedWrite([s])).toBe(s);
-  });
-
-  test('length>1 → array', () => {
-    const a = mkSel({ id: 'cd-a' });
-    const b = mkSel({ id: 'cd-b' });
-    expect(denormalizeSelectedWrite([a, b])).toEqual([a, b]);
-  });
-});
-
-describe('use-selection-set / round trip read-write', () => {
-  test('legacy single-element shape → array of 1 → back to single-element', () => {
-    const legacy = mkSel({ id: 'cd-a' });
-    const arr = normalizeSelectedRead(legacy);
-    expect(arr).toEqual([legacy]);
-    expect(denormalizeSelectedWrite(arr)).toBe(legacy);
-  });
-
-  test('null round-trips as null', () => {
-    expect(denormalizeSelectedWrite(normalizeSelectedRead(null))).toBeNull();
-  });
-});
-
-describe('use-selection-set / inspect.ts setSelected widening (integration)', () => {
-  test('inspect.setSelected accepts array and collapses single-entry to object', async () => {
-    // Spin up createInspect with a real on-disk active file in a tmp dir.
-    const { createInspect } = await import('../inspect.ts');
-    const { createBus } = await import('../context.ts');
-    const tmp = `/tmp/use-selection-set-${Date.now()}`;
-    await Bun.write(`${tmp}/.design/.keep`, '');
-    const ctx: Parameters<typeof createInspect>[0] = {
-      cfg: {} as never,
-      projectLabel: '',
-      paths: {
-        designRoot: `${tmp}/.design`,
-        designRel: '.design',
-        activeFile: `${tmp}/.design/_active.json`,
-        serverFile: `${tmp}/.design/_server.json`,
-        historyRoot: `${tmp}/.design/_history`,
-        commentsRoot: `${tmp}/.design/_comments`,
-        cwd: tmp,
-      } as never,
-      bus: createBus(),
-    };
-    const insp = createInspect(ctx, async () => []);
-
-    insp.setSelected({
-      file: '.design/ui/Foo.tsx',
-      selector: '.x',
-      tag: 'div',
-      classes: '',
-      text: '',
-      dom_path: [],
-      bounds: null,
-      html: '',
-      id: 'cd-a',
-    });
-    expect(Array.isArray(insp.state.selected)).toBe(false);
-    expect((insp.state.selected as { id?: string } | null)?.id).toBe('cd-a');
-
-    insp.setSelected([
-      {
-        file: '.design/ui/Foo.tsx',
-        selector: '.a',
-        tag: 'div',
-        classes: '',
-        text: '',
-        dom_path: [],
-        bounds: null,
-        html: '',
-        id: 'cd-a',
-      },
-      {
-        file: '.design/ui/Foo.tsx',
-        selector: '.b',
-        tag: 'div',
-        classes: '',
-        text: '',
-        dom_path: [],
-        bounds: null,
-        html: '',
-        id: 'cd-b',
-      },
-    ]);
-    expect(Array.isArray(insp.state.selected)).toBe(true);
-    expect((insp.state.selected as unknown[]).length).toBe(2);
-
-    // Single-entry array → object collapse
-    insp.setSelected([
-      {
-        file: '.design/ui/Foo.tsx',
-        selector: '.only',
-        tag: 'div',
-        classes: '',
-        text: '',
-        dom_path: [],
-        bounds: null,
-        html: '',
-        id: 'cd-only',
-      },
-    ]);
-    expect(Array.isArray(insp.state.selected)).toBe(false);
-    expect((insp.state.selected as { id?: string } | null)?.id).toBe('cd-only');
-
-    insp.setSelected(null);
-    expect(insp.state.selected).toBeNull();
-  });
-});

package/apps/studio/test/use-snap-guides.test.ts

@@ -1,271 +0,0 @@
-// use-snap-guides — Phase 4.2 Task 1. Pure snap-math table tests.
-
-import { describe, expect, test } from 'bun:test';
-
-import { computeSnap, type Rect, type SnapOptions } 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('computeSnap / disabled (Alt-held)', () => {
-  test('returns proposed unchanged + zero guides', () => {
-    const r = computeSnap(rect(37, 78), [rect(100, 100)], { ...DEFAULTS, disabled: true });
-    expect(r.x).toBe(37);
-    expect(r.y).toBe(78);
-    expect(r.guides).toEqual([]);
-  });
-});
-
-describe('computeSnap / grid', () => {
-  test('snaps left edge to nearest grid line within tolerance', () => {
-    const r = computeSnap(rect(37, 200), [], DEFAULTS);
-    expect(r.x).toBe(40);
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 40 });
-  });
-
-  test('does NOT snap when outside tolerance', () => {
-    const r = computeSnap(rect(27, 200), [], DEFAULTS);
-    expect(r.x).toBe(27);
-    expect(r.guides.find((g) => g.axis === 'x')).toBeUndefined();
-  });
-
-  test('snaps top edge independently of left edge', () => {
-    const r = computeSnap(rect(200, 37), [], DEFAULTS);
-    expect(r.y).toBe(40);
-    expect(r.guides.find((g) => g.axis === 'y')).toMatchObject({ pos: 40 });
-    expect(r.x).toBe(200);
-  });
-
-  test('exact grid boundary (delta = 0) snaps to itself + emits guide', () => {
-    const r = computeSnap(rect(40, 80), [], DEFAULTS);
-    expect(r.x).toBe(40);
-    expect(r.y).toBe(80);
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 40 });
-    expect(r.guides.find((g) => g.axis === 'y')).toMatchObject({ pos: 80 });
-  });
-
-  test("guide line spans proposed's perpendicular extent (no sibling)", () => {
-    const r = computeSnap(rect(37, 200, 100, 80), [], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg).toMatchObject({ from: 200, to: 280 });
-  });
-});
-
-describe('computeSnap / sibling edges (X-axis)', () => {
-  test('left↔left snap', () => {
-    const proposed = rect(503, 200);
-    const sibling = rect(500, 50);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(500);
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 500 });
-  });
-
-  test('right↔right snap (proposed.right snaps to sibling.right)', () => {
-    // proposed right = 503 + 100 = 603; sibling right = 500 + 100 = 600.
-    // delta = 600 - 603 = -3 → snap x by -3.
-    const proposed = rect(503, 300, 100, 80);
-    const sibling = rect(500, 100, 100, 80);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(500);
-  });
-
-  test('left↔right (proposed.left snaps to sibling.right — abutment)', () => {
-    // proposed.left = 597; sibling.right = 600. delta = +3.
-    const proposed = rect(597, 300, 100, 80);
-    const sibling = rect(500, 100, 100, 80);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(600);
-  });
-
-  test('centerX↔centerX snap', () => {
-    // proposed center = 553 + 50 = 603; sibling center = 550 + 50 = 600.
-    const proposed = rect(553, 300, 100, 80);
-    const sibling = rect(550, 100, 100, 80);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(550);
-  });
-
-  test('does NOT snap when delta exceeds tolerance', () => {
-    // proposed.x = 530 sits between grid lines 520 (Δ-10) and 560 (Δ+30) — both
-    // outside tolerance=8. Sibling at 500 is also -30 away. Nothing snaps.
-    const proposed = rect(530, 305);
-    const sibling = rect(500, 105);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(530);
-    expect(r.guides.find((g) => g.axis === 'x')).toBeUndefined();
-  });
-
-  test("guide line spans union of both rects' Y range", () => {
-    const proposed = rect(503, 50, 100, 80); // y range [50, 130]
-    const sibling = rect(500, 300, 100, 80); // y range [300, 380]
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg).toMatchObject({ from: 50, to: 380 });
-  });
-});
-
-describe('computeSnap / sibling edges (Y-axis)', () => {
-  test('top↔top snap', () => {
-    const proposed = rect(300, 103, 100, 80);
-    const sibling = rect(50, 100, 100, 80);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.y).toBe(100);
-  });
-
-  test('bottom↔top snap (proposed below sibling, abutting)', () => {
-    // proposed.bottom = 177; sibling.top = 180. delta = +3 → shift y by +3.
-    const proposed = rect(300, 97, 100, 80);
-    const sibling = rect(50, 180, 100, 80);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.y).toBe(100);
-    expect(proposed.y + 100 - 97).toBe(100);
-    const yg = r.guides.find((g) => g.axis === 'y');
-    expect(yg).toMatchObject({ pos: 180 });
-  });
-
-  test('centerY↔centerY snap', () => {
-    const proposed = rect(300, 103, 100, 80); // centerY = 143
-    const sibling = rect(50, 100, 100, 80); // centerY = 140
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.y).toBe(100);
-  });
-});
-
-describe('computeSnap / closest wins', () => {
-  test('when sibling and grid both within tolerance, closer wins', () => {
-    // proposed.x = 37; grid candidate at 40 (delta 3); sibling.left at 38 (delta 1).
-    const proposed = rect(37, 300);
-    const sibling = rect(38, 100);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(38);
-  });
-
-  test('when grid is closer, grid wins', () => {
-    // proposed.x = 39; grid candidate at 40 (delta 1); sibling at 35 (delta -4).
-    const proposed = rect(39, 300);
-    const sibling = rect(35, 100);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(40);
-  });
-});
-
-describe('computeSnap / X and Y axes are independent', () => {
-  test('snaps X to sibling AND Y to grid simultaneously', () => {
-    // proposed at (503, 37): X snaps to sibling.left=500; Y snaps to grid 40.
-    const proposed = rect(503, 37);
-    const sibling = rect(500, 300);
-    const r = computeSnap(proposed, [sibling], DEFAULTS);
-    expect(r.x).toBe(500);
-    expect(r.y).toBe(40);
-    expect(r.guides.length).toBe(2);
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 500 });
-    expect(r.guides.find((g) => g.axis === 'y')).toMatchObject({ pos: 40 });
-  });
-});
-
-describe('computeSnap / multiple siblings at same pos merge into one guide', () => {
-  test('two siblings with the same left edge produce a single merged guide', () => {
-    const proposed = rect(503, 300, 100, 80);
-    const sibA = rect(500, 100, 100, 80); // y range [100, 180]
-    const sibB = rect(500, 500, 100, 80); // y range [500, 580]
-    const r = computeSnap(proposed, [sibA, sibB], DEFAULTS);
-    const xGuides = r.guides.filter((g) => g.axis === 'x');
-    expect(xGuides.length).toBe(1);
-    expect(xGuides[0]).toMatchObject({
-      pos: 500,
-      from: 100,
-      to: 580,
-    });
-  });
-});
-
-describe('computeSnap / no candidates', () => {
-  test('empty others + outside grid tolerance → identity, no guides', () => {
-    const r = computeSnap(rect(27, 27), [], DEFAULTS);
-    expect(r.x).toBe(27);
-    expect(r.y).toBe(27);
-    expect(r.guides).toEqual([]);
-  });
-});
-
-// feature-1-artboard-kinds-foundation, T7 — generic-layout-guide-line candidates.
-describe('computeSnap / guide lines (T5 guides fed in as snap candidates)', () => {
-  test('left edge snaps to a guide line within tolerance, kind "guide"', () => {
-    const r = computeSnap(rect(503, 200), [], {
-      ...DEFAULTS,
-      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
-    });
-    expect(r.x).toBe(500);
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 500, kind: 'guide' });
-  });
-
-  test('right edge and center also test against the same guide line', () => {
-    // proposed right edge (137+100=237) is within tolerance of the guide at 240.
-    const r = computeSnap(rect(137, 200), [], {
-      ...DEFAULTS,
-      guideLines: [{ axis: 'x', pos: 240, from: 0, to: 1000 }],
-    });
-    expect(r.x).toBe(140); // shifted so right edge lands exactly on 240
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 240, kind: 'guide' });
-  });
-
-  test('a closer sibling wins over a farther guide line on the same axis', () => {
-    const r = computeSnap(rect(503, 200), [rect(500, 500)], {
-      ...DEFAULTS,
-      guideLines: [{ axis: 'x', pos: 507, from: 0, to: 1000 }],
-    });
-    // sibling delta = -3 (|3|), guide delta = +4 (|4|) — sibling is closer.
-    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ kind: 'sibling', pos: 500 });
-  });
-
-  test('outside tolerance, a guide line is ignored', () => {
-    const r = computeSnap(rect(100, 200), [], {
-      ...DEFAULTS,
-      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
-    });
-    expect(r.x).toBe(100);
-  });
-
-  test('y-axis guide lines snap independently of x-axis', () => {
-    const r = computeSnap(rect(200, 303), [], {
-      ...DEFAULTS,
-      guideLines: [{ axis: 'y', pos: 300, from: 0, to: 1000 }],
-    });
-    expect(r.y).toBe(300);
-    expect(r.x).toBe(200);
-  });
-});
-
-describe('computeSnap / intent presets (T7 Design Decision 4)', () => {
-  test('"pixel" intent ignores siblings AND guide lines — grid only', () => {
-    const r = computeSnap(rect(503, 201), [rect(500, 500)], {
-      ...DEFAULTS,
-      intent: 'pixel',
-      guideLines: [{ axis: 'x', pos: 502, from: 0, to: 1000 }],
-    });
-    // Neither the sibling (delta -3) nor the guide (delta -1) fire under
-    // "pixel" — only the grid pass, out of tolerance from both 503 and 201.
-    expect(r.x).toBe(503);
-    expect(r.guides.some((g) => g.kind === 'sibling' || g.kind === 'guide')).toBe(false);
-  });
-
-  test('"pixel" intent still snaps to the grid', () => {
-    const r = computeSnap(rect(37, 200), [], { ...DEFAULTS, intent: 'pixel' });
-    expect(r.x).toBe(40);
-  });
-
-  test('omitting `intent` defaults to "layout" (back-compat with every pre-T7 call site)', () => {
-    const r = computeSnap(rect(503, 200), [rect(500, 500)], DEFAULTS);
-    expect(r.x).toBe(500);
-  });
-
-  test('"layout" intent (explicit) still snaps to siblings + guides', () => {
-    const r = computeSnap(rect(503, 200), [], {
-      ...DEFAULTS,
-      intent: 'layout',
-      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
-    });
-    expect(r.x).toBe(500);
-  });
-});

package/apps/studio/test/use-tool-mode.test.tsx

@@ -1,186 +0,0 @@
-// use-tool-mode — Phase 4.1 Task 2. Provider transitions + cursor sync.
-
-import { describe, expect, test } from 'bun:test';
-
-import { renderToStaticMarkup } from 'react-dom/server';
-
-import {
-  DEFAULT_TOOLS,
-  filterToolsForReadOnly,
-  MODE_DEFAULT_TOOL,
-  ToolProvider,
-  useToolMode,
-  useToolModeOptional,
-} from '../use-tool-mode.tsx';
-
-describe('use-tool-mode / static', () => {
-  test('DEFAULT_TOOLS exposes browse (boot default, no letter) + V/H/C + draw set B/I/R/N/⇧S/A/T/E', () => {
-    expect(DEFAULT_TOOLS.map((t) => t.id)).toEqual([
-      // feature-4 (browse/move split) — browse leads, Move (V) is the select tool.
-      'browse',
-      'move',
-      'hand',
-      'comment',
-      'pen',
-      'highlighter',
-      'shape',
-      'sticky',
-      'section',
-      'arrow',
-      'text',
-      'eraser',
-    ]);
-    expect(DEFAULT_TOOLS.map((t) => t.shortcut)).toEqual([
-      '', // browse — no letter shortcut (palette / Esc-from-draw only)
-      'V',
-      'H',
-      'C',
-      'B',
-      'I',
-      'R',
-      'N',
-      '⇧S',
-      'A',
-      'T',
-      'E',
-    ]);
-  });
-
-  test('DEFAULT_TOOLS is immutable (Object.freeze applied)', () => {
-    expect(Object.isFrozen(DEFAULT_TOOLS)).toBe(true);
-  });
-
-  test('MODE_DEFAULT_TOOL — DDR-223 resting tools: preview→browse, edit→move', () => {
-    expect(MODE_DEFAULT_TOOL).toEqual({ preview: 'browse', edit: 'move' });
-    expect(Object.isFrozen(MODE_DEFAULT_TOOL)).toBe(true);
-  });
-
-  test('cursors per tool (Phase 24 — ONE Kenney library for every tool + native fallback)', () => {
-    const byId = Object.fromEntries(DEFAULT_TOOLS.map((t) => [t.id, t.cursor]));
-    // Phase 24 — EVERY tool (incl. move) ships a Kenney data-URI SVG cursor that
-    // falls back to the right native cursor if the image is rejected.
-    for (const id of [
-      'move',
-      'hand',
-      'comment',
-      'pen',
-      'highlighter',
-      'shape',
-      'sticky',
-      'section',
-      'arrow',
-      'text',
-      'eraser',
-    ]) {
-      expect(byId[id]).toContain('url("data:image/svg+xml,');
-      expect(byId[id]).toContain('32'); // 32×32 cursor
-    }
-    // Native fallbacks are preserved after the custom URL.
-    expect(byId.move).toMatch(/, default$/);
-    expect(byId.hand).toMatch(/, grab$/);
-    expect(byId.text).toMatch(/, text$/);
-    expect(byId.eraser).toMatch(/, cell$/);
-    expect(byId.pen).toMatch(/, crosshair$/);
-    expect(byId.shape).toMatch(/, crosshair$/);
-    // feature-4 — browse is the ONE tool with NO custom glyph: it's a pure
-    // native pass-through, so it shows the system `default` cursor over chrome
-    // and (special-cased in the provider) native element cursors over the mock.
-    expect(byId.browse).toBe('default');
-  });
-});
-
-describe('use-tool-mode / useToolModeOptional', () => {
-  test('returns null outside provider (SSR-safe path)', () => {
-    // useToolModeOptional uses useContext directly; outside a provider it
-    // returns the context's default value, which we set to null.
-    // We can't render hooks standalone without a renderer, but importing the
-    // module and calling useContext directly mirrors the runtime behavior.
-    // This documents the contract via the export shape.
-    expect(typeof useToolModeOptional).toBe('function');
-  });
-});
-
-describe('use-tool-mode / SSR render', () => {
-  test('ToolProvider with consumer renders without throwing', () => {
-    function Consumer() {
-      const { tool, mode } = useToolMode();
-      return (
-        <span data-tool={tool} data-mode={mode}>
-          {tool}
-        </span>
-      );
-    }
-    const html = renderToStaticMarkup(
-      <ToolProvider>
-        <Consumer />
-      </ToolProvider>
-    );
-    // DDR-223 (issue #93) — boot posture is EDIT with the Move (select) tool
-    // armed; Preview (the DDR-187 alive posture) is one toggle away.
-    expect(html).toContain('data-tool="move"');
-    expect(html).toContain('data-mode="edit"');
-  });
-
-  test('ToolProvider initial="browse" boots the preview mode (comment-mount / specimens)', () => {
-    function Consumer() {
-      const { tool, mode } = useToolMode();
-      return (
-        <span data-tool={tool} data-mode={mode}>
-          {tool}
-        </span>
-      );
-    }
-    const html = renderToStaticMarkup(
-      <ToolProvider initial="browse">
-        <Consumer />
-      </ToolProvider>
-    );
-    expect(html).toContain('data-tool="browse"');
-    expect(html).toContain('data-mode="preview"');
-  });
-
-  test('ToolProvider honors initial tool', () => {
-    function Consumer() {
-      const { tool } = useToolMode();
-      return <span>{tool}</span>;
-    }
-    const html = renderToStaticMarkup(
-      <ToolProvider initial="comment">
-        <Consumer />
-      </ToolProvider>
-    );
-    expect(html).toContain('comment');
-  });
-
-  test('useToolMode outside ToolProvider throws', () => {
-    function BareConsumer() {
-      useToolMode();
-      return null;
-    }
-    expect(() => renderToStaticMarkup(<BareConsumer />)).toThrow(
-      /useToolMode must be used inside <ToolProvider>/
-    );
-  });
-});
-
-// Cloud Phase 25 C2 — read-only tool filtering. The provider applies this to
-// its `tools` when the canvas booted with ?ro=1; the pure function is what the
-// contract pins: navigate/inspect only, every write tool absent.
-describe('use-tool-mode / read-only filter', () => {
-  test('read-only keeps exactly browse + move + hand, in order', () => {
-    expect(filterToolsForReadOnly(DEFAULT_TOOLS, true).map((t) => t.id)).toEqual([
-      'browse',
-      'move',
-      'hand',
-    ]);
-  });
-
-  test('comment is filtered too — the cell refuses viewer comments until C3', () => {
-    const ids = filterToolsForReadOnly(DEFAULT_TOOLS, true).map((t) => t.id);
-    expect(ids).not.toContain('comment');
-  });
-
-  test('readOnly=false is identity', () => {
-    expect(filterToolsForReadOnly(DEFAULT_TOOLS, false)).toEqual([...DEFAULT_TOOLS]);
-  });
-});