@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/dynamic-text-edit.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { applyTextEdit } from '../canvas-edit.ts';
-import { transpileCanvasSource } from '../canvas-pipeline.ts';
-
-// unified-text-editing follow-up — editing text that comes from a `{variable}`
-// or `{item.prop}` by tracing it back to its source string (a local const or a
-// `.map()`ed array element). The safety contract: never rewrite the wrong item
-// — occurrence picks the `.map()` slot, `before` verifies/rescues it, and an
-// unresolvable expression still throws (routes to /design:edit).
-
-const CANVAS = '/virtual/Cards.tsx';
-const SRC = `const TOPICS = [
-  { key: "a", body: "Alpha body text." },
-  { key: "b", body: "Beta body text." },
-  { key: "c", body: "Gamma body text." },
-];
-const TAGS = ["first", "second", "third"];
-const HEADLINE = "The one headline";
-export default function Cards() {
-  return (
-    <div>
-      <h1>{HEADLINE}</h1>
-      <section>
-        {TOPICS.map((t) => (
-          <article key={t.key}>
-            <p>{t.body}</p>
-          </article>
-        ))}
-      </section>
-      <ul>
-        {TAGS.map((tag) => (
-          <li key={tag}>{tag}</li>
-        ))}
-      </ul>
-      <p>Total: {TOPICS.length} topics</p>
-      <span>{price.toFixed(2)}</span>
-    </div>
-  );
-}
-const price = 9;
-`;
-
-function ids(withIds: string, tag: string, inner: string): string {
-  // Grab the data-cd-id of the <tag …>inner… element.
-  const re = new RegExp(`<${tag}\\s+data-cd-id="([^"]+)"[^>]*>\\s*\\{?${inner}`);
-  const m = withIds.match(re);
-  if (!m) throw new Error(`no ${tag} matching ${inner}`);
-  return m[1] as string;
-}
-
-describe('dynamic text edit — resolveDynamicTextSpan via applyTextEdit', () => {
-  const { withIds } = transpileCanvasSource(CANVAS, SRC);
-
-  test('{item.prop} in a .map — occurrence picks the array item', () => {
-    const pId = ids(withIds, 'p', 't\\.body');
-    // occurrence 1 → TOPICS[1].body, verified by `before`.
-    const { source } = applyTextEdit(CANVAS, withIds, pId, 'Beta EDITED', {
-      occurrence: 1,
-      before: 'Beta body text.',
-    });
-    expect(source).toContain('body: "Beta EDITED"');
-    expect(source).toContain('body: "Alpha body text."'); // sibling untouched
-    expect(source).toContain('body: "Gamma body text."');
-  });
-
-  test('{item.prop} — index drift rescued by unique before-match', () => {
-    const pId = ids(withIds, 'p', 't\\.body');
-    // Wrong occurrence, but `before` uniquely identifies Gamma → rewrite it.
-    const { source } = applyTextEdit(CANVAS, withIds, pId, 'Gamma EDITED', {
-      occurrence: 0,
-      before: 'Gamma body text.',
-    });
-    expect(source).toContain('body: "Gamma EDITED"');
-    expect(source).toContain('body: "Alpha body text."');
-  });
-
-  test('{item} in a .map over a string array', () => {
-    const liId = ids(withIds, 'li', 'tag');
-    const { source } = applyTextEdit(CANVAS, withIds, liId, 'SECOND', {
-      occurrence: 1,
-      before: 'second',
-    });
-    expect(source).toContain('"first", "SECOND", "third"');
-  });
-
-  test('{localConst} — rewrites the const string', () => {
-    const h1Id = ids(withIds, 'h1', 'HEADLINE');
-    const { source } = applyTextEdit(CANVAS, withIds, h1Id, 'A new headline', {
-      before: 'The one headline',
-    });
-    expect(source).toContain('HEADLINE = "A new headline"');
-  });
-
-  test('{prop.field} — component fed BEATS[k] resolves to BEATS[k].field', () => {
-    // A reusable component whose `beat` prop is fed `BEATS[0..2]` at each usage
-    // (the Remotion-style pattern). Editing the 2nd usage's caption must hit
-    // BEATS[1].caption via occurrence, not card 0 or 2.
-    const SRC2 = `const BEATS = [
-  { n: "01", caption: "Beat one caption." },
-  { n: "02", caption: "Beat two caption." },
-  { n: "03", caption: "Beat three caption." },
-];
-function GuideBeat({ beat }: { beat: (typeof BEATS)[number] }) {
-  return <p>{beat.caption}</p>;
-}
-export default function Reel() {
-  return (
-    <div>
-      <GuideBeat beat={BEATS[0]} />
-      <GuideBeat beat={BEATS[1]} />
-      <GuideBeat beat={BEATS[2]} />
-    </div>
-  );
-}`;
-    const built = transpileCanvasSource(CANVAS, SRC2).withIds;
-    const pId = /<p\s+data-cd-id="([^"]+)"[^>]*>\s*\{beat\.caption\}/.exec(built)?.[1] as string;
-    const { source } = applyTextEdit(CANVAS, built, pId, 'Beat two EDITED', {
-      occurrence: 1,
-      before: 'Beat two caption.',
-    });
-    expect(source).toContain('caption: "Beat two EDITED"');
-    expect(source).toContain('caption: "Beat one caption."');
-    expect(source).toContain('caption: "Beat three caption."');
-  });
-
-  test('genuinely computed text still refuses (routes to /design:edit)', () => {
-    const spanId = ids(withIds, 'span', 'price\\.toFixed');
-    expect(() =>
-      applyTextEdit(CANVAS, withIds, spanId, 'nope', { occurrence: 0, before: '9.00' })
-    ).toThrow(/dynamic content/);
-  });
-
-  test('mixed literal+expression (Total: {n} topics) refuses', () => {
-    // This <p> has text + expression + text → mixed, never offered.
-    const m = withIds.match(/<p[^>]*data-cd-id="([^"]+)"[^>]*>Total:/);
-    expect(m).toBeTruthy();
-    expect(() => applyTextEdit(CANVAS, withIds, (m as RegExpMatchArray)[1] as string, 'x')).toThrow(
-      /mixed or expression/
-    );
-  });
-
-  test('no occurrence + no before on an ambiguous .map refuses (never guesses)', () => {
-    const pId = ids(withIds, 'p', 't\\.body');
-    // Without occurrence or before there is no way to know which card → refuse.
-    expect(() => applyTextEdit(CANVAS, withIds, pId, 'x')).toThrow(/dynamic content/);
-  });
-});
-
-describe('stamp marks var-editable text', () => {
-  const { withIds } = transpileCanvasSource(CANVAS, SRC);
-  test('{item.prop}, {item}, {const} get data-cd-editable="var"', () => {
-    expect(withIds).toMatch(/<p[^>]*data-cd-editable="var"[^>]*>\s*\{t\.body\}/);
-    expect(withIds).toMatch(/<li[^>]*data-cd-editable="var"[^>]*>\s*\{tag\}/);
-    expect(withIds).toMatch(/<h1[^>]*data-cd-editable="var"[^>]*>\s*\{HEADLINE\}/);
-  });
-  test('computed + mixed text are NOT marked', () => {
-    const span = withIds.match(/<span[^>]*>\{price\.toFixed/);
-    expect((span as RegExpMatchArray)[0].includes('data-cd-editable')).toBe(false);
-    const p = withIds.match(/<p[^>]*>Total:/);
-    expect((p as RegExpMatchArray)[0].includes('data-cd-editable')).toBe(false);
-  });
-});

package/apps/studio/test/edit-css-occurrence.test.ts

@@ -1,81 +0,0 @@
-// canvas-edit.ts — Stage H3 (feature-element-editing-robustness). A whole-
-// component-instance move/resize passes a DOM-occurrence index into edit-css so
-// `applyEdit` routes the write to that instance's `<Component/>` USAGE (local to
-// the dragged instance) instead of the shared inner definition (global). The knob
-// / paste-style paths pass NO occurrence, so inner-shared-element styling stays
-// global-and-labeled — the H2 badge is the answer there (the chosen model).
-// Positional ids are round-tripped through transpileCanvasSource like the sibling
-// structural test, so the arithmetic stays in lockstep with the pipeline.
-
-import { describe, expect, test } from 'bun:test';
-
-import { applyEdit } from '../canvas-edit.ts';
-import { transpileCanvasSource } from '../canvas-pipeline.ts';
-
-const CANVAS = '/abs/Canvas.tsx';
-
-/** Map data-cd-id by element-type name (first occurrence), like canvas-edit.test.ts. */
-function idsOf(source: string): Record<string, string> {
-  const { withIds } = transpileCanvasSource(CANVAS, source);
-  const out: Record<string, string> = {};
-  for (const m of withIds.matchAll(/<(\w+)([^>]*?)data-cd-id="([0-9a-f]{8})"/g)) {
-    if (!out[m[1] as string]) out[m[1] as string] = m[3] as string;
-  }
-  return out;
-}
-
-const SHARED = [
-  'function Card() { return <article>card</article>; }',
-  'function Demo() {',
-  '  return (',
-  '    <section>',
-  '      <Card />',
-  '      <Card />',
-  '      <Card />',
-  '    </section>',
-  '  );',
-  '}',
-].join('\n');
-
-describe('canvas-edit / applyEdit — Stage H3 occurrence routing', () => {
-  test('with an occurrence, a style edit routes to that <Component/> usage (local)', () => {
-    // The inner <article> id is shared across all three <Card/> usages.
-    const innerId = idsOf(SHARED).article as string;
-    const out = applyEdit(CANVAS, SHARED, innerId, 'style.left', '"40px"', 1); // 2nd instance
-    // The 2nd (index 1) <Card/> usage gains the inline style; the shared inner
-    // <article> definition is untouched, so the other two instances don't move.
-    expect(out.source).toContain('<Card style={{ left: "40px" }}');
-    expect(out.source.match(/<Card \/>/g)?.length).toBe(2);
-    expect(out.source).toContain('<article>card</article>');
-  });
-
-  test('without an occurrence, the same edit stays on the shared inner element (global)', () => {
-    const innerId = idsOf(SHARED).article as string;
-    const out = applyEdit(CANVAS, SHARED, innerId, 'style.left', '"40px"');
-    // No occurrence → knob / paste-style behavior: the write lands on the inner
-    // <article>, changing every rendered instance (the "inner styling is global"
-    // model the H2 badge labels).
-    expect(out.source).toContain('<article style={{ left: "40px" }}>card</article>');
-    expect(out.source).not.toContain('<Card style=');
-  });
-
-  test('a normal (non-instance) element ignores the occurrence (no-op remap)', () => {
-    const src = 'function Demo() { return <div>x</div>; }';
-    const id = idsOf(src).div as string;
-    const out = applyEdit(CANVAS, src, id, 'style.padding', '14', 3);
-    expect(out.source).toContain('<div style={{ padding: 14 }}>x</div>');
-  });
-
-  test('an element in a single-usage component ignores the occurrence (not splittable)', () => {
-    const src = [
-      'function Card() { return <article>card</article>; }',
-      'function Demo() { return <section><Card /></section>; }',
-    ].join('\n');
-    const innerId = idsOf(src).article as string;
-    // One usage → resolveUsageId returns the inner id (can't split) — the edit
-    // lands on <article>, never fabricates a phantom usage index.
-    const out = applyEdit(CANVAS, src, innerId, 'style.left', '"40px"', 0);
-    expect(out.source).toContain('<article style={{ left: "40px" }}>card</article>');
-    expect(out.source).not.toContain('<Card style=');
-  });
-});

package/apps/studio/test/edit-persistence.test.ts

@@ -1,91 +0,0 @@
-// edit-persistence — DDR-148 dogfood. A CSS edit on a video-comp element must
-// survive into the RENDERED module, not just the optimistic DOM overlay — i.e.
-// source edit → build → the new value is in the compiled canvas the Player runs.
-// This end-to-end guard would have caught the original "my color reverts when
-// the video replays" bug (a trailing-comma insert produced `opacity: o, , color`
-// → the build FAILED → the Player kept rendering the OLD source).
-
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildCanvasModule } from '../canvas-build.ts';
-import { applyEdit } from '../canvas-edit.ts';
-import { transpileCanvasSource } from '../canvas-pipeline.ts';
-
-const CANVAS = '/tmp/edit-persist.tsx';
-
-/** buildCanvasModule needs the entrypoint on disk — write the source, then build. */
-async function buildAt(source: string) {
-  const dir = mkdtempSync(join(tmpdir(), 'edit-persist-'));
-  const abs = join(dir, 'Comp.tsx');
-  writeFileSync(abs, source);
-  return buildCanvasModule(abs, source);
-}
-
-// A frame-driven letter span (the exact shape from the intro demo): computed
-// transform/opacity + a trailing comma on the last property.
-const COMP = `import { AbsoluteFill, interpolate, useCurrentFrame } from 'remotion';
-export default function Comp() {
-  const frame = useCurrentFrame();
-  const y = interpolate(frame, [0, 20], [40, 0]);
-  const o = interpolate(frame, [0, 20], [0, 1]);
-  return (
-    <AbsoluteFill>
-      <span
-        style={{
-          fontSize: 132,
-          fontWeight: 800,
-          transform: \`translateY(\${y}px)\`,
-          opacity: o,
-          color: '#f0ece5',
-        }}
-      >
-        maude
-      </span>
-    </AbsoluteFill>
-  );
-}
-`;
-
-function spanId(source: string): string {
-  const { withIds } = transpileCanvasSource(CANVAS, source);
-  const m = withIds.match(/<span[^>]*?data-cd-id="([0-9a-f]{8})"/);
-  if (!m) throw new Error('no span id');
-  return m[1] as string;
-}
-
-describe('edit-persistence — a CSS edit survives into the built module', () => {
-  test('SWAP an existing color → the new color is in the compiled canvas', async () => {
-    const id = spanId(COMP);
-    const edited = applyEdit(CANVAS, COMP, id, 'style.color', "'#ff0000'").source;
-    expect(edited).toContain("color: '#ff0000'");
-    // The value the Player actually renders is the BUILT module — assert it there.
-    const built = await buildAt(edited);
-    expect(built.js).toContain('#ff0000');
-    expect(built.js).not.toContain('#f0ece5'); // old value fully replaced
-  });
-
-  test('INSERT a new prop next to a TRAILING comma → still builds + renders (the bug)', async () => {
-    const id = spanId(COMP);
-    // Insert a brand-new property where the last one (color) ends with a comma.
-    const edited = applyEdit(CANVAS, COMP, id, 'style.letterSpacing', "'-0.04em'").source;
-    expect(edited).not.toMatch(/,\s*,/); // NO double comma (the crash that reverted the render)
-    const built = await buildAt(edited); // must not throw
-    expect(built.js).toContain('-0.04em');
-    expect(built.js).toContain('#f0ece5'); // untouched props survive
-  });
-
-  test('a SEQUENCE of edits all persist (no edit clobbers a prior one)', async () => {
-    let src = COMP;
-    const id = spanId(src);
-    src = applyEdit(CANVAS, src, id, 'style.color', "'#00ff00'").source;
-    src = applyEdit(CANVAS, src, id, 'style.fontWeight', '900').source;
-    src = applyEdit(CANVAS, src, id, 'style.fontSize', '148').source;
-    const built = await buildAt(src);
-    expect(built.js).toContain('#00ff00');
-    expect(built.js).toContain('148');
-    // the frame-driven values must still be present (edits never touched them)
-    expect(built.js).toContain('translateY');
-  });
-});

package/apps/studio/test/edit-scope-api.test.ts

@@ -1,119 +0,0 @@
-// GET /_api/edit-scope — the INV-3 local-vs-shared predictability verdict
-// (feature-element-editing-robustness Stage H). Boots a real server, serves a
-// canvas with a `Card` component reused 3×, then asserts:
-//   • an element INSIDE the reused component → scope 'shared', affects 3
-//   • a top-level artboard element → scope 'local'
-//   • the `.map()` caveat (DDR-139) — a local element rendered N× (client-
-//     supplied `rendered`) → scope 'shared', reason 'mapped'
-//   • the route is main-origin only (proven separately in canvas-origin-gate).
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-const CANVAS_SRC = `const Card = ({ title }) => (
-  <div className="card">
-    <h3>{title}</h3>
-  </div>
-);
-
-export default function Gallery() {
-  return (
-    <DesignCanvas>
-      <DCArtboard id="home" label="Home" width={1440} height={1024}>
-        <section className="grid">
-          <Card title="A" />
-          <Card title="B" />
-          <Card title="C" />
-        </section>
-      </DCArtboard>
-    </DesignCanvas>
-  );
-}
-`;
-
-interface LocEntry {
-  line: number;
-  jsxPath: string[];
-  componentName: string;
-}
-
-async function boot() {
-  const { root, designRoot } = makeSandbox();
-  mkdirSync(join(designRoot, 'ui'), { recursive: true });
-  writeFileSync(join(designRoot, 'ui', 'Gallery.tsx'), CANVAS_SRC);
-  const port = nextPort();
-  const proc = await bootServer(root, port);
-  return { designRoot, main: `http://localhost:${port}`, proc };
-}
-
-/** Warm the pipeline (stamps cd-ids + writes _locator.json), return the map. */
-async function locatorMap(main: string, designRoot: string): Promise<Record<string, LocEntry>> {
-  const r = await fetch(`${main}/.design/ui/Gallery.tsx`, { signal: AbortSignal.timeout(2000) });
-  expect(r.status).toBe(200);
-  const locator = JSON.parse(readFileSync(join(designRoot, '_locator.json'), 'utf8'));
-  return locator['ui/Gallery'] as Record<string, LocEntry>;
-}
-
-function findId(map: Record<string, LocEntry>, pred: (e: LocEntry) => boolean): string {
-  const hit = Object.entries(map).find(([, e]) => pred(e));
-  if (!hit) throw new Error('no matching locator entry');
-  return hit[0];
-}
-
-async function scope(main: string, id: string, rendered?: number) {
-  const q = new URLSearchParams({ canvas: 'ui/Gallery', id });
-  if (rendered != null) q.set('rendered', String(rendered));
-  const res = await fetch(`${main}/_api/edit-scope?${q}`, { signal: AbortSignal.timeout(2000) });
-  return { status: res.status, body: (await res.json()) as Record<string, unknown> };
-}
-
-describe('GET /_api/edit-scope', () => {
-  test('reports shared for a reused-component inner element, local for a top-level one', async () => {
-    const { designRoot, main, proc } = await boot();
-    try {
-      const map = await locatorMap(main, designRoot);
-
-      // An element inside the reused `Card` component (componentName === 'Card').
-      const innerId = findId(map, (e) => e.componentName === 'Card');
-      const shared = await scope(main, innerId);
-      expect(shared.status).toBe(200);
-      expect(shared.body.scope).toBe('shared');
-      expect(shared.body.componentName).toBe('Card');
-      expect(shared.body.affects).toBe(3);
-      expect(shared.body.reason).toBe('component');
-
-      // A top-level artboard element (the <section>) — not inside a reused comp.
-      const topId = findId(
-        map,
-        (e) => e.componentName !== 'Card' && e.jsxPath[e.jsxPath.length - 1] === 'section'
-      );
-      const local = await scope(main, topId);
-      expect(local.status).toBe(200);
-      expect(local.body.scope).toBe('local');
-      expect(local.body.affects).toBe(1);
-      expect(local.body.reason).toBe('single');
-
-      // The .map() caveat (DDR-139): a local element the client says renders N×
-      // is 'shared' ('mapped') even though its source usage count is 1.
-      const mapped = await scope(main, topId, 4);
-      expect(mapped.body.scope).toBe('shared');
-      expect(mapped.body.reason).toBe('mapped');
-      expect(mapped.body.affects).toBe(4);
-
-      // A bogus id is a 400 (invalid data-cd-id shape). Note: since the
-      // authored-id widening (feature-4, 2026-07-20) short word-ids like "zzz"
-      // are VALID shapes (hand-authored data-cd-id attrs are preserved by the
-      // pipeline) — only genuinely malformed values (spaces, slashes) fail.
-      const bad = await fetch(
-        `${main}/_api/edit-scope?canvas=ui/Gallery&id=${encodeURIComponent('../etc/passwd')}`,
-        { signal: AbortSignal.timeout(2000) }
-      );
-      expect(bad.status).toBe(400);
-    } finally {
-      await killProc(proc as never);
-    }
-  });
-});

package/apps/studio/test/edit-source-command.test.ts

@@ -1,142 +0,0 @@
-import { beforeAll, describe, expect, mock, test } from 'bun:test';
-
-import {
-  buildEditSourceRecord,
-  createEditSourceCommand,
-  EDIT_SOURCE_KIND,
-  type EditSourceApplyFn,
-  type EditSourcePayload,
-} from '../commands/edit-source-command.ts';
-import { type CommandSinks, rebuildCommand, registerCommand } from '../undo-stack.ts';
-
-const cssEdit: EditSourcePayload = {
-  op: 'css',
-  canvas: '.design/ui/Foo.tsx',
-  id: 'cd-1',
-  key: 'color',
-  before: 'red',
-  after: 'blue',
-};
-
-describe('createEditSourceCommand', () => {
-  test('do() applies the AFTER value', async () => {
-    const applyFn = mock(() => {});
-    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
-    await cmd.do();
-    expect(applyFn).toHaveBeenCalledTimes(1);
-    expect(applyFn.mock.calls[0]?.[0]).toEqual({
-      op: 'css',
-      canvas: '.design/ui/Foo.tsx',
-      id: 'cd-1',
-      key: 'color',
-      value: 'blue',
-      // do() writes `after` over `before`, so `from` = before; css has no occurrence.
-      from: 'red',
-      occurrence: undefined,
-    });
-  });
-
-  test('do()/undo() carry occurrence + from for a text edit (variable re-target)', async () => {
-    const applyFn = mock(() => {});
-    const textEdit: EditSourcePayload = {
-      op: 'text',
-      canvas: '.design/ui/Foo.tsx',
-      id: 'cd-9',
-      key: '',
-      before: 'Old',
-      after: 'New',
-      occurrence: 2,
-    };
-    const cmd = createEditSourceCommand({ payload: textEdit, applyFn });
-    await cmd.do();
-    // redo/do: write New over Old → from = Old.
-    expect(applyFn.mock.calls[0]?.[0]).toMatchObject({ value: 'New', from: 'Old', occurrence: 2 });
-    await cmd.undo();
-    // undo: write Old over New → from = New.
-    expect(applyFn.mock.calls[1]?.[0]).toMatchObject({ value: 'Old', from: 'New', occurrence: 2 });
-  });
-
-  test('undo() applies the BEFORE value', async () => {
-    const applyFn = mock(() => {});
-    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
-    await cmd.undo();
-    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('red');
-  });
-
-  test('undo() of a NEW prop (before:null) applies null = reset', async () => {
-    const applyFn = mock(() => {});
-    const cmd = createEditSourceCommand({
-      payload: { ...cssEdit, before: null, after: 'blue' },
-      applyFn,
-    });
-    await cmd.undo();
-    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
-  });
-
-  test('do() of a RESET (after:null) applies null = remove the prop', async () => {
-    const applyFn = mock(() => {});
-    const cmd = createEditSourceCommand({
-      payload: { ...cssEdit, before: 'red', after: null },
-      applyFn,
-    });
-    await cmd.do();
-    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
-  });
-
-  test('label reflects op + key', () => {
-    expect(createEditSourceCommand({ payload: cssEdit, applyFn: () => {} }).label).toBe(
-      'edit color'
-    );
-    expect(
-      createEditSourceCommand({ payload: { ...cssEdit, after: null }, applyFn: () => {} }).label
-    ).toBe('reset color');
-    expect(
-      createEditSourceCommand({
-        payload: { op: 'attr', canvas: 'x', id: 'y', key: 'data-x', before: null, after: '1' },
-        applyFn: () => {},
-      }).label
-    ).toBe('edit @data-x');
-    expect(
-      createEditSourceCommand({
-        payload: { op: 'text', canvas: 'x', id: 'y', key: '', before: 'a', after: 'b' },
-        applyFn: () => {},
-      }).label
-    ).toBe('edit text');
-  });
-});
-
-describe('buildEditSourceRecord', () => {
-  test('produces a serializable record under the edit-source kind', () => {
-    const rec = buildEditSourceRecord(cssEdit);
-    expect(rec.kind).toBe(EDIT_SOURCE_KIND);
-    expect(rec.payload).toEqual(cssEdit);
-    expect(JSON.parse(JSON.stringify(rec))).toEqual(rec); // round-trips
-  });
-});
-
-describe('edit-source registry', () => {
-  // The module self-registers on import, but sibling test files wipe the shared
-  // builder registry in their beforeEach — re-register here so this block is
-  // order-independent. Mirrors the real registration in edit-source-command.ts.
-  beforeAll(() => {
-    registerCommand<EditSourcePayload>(EDIT_SOURCE_KIND, (record, sinks) => {
-      const applyFn = sinks.editSourceApplyFn as EditSourceApplyFn | undefined;
-      if (!applyFn) return null;
-      return createEditSourceCommand({ payload: record.payload, applyFn, label: record.label });
-    });
-  });
-
-  test('rebuildCommand returns null when the editSourceApplyFn sink is unbound', () => {
-    expect(rebuildCommand(buildEditSourceRecord(cssEdit), {} as CommandSinks)).toBeNull();
-  });
-
-  test('rebuildCommand wires the bound sink into a runnable command', async () => {
-    const applyFn = mock(() => {});
-    const cmd = rebuildCommand(buildEditSourceRecord(cssEdit), {
-      editSourceApplyFn: applyFn,
-    } as CommandSinks);
-    expect(cmd).not.toBeNull();
-    await cmd?.do();
-    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('blue');
-  });
-});