@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/inspect-script-syntax.test.ts

@@ -1,53 +0,0 @@
-// inspect-script-syntax.test.ts — regression guard for a real bug hit while
-// adding the photo-editor's background-removal busy shimmer: INSPECTOR_SCRIPT
-// (inspect.ts) is itself a giant template literal, so a stray backtick in an
-// inline comment silently truncates/reopens it — tsc DOES catch backtick
-// imbalance (it breaks the outer .ts file's own syntax), but nothing catches
-// any OTHER malformed-JS mistake inside the injected string (e.g. a stray
-// unescaped quote, mismatched braces in the CSS array). This test extracts the
-// actual injected <script> body and syntax-checks it directly.
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import { type Context, createBus } from '../context.ts';
-import { createInspect } from '../inspect.ts';
-import { makeSandbox } from './_helpers.ts';
-
-function mkCtx(root: string, designRoot: string): Context {
-  return {
-    cfg: {} as Context['cfg'],
-    projectLabel: 'test',
-    bus: createBus(),
-    paths: {
-      repoRoot: root,
-      designRel: '.design',
-      designRoot,
-      serverInfoFile: join(designRoot, '_server.json'),
-      activeFile: join(designRoot, '_active.json'),
-      commentsDir: join(designRoot, '_comments'),
-      canvasStateDir: join(designRoot, '_canvas-state'),
-      historyDir: join(designRoot, '_history'),
-      tokensUrlRel: '',
-      systemDirRel: 'system',
-    },
-  };
-}
-
-describe('injectInspector — injected <script> is syntactically valid JS', () => {
-  test('the extracted script body compiles with no SyntaxError', () => {
-    const { root, designRoot } = makeSandbox();
-    const inspect = createInspect(mkCtx(root, designRoot), async () => []);
-    const out = inspect.injectInspector('<html><body></body></html>');
-
-    const scripts = [...out.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1]);
-    expect(scripts.length).toBeGreaterThan(0);
-
-    for (const body of scripts) {
-      // `new Function` only PARSES the body (no window/document access at
-      // construction time) — throws SyntaxError on malformed JS, exactly the
-      // class of bug a stray backtick / unbalanced brace produces.
-      expect(() => new Function(body)).not.toThrow();
-    }
-  });
-});

package/apps/studio/test/inspect-selections.test.ts

@@ -1,219 +0,0 @@
-// feature-acp-context-hardening — per-canvas selection memory (`selections`
-// map) with the `selected` mirror invariant, restore-on-switch, the mtime
-// drift gate, html size cap on parked entries, and open_tabs GC.
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import { type Context, createBus } from '../context.ts';
-import { createInspect, type SelectedElement } from '../inspect.ts';
-import { makeSandbox } from './_helpers.ts';
-
-function mkCtx(root: string, designRoot: string): Context {
-  return {
-    cfg: {} as Context['cfg'],
-    projectLabel: 'test',
-    bus: createBus(),
-    paths: {
-      repoRoot: root,
-      designRel: '.design',
-      designRoot,
-      serverInfoFile: join(designRoot, '_server.json'),
-      activeFile: join(designRoot, '_active.json'),
-      commentsDir: join(designRoot, '_comments'),
-      canvasStateDir: join(designRoot, '_canvas-state'),
-      historyDir: join(designRoot, '_history'),
-      tokensUrlRel: '',
-      systemDirRel: 'system',
-    },
-  };
-}
-
-const A = '.design/ui/fixture.html'; // exists via makeSandbox
-const B = '.design/ui/second.tsx';
-
-function selFor(file: string, text = 'hello') {
-  return {
-    file,
-    selector: 'h1',
-    tag: 'h1',
-    classes: '',
-    text,
-    dom_path: ['html', 'body', 'h1'],
-    bounds: { x: 0, y: 0, w: 100, h: 24 },
-    html: `<h1>${text}</h1>`,
-  };
-}
-
-async function mkRig() {
-  const { root, designRoot } = makeSandbox();
-  await Bun.write(join(root, B), 'export default function Second() { return <h1>B</h1>; }');
-  const ctx = mkCtx(root, designRoot);
-  const inspect = createInspect(ctx, async () => []);
-  return { root, designRoot, ctx, inspect };
-}
-
-const asOne = (v: unknown): SelectedElement => v as SelectedElement;
-
-describe('per-canvas selections — restore on switch', () => {
-  test('selection survives a canvas switch and comes back on return', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    expect(asOne(inspect.state.selected).selector).toBe('h1');
-
-    inspect.setActive(B);
-    expect(inspect.state.selected).toBeNull(); // B has no memory
-
-    inspect.setActive(A);
-    const restored = asOne(inspect.state.selected);
-    expect(restored).not.toBeNull();
-    expect(restored.selector).toBe('h1');
-    expect(restored.file).toBe(A); // SEL_VALID (`selected.file === active`) holds
-  });
-
-  test('parked (non-active) entries carry html: "" — size cap', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    // Active canvas's write-through keeps the rich copy…
-    expect(asOne(inspect.state.selections['ui/fixture']).html).toContain('<h1>');
-    inspect.setActive(B);
-    // …but parking on switch-away strips it.
-    expect(asOne(inspect.state.selections['ui/fixture']).html).toBe('');
-    inspect.setActive(A);
-    expect(asOne(inspect.state.selected).html).toBe('');
-  });
-
-  test('mirror invariant: selected === selections[activeSlug] after select', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    expect(inspect.state.selections['ui/fixture']).toBe(inspect.state.selected);
-  });
-
-  test('a cross-canvas plant (selection.file != active) is NOT stored (attacker F2 residual)', async () => {
-    // An active untrusted canvas posts a selection claiming a DIFFERENT canvas's
-    // file — it must not land in that canvas's slot for later agent delivery.
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(B, 'planted')); // A is active, payload claims B
-    expect(inspect.state.selections['ui/second']).toBeUndefined();
-    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
-    // Later opening B must not resurrect the plant.
-    inspect.setActive(B);
-    expect(inspect.state.selected).toBeNull();
-  });
-
-  test('single-entry array still collapses to a bare object (Phase 4.1 contract)', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected([selFor(A)]);
-    expect(Array.isArray(inspect.state.selected)).toBe(false);
-    expect(asOne(inspect.state.selected).tag).toBe('h1');
-  });
-});
-
-describe('per-canvas selections — drift gate', () => {
-  test('canvas edited while parked → restored selection is stale', async () => {
-    const { root, inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    const stamped = asOne(inspect.state.selected).canvas_mtime;
-    expect(stamped).toBeGreaterThan(0);
-
-    inspect.setActive(B);
-    // Another writer edits canvas A while it's parked (ensure mtime moves).
-    await Bun.sleep(5);
-    await Bun.write(join(root, A), '<!doctype html><html><body><h1>changed</h1></body></html>');
-
-    inspect.setActive(A);
-    expect(asOne(inspect.state.selected).stale).toBe(true);
-  });
-
-  test('untouched canvas restores without the stale flag', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    inspect.setActive(B);
-    inspect.setActive(A);
-    expect(asOne(inspect.state.selected).stale).toBeUndefined();
-  });
-});
-
-describe('per-canvas selections — lifecycle', () => {
-  test('explicit deselect clears the active canvas memory', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    inspect.setSelected(null);
-    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
-    inspect.setActive(B);
-    inspect.setActive(A);
-    expect(inspect.state.selected).toBeNull();
-  });
-
-  test('single-canvas shell ordering (tabs BEFORE active) never GCs the outgoing canvas', async () => {
-    // The shell replaces the tab and sends `tabs` with ONLY the incoming canvas
-    // before `active` parks the outgoing one — the exact wire order of app.jsx
-    // openTab effects. The outgoing canvas's memory must survive the round trip.
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setOpenTabs([A]);
-    inspect.setSelected(selFor(A));
-
-    inspect.setOpenTabs([B]); // switch A→B: tabs first…
-    inspect.setActive(B); //    …then active (parks A)
-    expect(inspect.state.selections['ui/fixture']).toBeDefined();
-
-    inspect.setOpenTabs([A]); // switch back B→A: tabs first…
-    inspect.setActive(A); //    …then active (restores A)
-    expect(asOne(inspect.state.selected).selector).toBe('h1');
-    expect(asOne(inspect.state.selected).file).toBe(A);
-  });
-
-  test('closing a tab GCs its parked selection', async () => {
-    const { inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    inspect.setActive(B); // parks A
-    inspect.setOpenTabs([B]); // A closed
-    expect(inspect.state.selections['ui/fixture']).toBeUndefined();
-    expect(Object.keys(inspect.state.selections)).toHaveLength(0);
-  });
-
-  test('save/load round-trips selections; legacy file without them loads as {}', async () => {
-    const { designRoot, ctx, inspect } = await mkRig();
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    await inspect.save();
-
-    const reloaded = createInspect(ctx, async () => []);
-    await reloaded.load();
-    expect(asOne(reloaded.state.selections['ui/fixture']).selector).toBe('h1');
-
-    // Legacy shape (pre-selections) → invariant restored on load.
-    await Bun.write(
-      join(designRoot, '_active.json'),
-      JSON.stringify({ active: A, open_tabs: [A], selected: null, last_change: null })
-    );
-    const legacy = createInspect(ctx, async () => []);
-    await legacy.load();
-    expect(legacy.state.selections).toEqual({});
-  });
-
-  test('switch emits the restored selection on the bus (clients stay in sync)', async () => {
-    const { ctx, inspect } = await mkRig();
-    const emitted: unknown[] = [];
-    ctx.bus.on('selected', (s: unknown) => emitted.push(s));
-    inspect.setActive(A);
-    inspect.setSelected(selFor(A));
-    inspect.setActive(B);
-    inspect.setActive(A);
-    // emits: initial activate (null), select(A), switch→B (null), switch→A (restored)
-    expect(emitted).toHaveLength(4);
-    expect(emitted[0]).toBeNull();
-    expect(emitted[2]).toBeNull();
-    expect(asOne(emitted[3]).selector).toBe('h1');
-  });
-});

package/apps/studio/test/knob-props-authored.test.ts

@@ -1,87 +0,0 @@
-// KNOB_PROPS round-trip — feature-element-editing-robustness Stage B (Task B1
-// + G2 item b). Promoting a property into `KNOB_PROPS` (dom-selection.ts) does
-// two things: `styleMapsFor` captures its authored/computed value into the
-// `Selection` payload (so the new Position/Transform/Typography/Media panel
-// rows have something to render), AND it moves the prop OUT of the Advanced
-// "customStyles" escape hatch — a canvas that had one of these as a raw custom
-// style no longer double-surfaces it there.
-//
-// `hoverTargetToSelection` (the exported, already-tested entry point) spreads
-// `...styleMapsFor(el)` into its return, so this exercises the real promoted
-// list end-to-end without needing to export the private `styleMapsFor`/
-// `KNOB_PROPS` internals.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-afterAll(() => {
-  GlobalRegistrator.unregister();
-});
-
-import { hoverTargetToSelection } from '../dom-selection.ts';
-import type { HoverTarget } from '../input-router.tsx';
-
-function selectionFor(styleText: string) {
-  document.body.innerHTML = `<div data-cd-id="aaaaaaaa" style="${styleText}">x</div>`;
-  const el = document.querySelector('[data-cd-id]') as HTMLElement;
-  const target: HoverTarget = { el, cdId: 'aaaaaaaa', artboardId: null };
-  return hoverTargetToSelection(target);
-}
-
-describe('KNOB_PROPS — the Stage-B promoted (formerly DDR-104 OUT-list) properties', () => {
-  test('position + inset (top/right/bottom/left) + z-index round-trip into authored', () => {
-    const sel = selectionFor(
-      'position: absolute; top: 10px; right: 20px; bottom: 30px; left: 40px; z-index: 5;'
-    );
-    expect(sel.authored?.position).toBe('absolute');
-    expect(sel.authored?.top).toBe('10px');
-    expect(sel.authored?.right).toBe('20px');
-    expect(sel.authored?.bottom).toBe('30px');
-    expect(sel.authored?.left).toBe('40px');
-    expect(sel.authored?.['z-index']).toBe('5');
-  });
-
-  test('transform + transform-origin round-trip', () => {
-    const sel = selectionFor('transform: rotate(12deg); transform-origin: center;');
-    expect(sel.authored?.transform).toBe('rotate(12deg)');
-    expect(sel.authored?.['transform-origin']).toBe('center');
-  });
-
-  test('font-style / text-transform / text-decoration / white-space round-trip', () => {
-    const sel = selectionFor(
-      'font-style: italic; text-transform: uppercase; text-decoration: underline; white-space: nowrap;'
-    );
-    expect(sel.authored?.['font-style']).toBe('italic');
-    expect(sel.authored?.['text-transform']).toBe('uppercase');
-    expect(sel.authored?.['text-decoration']).toBe('underline');
-    expect(sel.authored?.['white-space']).toBe('nowrap');
-  });
-
-  test('overflow + media framing (object-fit/aspect-ratio/object-position) round-trip', () => {
-    const sel = selectionFor(
-      'overflow: hidden; object-fit: cover; aspect-ratio: 16 / 9; object-position: top;'
-    );
-    expect(sel.authored?.overflow).toBe('hidden');
-    expect(sel.authored?.['object-fit']).toBe('cover');
-    expect(sel.authored?.['aspect-ratio']).toBe('16 / 9');
-    expect(sel.authored?.['object-position']).toBe('top');
-  });
-
-  test('a promoted prop never leaks into customStyles (the B1 exclusion gotcha)', () => {
-    const sel = selectionFor('position: absolute; cursor: pointer;');
-    // `position` is curated now → excluded from the Advanced hatch.
-    expect(sel.customStyles?.position).toBeUndefined();
-    // A genuinely uncurated prop (not in KNOB_PROPS) still lands in
-    // customStyles as before — proves the exclusion is targeted, not a
-    // blanket "nothing goes to customStyles anymore" regression.
-    expect(sel.customStyles?.cursor).toBe('pointer');
-  });
-
-  test('computed values are also captured (placeholder-hint source)', () => {
-    const sel = selectionFor('position: relative;');
-    expect(sel.computed?.position).toBe('relative');
-  });
-});

package/apps/studio/test/layers-synthetic-groups.test.ts

@@ -1,96 +0,0 @@
-// layers-synthetic-groups — feature-4 T7. The serializer that feeds the shell's
-// Layers panel must emit SYNTHETIC group rows for unstamped wrappers that hold
-// stamped descendants (so the tree mirrors real nesting), while still omitting
-// purely-decorative wrappers with no addressable content. This is the fix for
-// the "some layers don't show up / the tree is flat" report.
-//
-// Needs a live DOM (children / querySelector / closest) — register happy-dom.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-afterAll(() => {
-  GlobalRegistrator.unregister();
-});
-
-import { serializeArtboardTree } from '../canvas-shell.tsx';
-
-function root(html: string): Element {
-  const el = document.createElement('div');
-  el.className = 'dc-artboard-body';
-  el.innerHTML = html;
-  return el;
-}
-
-describe('serializeArtboardTree — synthetic group rows for unstamped wrappers', () => {
-  test('unstamped wrapper WITH a stamped descendant → synthetic group parent (nesting preserved)', () => {
-    const tree = serializeArtboardTree(
-      root('<div class="hero-wrap"><button data-cd-id="aabbccdd">Go</button></div>')
-    );
-    expect(tree).toHaveLength(1);
-    const group = tree[0]!;
-    expect(group.synthetic).toBe(true);
-    expect(group.type).toBe('group');
-    expect(group.id.startsWith('__grp:')).toBe(true);
-    expect(group.tag).toBe('div');
-    // The stamped button is now a CHILD of the group (not hoisted to the root).
-    expect(group.children).toHaveLength(1);
-    expect(group.children[0]!.id).toBe('aabbccdd');
-    expect(group.children[0]!.synthetic).toBeUndefined();
-  });
-
-  test('unstamped wrapper with NO stamped descendant → omitted (no decorative noise)', () => {
-    const tree = serializeArtboardTree(root('<div class="deco"><span>just text</span></div>'));
-    expect(tree).toHaveLength(0);
-  });
-
-  test('stamped child directly → a normal (non-synthetic) row, no group wrapper', () => {
-    const tree = serializeArtboardTree(root('<section data-cd-id="11112222">Hi</section>'));
-    expect(tree).toHaveLength(1);
-    expect(tree[0]!.synthetic).toBeUndefined();
-    expect(tree[0]!.id).toBe('11112222');
-  });
-
-  test('nested unstamped wrappers → nested synthetic groups (each rung shown)', () => {
-    const tree = serializeArtboardTree(
-      root('<div class="outer"><div class="inner"><a data-cd-id="deadbeef">L</a></div></div>')
-    );
-    expect(tree).toHaveLength(1);
-    const outer = tree[0]!;
-    expect(outer.synthetic).toBe(true);
-    expect(outer.children).toHaveLength(1);
-    const inner = outer.children[0]!;
-    expect(inner.synthetic).toBe(true);
-    expect(inner.children[0]!.id).toBe('deadbeef');
-  });
-
-  test('synthetic group ids are unique across same-signature siblings (stable keys)', () => {
-    const tree = serializeArtboardTree(
-      root(
-        '<div class="col"><span data-cd-id="aaaa1111">a</span></div>' +
-          '<div class="col"><span data-cd-id="bbbb2222">b</span></div>'
-      )
-    );
-    expect(tree).toHaveLength(2);
-    expect(tree[0]!.id).not.toBe(tree[1]!.id);
-    expect(tree[0]!.synthetic).toBe(true);
-    expect(tree[1]!.synthetic).toBe(true);
-  });
-
-  test('mixed: a stamped element AND a sibling unstamped-wrapper-with-content both surface', () => {
-    const tree = serializeArtboardTree(
-      root(
-        '<h1 data-cd-id="head0001">Title</h1>' +
-          '<div class="body"><p data-cd-id="para0001">copy</p></div>'
-      )
-    );
-    expect(tree).toHaveLength(2);
-    expect(tree[0]!.id).toBe('head0001');
-    expect(tree[0]!.synthetic).toBeUndefined();
-    expect(tree[1]!.synthetic).toBe(true);
-    expect(tree[1]!.children[0]!.id).toBe('para0001');
-  });
-});

package/apps/studio/test/locator.test.ts

@@ -1,214 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import {
-  canvasSlug,
-  clearLocatorSlug,
-  type LocatorMap,
-  readLocator,
-  readLocatorFile,
-  writeLocator,
-} from '../locator.ts';
-
-function tmp(): { dir: string; locFile: string; cleanup: () => void } {
-  const dir = mkdtempSync(path.join(tmpdir(), 'mdcc-locator-'));
-  const locFile = path.join(dir, '_locator.json');
-  return { dir, locFile, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
-}
-
-const entry = (canvas: string, line: number): LocatorMap[string] => ({
-  canvas,
-  line,
-  col: 0,
-  jsxPath: ['section'],
-  componentName: 'X',
-});
-
-describe('canvasSlug', () => {
-  test('strips designRoot prefix and file extension', () => {
-    expect(canvasSlug('/proj/.design/ui/Docs Site.tsx', '/proj/.design')).toBe('ui/Docs Site');
-  });
-
-  test('handles nested paths', () => {
-    expect(canvasSlug('/proj/.design/system/project/preview/btn.tsx', '/proj/.design')).toBe(
-      'system/project/preview/btn'
-    );
-  });
-
-  test('files without extension are returned as-is', () => {
-    expect(canvasSlug('/proj/.design/ui/no-ext', '/proj/.design')).toBe('ui/no-ext');
-  });
-});
-
-describe('readLocatorFile / readLocator', () => {
-  test('returns empty object when the file does not exist', async () => {
-    const t = tmp();
-    try {
-      expect(await readLocatorFile(t.locFile)).toEqual({});
-      expect(await readLocator(t.locFile, 'ui/anything')).toBeNull();
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('treats malformed JSON as empty without throwing', async () => {
-    const t = tmp();
-    try {
-      await Bun.write(t.locFile, '{ not valid');
-      expect(await readLocatorFile(t.locFile)).toEqual({});
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('treats a top-level array as empty (defensive against bad shape)', async () => {
-    const t = tmp();
-    try {
-      await Bun.write(t.locFile, '[]');
-      expect(await readLocatorFile(t.locFile)).toEqual({});
-    } finally {
-      t.cleanup();
-    }
-  });
-});
-
-describe('writeLocator — roundtrip + atomicity', () => {
-  test('round-trip a single slug', async () => {
-    const t = tmp();
-    try {
-      const map: LocatorMap = { aaaaaaaa: entry('/c/X.tsx', 4) };
-      await writeLocator(t.locFile, 'ui/X', map);
-      const back = await readLocator(t.locFile, 'ui/X');
-      expect(back).toEqual({ aaaaaaaa: entry('/c/X.tsx', 4) });
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('multiple slugs share the same _locator.json without trampling', async () => {
-    const t = tmp();
-    try {
-      await writeLocator(t.locFile, 'ui/A', { aaaaaaaa: entry('/c/A.tsx', 1) });
-      await writeLocator(t.locFile, 'ui/B', { bbbbbbbb: entry('/c/B.tsx', 2) });
-      const file = await readLocatorFile(t.locFile);
-      expect(Object.keys(file).sort()).toEqual(['ui/A', 'ui/B']);
-      expect(file['ui/A']).toEqual({ aaaaaaaa: entry('/c/A.tsx', 1) });
-      expect(file['ui/B']).toEqual({ bbbbbbbb: entry('/c/B.tsx', 2) });
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('updating an existing slug overwrites its map but leaves siblings intact', async () => {
-    const t = tmp();
-    try {
-      await writeLocator(t.locFile, 'ui/A', { aaaaaaaa: entry('/c/A.tsx', 1) });
-      await writeLocator(t.locFile, 'ui/B', { bbbbbbbb: entry('/c/B.tsx', 2) });
-      await writeLocator(t.locFile, 'ui/A', { cccccccc: entry('/c/A.tsx', 9) });
-      const file = await readLocatorFile(t.locFile);
-      expect(file['ui/A']).toEqual({ cccccccc: entry('/c/A.tsx', 9) });
-      expect(file['ui/B']).toEqual({ bbbbbbbb: entry('/c/B.tsx', 2) });
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('on-disk JSON is deterministic (sorted keys, trailing newline)', async () => {
-    const t = tmp();
-    try {
-      const big: LocatorMap = {
-        zzzzzzzz: entry('/c/X.tsx', 9),
-        aaaaaaaa: entry('/c/X.tsx', 1),
-        mmmmmmmm: entry('/c/X.tsx', 5),
-      };
-      await writeLocator(t.locFile, 'ui/X', big);
-      const raw = await Bun.file(t.locFile).text();
-      // top-level + nested keys should be sorted
-      const aIdx = raw.indexOf('aaaaaaaa');
-      const mIdx = raw.indexOf('mmmmmmmm');
-      const zIdx = raw.indexOf('zzzzzzzz');
-      expect(aIdx).toBeGreaterThan(-1);
-      expect(aIdx).toBeLessThan(mIdx);
-      expect(mIdx).toBeLessThan(zIdx);
-      expect(raw.endsWith('\n')).toBe(true);
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('concurrent writes against the same file do not corrupt JSON', async () => {
-    const t = tmp();
-    try {
-      // Fire 20 writes in parallel, each against a distinct slug. The
-      // per-path mutex must serialise them; the final file must contain all 20.
-      const writes: Promise<void>[] = [];
-      for (let i = 0; i < 20; i++) {
-        const slug = `ui/slug-${String(i).padStart(2, '0')}`;
-        const map: LocatorMap = {
-          [`id${String(i).padStart(5, '0')}`]: entry(`/c/${slug}.tsx`, i + 1),
-        };
-        writes.push(writeLocator(t.locFile, slug, map));
-      }
-      await Promise.all(writes);
-      const file = await readLocatorFile(t.locFile);
-      expect(Object.keys(file).length).toBe(20);
-      for (let i = 0; i < 20; i++) {
-        const slug = `ui/slug-${String(i).padStart(2, '0')}`;
-        expect(file[slug]).toBeDefined();
-      }
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('concurrent writes against the SAME slug end up with the last writer winning, no partial state', async () => {
-    const t = tmp();
-    try {
-      const writes: Promise<void>[] = [];
-      // 10 writes to the same slug, each with a different singleton map.
-      for (let i = 0; i < 10; i++) {
-        const map: LocatorMap = { [`id-${i}`]: entry('/c/X.tsx', i) };
-        writes.push(writeLocator(t.locFile, 'ui/X', map));
-      }
-      await Promise.all(writes);
-      const back = await readLocator(t.locFile, 'ui/X');
-      expect(back).not.toBeNull();
-      // Each writer fully replaces the slug map, so the final state has exactly
-      // one entry. Which entry won is implementation-defined (FIFO via mutex),
-      // but the file shape is well-formed.
-      expect(Object.keys(back as LocatorMap).length).toBe(1);
-    } finally {
-      t.cleanup();
-    }
-  });
-});
-
-describe('clearLocatorSlug', () => {
-  test('removes one slug and leaves siblings', async () => {
-    const t = tmp();
-    try {
-      await writeLocator(t.locFile, 'ui/A', { aaaaaaaa: entry('/c/A.tsx', 1) });
-      await writeLocator(t.locFile, 'ui/B', { bbbbbbbb: entry('/c/B.tsx', 2) });
-      await clearLocatorSlug(t.locFile, 'ui/A');
-      const file = await readLocatorFile(t.locFile);
-      expect(file['ui/A']).toBeUndefined();
-      expect(file['ui/B']).toBeDefined();
-    } finally {
-      t.cleanup();
-    }
-  });
-
-  test('is a no-op when slug missing', async () => {
-    const t = tmp();
-    try {
-      await writeLocator(t.locFile, 'ui/A', { aaaaaaaa: entry('/c/A.tsx', 1) });
-      await clearLocatorSlug(t.locFile, 'ui/Nope');
-      const file = await readLocatorFile(t.locFile);
-      expect(file['ui/A']).toBeDefined();
-    } finally {
-      t.cleanup();
-    }
-  });
-});