@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/canvas-lib-resolver.test.ts

@@ -1,111 +0,0 @@
-// canvas-lib-resolver — virtual specifier `@maude/canvas-lib` → the dev-server-
-// bundled canvas-lib (Phase 3.6.1 Task 2; relocated to dev-server in Phase
-// 4.0.5 per DDR-025).
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { existsSync } from 'node:fs';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-
-import { buildCanvasModule } from '../canvas-build.ts';
-import {
-  CANVAS_LIB_SPECIFIER,
-  canvasLibPath,
-  readCanvasLibSource,
-} from '../canvas-lib-resolver.ts';
-
-const TMP = `/tmp/canvas-lib-resolver-${Math.random().toString(36).slice(2, 8)}`;
-const DESIGN_ROOT = path.join(TMP, 'designRoot');
-
-beforeAll(async () => {
-  await mkdir(DESIGN_ROOT, { recursive: true });
-});
-
-afterAll(async () => {
-  await rm(TMP, { recursive: true, force: true });
-});
-
-describe('canvas-lib-resolver / canvasLibPath', () => {
-  test('returns the dev-server-internal canvas-lib.tsx path', () => {
-    const p = canvasLibPath();
-    expect(p.endsWith('apps/studio/canvas-lib.tsx')).toBe(true);
-    expect(existsSync(p)).toBe(true);
-  });
-
-  test('ignores the legacy designRoot argument (back-compat shim)', () => {
-    expect(canvasLibPath('/foo/bar')).toBe(canvasLibPath());
-  });
-
-  test('CANVAS_LIB_SPECIFIER is `@maude/canvas-lib`', () => {
-    expect(CANVAS_LIB_SPECIFIER).toBe('@maude/canvas-lib');
-  });
-});
-
-describe('canvas-lib-resolver / canvasLibResolver plugin', () => {
-  test('resolves @maude/canvas-lib through Bun.build', async () => {
-    const canvasPath = path.join(DESIGN_ROOT, 'ui', 'Resolves.tsx');
-    await mkdir(path.dirname(canvasPath), { recursive: true });
-    const canvasSource =
-      `import { DesignCanvas, DCArtboard } from "@maude/canvas-lib";\n` +
-      'export default function Demo() {\n' +
-      '  return <DesignCanvas><DCArtboard>hi</DCArtboard></DesignCanvas>;\n' +
-      '}\n';
-    await writeFile(canvasPath, canvasSource);
-    const r = await buildCanvasModule(canvasPath, canvasSource, {
-      designRoot: DESIGN_ROOT,
-    });
-    // The bundled output should contain the resolved lib's function bodies.
-    expect(r.js).toContain('dc-canvas');
-    expect(r.js).toContain('dc-artboard');
-    // The bare specifier should NOT survive as an import.
-    expect(r.js).not.toMatch(/from\s*["']@maude\/canvas-lib["']/);
-  });
-
-  test('does not interfere with canvases that never import the lib', async () => {
-    const canvasPath = path.join(DESIGN_ROOT, 'ui', 'PlainNoLib.tsx');
-    await mkdir(path.dirname(canvasPath), { recursive: true });
-    const canvasSource = 'export default function Y() { return <button>hi</button>; }\n';
-    await writeFile(canvasPath, canvasSource);
-    const r = await buildCanvasModule(canvasPath, canvasSource, {
-      designRoot: DESIGN_ROOT,
-    });
-    expect(r.js).toContain('button');
-  });
-});
-
-describe('canvas-lib-resolver / readCanvasLibSource', () => {
-  test('reads the dev-server-bundled lib source', async () => {
-    const src = await readCanvasLibSource();
-    // Real bundled lib — assert a stable export name shows up.
-    expect(src).toContain('DesignCanvas');
-  });
-
-  test('ignores the legacy designRoot argument', async () => {
-    const src = await readCanvasLibSource('/non-existent-design-root');
-    expect(src).toContain('DesignCanvas');
-  });
-});
-
-describe('canvas-lib-resolver / legacy deprecation guard', () => {
-  test('legacy <designRoot>/_lib/canvas-lib.tsx is ignored — dev-server bundled lib wins', async () => {
-    const projRoot = path.join(TMP, 'legacy-project');
-    const legacyLibDir = path.join(projRoot, '_lib');
-    await mkdir(legacyLibDir, { recursive: true });
-    // Plant a syntactically-bogus legacy file. If the resolver were still
-    // reading from `<designRoot>/_lib/canvas-lib.tsx` this would explode at
-    // bundle time; with the dev-server-bundled lib it must be a no-op.
-    await writeFile(
-      path.join(legacyLibDir, 'canvas-lib.tsx'),
-      '// LEGACY — should be ignored\nexport const SHOULD_NOT_APPEAR = true;\n'
-    );
-    const canvasPath = path.join(projRoot, 'ui', 'Legacy.tsx');
-    await mkdir(path.dirname(canvasPath), { recursive: true });
-    const canvasSource =
-      `import { DesignCanvas } from "@maude/canvas-lib";\n` +
-      'export default function L() { return <DesignCanvas>hi</DesignCanvas>; }\n';
-    await writeFile(canvasPath, canvasSource);
-    const r = await buildCanvasModule(canvasPath, canvasSource, { designRoot: projRoot });
-    expect(r.js).toContain('dc-canvas');
-    expect(r.js).not.toContain('SHOULD_NOT_APPEAR');
-  });
-});

package/apps/studio/test/canvas-list-watch.test.ts

@@ -1,388 +0,0 @@
-// canvas-list-watch — external-canvas list watcher. Emits `canvas-list-update`
-// when a canvas file appears/disappears on disk from OUTSIDE the dev-server
-// (the ACP agent's `/design:new`, agent Write, git checkout), so the browser
-// file tree refreshes without a reload.
-// RCA: .ai/logs/rca/issue-acp-new-canvas-not-in-filetree.md
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  CANVAS_LIST_DEBOUNCE_MS,
-  createCanvasListWatch,
-  isCanvasCandidate,
-} from '../canvas-list-watch.ts';
-import { type Context, createBus } from '../context.ts';
-import { createFsWatch } from '../fs-watch.ts';
-
-const GROUPS = [
-  { label: 'System', path: 'system' },
-  { label: 'UI', path: 'ui' },
-];
-
-function sandbox(): { root: string; designRoot: string } {
-  const root = mkdtempSync(join(tmpdir(), 'clw-test-'));
-  const designRoot = join(root, '.design');
-  mkdirSync(join(designRoot, 'ui'), { recursive: true });
-  return { root, designRoot };
-}
-
-function mkCtx(designRoot: string): Context {
-  return {
-    cfg: { canvasGroups: GROUPS } as Context['cfg'],
-    projectLabel: '',
-    paths: { designRoot, designRel: '.design' } as Context['paths'],
-    bus: createBus(),
-  };
-}
-
-const TSX = 'export default function C(){return null}';
-
-interface Update {
-  action?: string;
-  rel?: string;
-  slug?: string;
-}
-
-function collect(ctx: Context): Update[] {
-  const got: Update[] = [];
-  ctx.bus.on('canvas-list-update', (p) => got.push(p as Update));
-  return got;
-}
-
-describe('canvas-list-watch / isCanvasCandidate (pure gate)', () => {
-  const groups = ['system', 'ui'];
-  test('accepts openable canvases under a configured group', () => {
-    expect(isCanvasCandidate('ui/Pricing.tsx', groups)).toBe(true);
-    expect(isCanvasCandidate('ui/project/Pricing.tsx', groups)).toBe(true);
-    expect(isCanvasCandidate('ui/Smoke.html', groups)).toBe(true);
-    // DS preview specimens DO show in the tree, so they must trigger a refresh.
-    expect(isCanvasCandidate('system/project/preview/colors.tsx', groups)).toBe(true);
-  });
-
-  test('rejects non-canvas extensions (sidecars, tokens, docs)', () => {
-    expect(isCanvasCandidate('ui/Pricing.meta.json', groups)).toBe(false);
-    expect(isCanvasCandidate('ui/Pricing.css', groups)).toBe(false);
-    expect(isCanvasCandidate('system/project/README.md', groups)).toBe(false);
-  });
-
-  test('rejects runtime-state (`_`-prefixed segment) + SKIP_DIRS', () => {
-    expect(isCanvasCandidate('_history/ui-x/00-screen.tsx', groups)).toBe(false);
-    expect(isCanvasCandidate('ui/_draft.tsx', groups)).toBe(false);
-    expect(isCanvasCandidate('_active.json', groups)).toBe(false);
-    expect(isCanvasCandidate('node_modules/pkg/index.tsx', groups)).toBe(false);
-  });
-
-  // Renaming or moving a folder from Finder / `mv` / a `git checkout` names the
-  // DIRECTORY, and that event used to be dropped here — so the tree kept showing
-  // the old folder and every canvas inside it silently stopped syncing (its
-  // descriptor pointed at a path that no longer existed) until an unrelated
-  // `.tsx` write happened to nudge the same recompute.
-  test('accepts a directory under a group — a folder rename is a list change', () => {
-    expect(isCanvasCandidate('ui/dbox2', groups)).toBe(true);
-    expect(isCanvasCandidate('ui/2026/social', groups)).toBe(true);
-    expect(isCanvasCandidate('system', groups)).toBe(true);
-  });
-
-  test('a directory still obeys every other rule', () => {
-    expect(isCanvasCandidate('ui/_drafts', groups)).toBe(false);
-    expect(isCanvasCandidate('node_modules/pkg', groups)).toBe(false);
-    expect(isCanvasCandidate('docs/whatever', groups)).toBe(false);
-  });
-
-  test('rejects canvases outside any configured group', () => {
-    expect(isCanvasCandidate('docs/Thing.tsx', groups)).toBe(false);
-    expect(isCanvasCandidate('Thing.tsx', groups)).toBe(false);
-  });
-
-  test('non-string / empty input is rejected, not thrown', () => {
-    expect(isCanvasCandidate('', groups)).toBe(false);
-    expect(isCanvasCandidate(undefined as unknown as string, groups)).toBe(false);
-  });
-});
-
-describe('canvas-list-watch / diff + emit', () => {
-  test('seeding existing canvases emits nothing', async () => {
-    const { root, designRoot } = sandbox();
-    writeFileSync(join(designRoot, 'ui', 'Existing.tsx'), TSX);
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      expect(got).toHaveLength(0);
-      expect(w.known.has('.design/ui/Existing.tsx')).toBe(true);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a canvas written straight to disk emits action:added (the bug)', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      // Simulate `/design:new` writing the canvas (and its sidecar) directly —
-      // NO API call, so api.ts never emits.
-      writeFileSync(join(designRoot, 'ui', 'Pricing.tsx'), TSX);
-      writeFileSync(join(designRoot, 'ui', 'Pricing.meta.json'), '{}');
-      await w.refresh();
-      expect(got).toHaveLength(1);
-      expect(got[0]?.action).toBe('added');
-      expect(got[0]?.slug).toBe('ui-pricing');
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('deleting a canvas on disk emits action:removed', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      const abs = join(designRoot, 'ui', 'Gone.tsx');
-      writeFileSync(abs, TSX);
-      await w.refresh();
-      got.length = 0; // drop the 'added'
-      rmSync(abs);
-      await w.refresh();
-      expect(got).toHaveLength(1);
-      expect(got[0]?.action).toBe('removed');
-      expect(got[0]?.slug).toBe('ui-gone');
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('editing an existing canvas body emits nothing (no tree thrash)', async () => {
-    const { root, designRoot } = sandbox();
-    const abs = join(designRoot, 'ui', 'Edited.tsx');
-    writeFileSync(abs, TSX);
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      writeFileSync(abs, `${TSX}\n// edited`);
-      writeFileSync(join(designRoot, 'ui', 'Edited.meta.json'), '{"x":1}');
-      await w.refresh();
-      expect(got).toHaveLength(0);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('runtime-state + sidecar writes never emit', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      writeFileSync(join(designRoot, '_active.json'), '{}');
-      mkdirSync(join(designRoot, '_canvas-state'), { recursive: true });
-      writeFileSync(join(designRoot, '_canvas-state', 'ui-x.view.json'), '{}');
-      writeFileSync(join(designRoot, 'config.json'), '{}');
-      await w.refresh();
-      expect(got).toHaveLength(0);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('canvas-list-watch / live fs:any path', () => {
-  test('a candidate fs:any event schedules a debounced refresh that emits', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 20 });
-    await w.ready;
-    try {
-      writeFileSync(join(designRoot, 'ui', 'Live.tsx'), TSX);
-      // The fs-watch would emit this; assert the subscriber wires through.
-      ctx.bus.emit('fs:any', 'ui/Live.tsx');
-      await new Promise((r) => setTimeout(r, 20 + 80));
-      await w.refresh(); // flush the chain
-      const added = got.find((m) => m.action === 'added' && m.slug === 'ui-live');
-      expect(added).toBeTruthy();
-      // Exactly one 'added' — the timer + the explicit flush must not double-emit.
-      expect(got.filter((m) => m.action === 'added' && m.slug === 'ui-live')).toHaveLength(1);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('a non-candidate fs:any event does not schedule a refresh', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 20 });
-    await w.ready;
-    try {
-      // Create a canvas but only announce a NON-candidate path. The gate must
-      // skip the recompute, so the new canvas stays unseen until a real event.
-      writeFileSync(join(designRoot, 'ui', 'Sneaky.tsx'), TSX);
-      ctx.bus.emit('fs:any', 'ui/Sneaky.meta.json');
-      ctx.bus.emit('fs:any', '_active.json');
-      await new Promise((r) => setTimeout(r, 20 + 80));
-      expect(got).toHaveLength(0);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('stop() unsubscribes — later events are ignored', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    w.stop();
-    try {
-      writeFileSync(join(designRoot, 'ui', 'After.tsx'), TSX);
-      ctx.bus.emit('fs:any', 'ui/After.tsx');
-      await new Promise((r) => setTimeout(r, CANVAS_LIST_DEBOUNCE_MS + 40));
-      expect(got).toHaveLength(0);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('canvas-list-watch / serialization + multi-remove', () => {
-  test('overlapping refresh() calls serialize — a create between them emits exactly once', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      writeFileSync(join(designRoot, 'ui', 'Pair.tsx'), TSX);
-      // Fire two refreshes WITHOUT awaiting the first. The promise-chain must
-      // serialize them: the first diffs the create against the pre-create set
-      // and updates `known`; the second sees no change. Without the chain both
-      // would snapshot concurrently against the stale `known` and emit twice.
-      const a = w.refresh();
-      const b = w.refresh();
-      await Promise.all([a, b]);
-      expect(got.filter((m) => m.action === 'added' && m.slug === 'ui-pair')).toHaveLength(1);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('removing a whole group subdir emits one removed per canvas (git-checkout shape)', async () => {
-    const { root, designRoot } = sandbox();
-    mkdirSync(join(designRoot, 'ui', 'project'), { recursive: true });
-    writeFileSync(join(designRoot, 'ui', 'project', 'A.tsx'), TSX);
-    writeFileSync(join(designRoot, 'ui', 'project', 'B.tsx'), TSX);
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      rmSync(join(designRoot, 'ui', 'project'), { recursive: true, force: true });
-      await w.refresh();
-      const removed = got.filter((m) => m.action === 'removed').map((m) => m.slug);
-      expect(removed.sort()).toEqual(['ui-project-a', 'ui-project-b']);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('canvas-list-watch / real fs-watch end-to-end', () => {
-  test('a raw disk write through createFsWatch emits added (the actual bug path)', async () => {
-    const { root, designRoot } = sandbox();
-    const ctx = mkCtx(designRoot);
-    const got = collect(ctx);
-    const fsWatch = createFsWatch(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 30 });
-    await w.ready;
-    fsWatch.start();
-    try {
-      // Let the OS watcher arm, then write straight to disk — NO manual bus
-      // emit. This exercises the genuine ACP-agent path: disk write →
-      // fs.watch → fs:any → gate → debounce → snapshot diff → canvas-list-update.
-      await new Promise((r) => setTimeout(r, 60));
-      writeFileSync(join(designRoot, 'ui', 'Real.tsx'), TSX);
-      const deadline = Date.now() + 3000;
-      while (
-        Date.now() < deadline &&
-        !got.some((m) => m.action === 'added' && m.slug === 'ui-real')
-      ) {
-        await new Promise((r) => setTimeout(r, 50));
-      }
-      expect(got.some((m) => m.action === 'added' && m.slug === 'ui-real')).toBe(true);
-    } finally {
-      fsWatch.stop();
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  }, 10_000);
-});
-
-describe('canvas-list-watch / config hot-reload (stale-config RCA)', () => {
-  // /design:setup-ds adds the `system` group to config.json mid-session;
-  // reloadConfig (context.ts) swaps ctx.cfg in place. The watcher must read
-  // groups at USE time — a boot-captured groupPaths list would keep gating
-  // the new group's files out forever.
-  // RCA: .ai/logs/rca/issue-ds-scaffold-files-not-in-filetree-stale-config.md
-  test('a group added by an in-place cfg swap uncovers its canvases', async () => {
-    const { root, designRoot } = sandbox();
-    mkdirSync(join(designRoot, 'system', 'kanban-glass', 'preview'), { recursive: true });
-    const ctx = mkCtx(designRoot);
-    // Pre-scaffold fixture shape: UI-only group.
-    ctx.cfg.canvasGroups = [{ label: 'UI', path: 'ui' }];
-    const got = collect(ctx);
-    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
-    await w.ready;
-    try {
-      // Scaffold writes specimens while the group is still absent — no emit.
-      writeFileSync(join(designRoot, 'system', 'kanban-glass', 'preview', 'colors.tsx'), TSX);
-      ctx.bus.emit('fs:any', 'system/kanban-glass/preview/colors.tsx');
-      await new Promise((r) => setTimeout(r, 10 + 40));
-      await w.refresh();
-      expect(got).toHaveLength(0);
-
-      // Hot reload: new array on the SAME cfg object (what reloadConfig does),
-      // then the server.ts subscriber calls refresh() — the diff must surface
-      // the pre-existing specimen.
-      ctx.cfg.canvasGroups = [
-        { label: 'Design system', path: 'system' },
-        { label: 'UI', path: 'ui' },
-      ];
-      await w.refresh();
-      expect(got).toHaveLength(1);
-      expect(got[0]?.action).toBe('added');
-      expect(got[0]?.rel).toBe('system/kanban-glass/preview/colors.tsx');
-
-      // And FUTURE writes under the new group pass the live fs:any gate.
-      got.length = 0;
-      writeFileSync(join(designRoot, 'system', 'kanban-glass', 'preview', 'type.tsx'), TSX);
-      ctx.bus.emit('fs:any', 'system/kanban-glass/preview/type.tsx');
-      await new Promise((r) => setTimeout(r, 10 + 40));
-      await w.refresh();
-      expect(got.some((m) => m.action === 'added' && m.rel?.endsWith('type.tsx'))).toBe(true);
-    } finally {
-      w.stop();
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});

package/apps/studio/test/canvas-media-drop.test.ts

@@ -1,187 +0,0 @@
-// use-canvas-media-drop — Phase 23 pure helpers (no DOM).
-//
-// Covers the drop/paste dispatch matrix + the URL helpers. The http(s) scheme
-// gate (isHttpUrl) is security-relevant — a link chip must never carry a
-// javascript:/data: URL into window.open.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  anchorTextFromHtml,
-  classifyMediaPayload,
-  firstHttpUrl,
-  isHttpUrl,
-  linkDomain,
-  type MediaPayload,
-  mediaSnippet,
-  normalizeUrl,
-  prettifyUrl,
-} from '../use-canvas-media-drop.tsx';
-
-const empty: MediaPayload = { files: [], uriList: '', html: '', plain: '' };
-const fakeFile = (type: string): File => ({ type, name: 'x', size: 1 }) as unknown as File;
-
-describe('use-canvas-media-drop / isHttpUrl (scheme gate)', () => {
-  test('accepts http + https only', () => {
-    expect(isHttpUrl('https://example.com')).toBe(true);
-    expect(isHttpUrl('http://example.com/a/b?c=1')).toBe(true);
-  });
-  test('rejects javascript: / data: / file: / mailto: / garbage', () => {
-    expect(isHttpUrl('javascript:alert(1)')).toBe(false);
-    expect(isHttpUrl('data:text/html,<script>')).toBe(false);
-    expect(isHttpUrl('file:///etc/passwd')).toBe(false);
-    expect(isHttpUrl('mailto:a@b.com')).toBe(false);
-    expect(isHttpUrl('not a url')).toBe(false);
-    expect(isHttpUrl('')).toBe(false);
-  });
-});
-
-describe('use-canvas-media-drop / normalizeUrl (no scheme required)', () => {
-  test('keeps an explicit http(s) URL', () => {
-    expect(normalizeUrl('https://example.com/x')).toBe('https://example.com/x');
-    expect(normalizeUrl('http://example.com')).toBe('http://example.com');
-  });
-  test('prepends https:// to a bare domain', () => {
-    expect(normalizeUrl('example.com')).toBe('https://example.com');
-    expect(normalizeUrl('www.example.com/blog/post?x=1')).toBe(
-      'https://www.example.com/blog/post?x=1'
-    );
-    expect(normalizeUrl('sub.example.io:8080/path')).toBe('https://sub.example.io:8080/path');
-  });
-  test('rejects dangerous schemes even though it is lenient about http(s)', () => {
-    expect(normalizeUrl('javascript:alert(1)')).toBeNull();
-    expect(normalizeUrl('data:text/html,x')).toBeNull();
-    expect(normalizeUrl('file:///etc/passwd')).toBeNull();
-    expect(normalizeUrl('mailto:a@b.com')).toBeNull();
-  });
-  test('does NOT mistake a bare decimal / non-domain for a URL', () => {
-    expect(normalizeUrl('3.5')).toBeNull();
-    expect(normalizeUrl('v1.2')).toBeNull();
-    expect(normalizeUrl('hello world')).toBeNull();
-    expect(normalizeUrl('')).toBeNull();
-  });
-});
-
-describe('use-canvas-media-drop / firstHttpUrl', () => {
-  test('a bare-domain line becomes an https URL (no scheme needed to paste)', () => {
-    expect(firstHttpUrl('example.com')).toBe('https://example.com');
-  });
-
-  test('skips uri-list comment lines and returns the first real URL', () => {
-    expect(firstHttpUrl('# a comment\nhttps://example.com/p\nhttps://other.com')).toBe(
-      'https://example.com/p'
-    );
-  });
-  test('finds an inline URL in a prose paste', () => {
-    expect(firstHttpUrl('see https://example.com/post for details')).toBe(
-      'https://example.com/post'
-    );
-  });
-  test('returns null for non-URL text', () => {
-    expect(firstHttpUrl('just some words')).toBeNull();
-    expect(firstHttpUrl('javascript:alert(1)')).toBeNull();
-  });
-});
-
-describe('use-canvas-media-drop / linkDomain + prettifyUrl', () => {
-  test('linkDomain strips www.', () => {
-    expect(linkDomain('https://www.example.com/x')).toBe('example.com');
-    expect(linkDomain('https://sub.example.io')).toBe('sub.example.io');
-  });
-  test('prettifyUrl yields host + path (no protocol, no trailing slash)', () => {
-    expect(prettifyUrl('https://www.example.com/blog/post/')).toBe('example.com/blog/post');
-    expect(prettifyUrl('https://example.com/')).toBe('example.com');
-  });
-});
-
-describe('use-canvas-media-drop / anchorTextFromHtml', () => {
-  test('extracts the anchor text from a text/html payload', () => {
-    expect(anchorTextFromHtml('<a href="https://x.io">Cool Post</a>')).toBe('Cool Post');
-  });
-  test('strips inner markup and collapses whitespace', () => {
-    expect(anchorTextFromHtml('<a href="#"><b>Bold</b>  title</a>')).toBe('Bold title');
-  });
-  test('returns null when there is no anchor', () => {
-    expect(anchorTextFromHtml('<div>no link</div>')).toBeNull();
-    expect(anchorTextFromHtml('')).toBeNull();
-  });
-});
-
-describe('use-canvas-media-drop / classifyMediaPayload (dispatch matrix)', () => {
-  test('an image file wins (even when a uri-list is also present)', () => {
-    const intent = classifyMediaPayload({
-      ...empty,
-      files: [fakeFile('image/png')],
-      uriList: 'https://example.com',
-    });
-    expect(intent?.kind).toBe('image');
-  });
-
-  test('a non-image, non-media file is ignored', () => {
-    expect(classifyMediaPayload({ ...empty, files: [fakeFile('application/pdf')] })).toBeNull();
-  });
-
-  test('a video file → a media intent (DDR-148)', () => {
-    const intent = classifyMediaPayload({ ...empty, files: [fakeFile('video/mp4')] });
-    expect(intent).toEqual({ kind: 'media', file: expect.anything(), mediaKind: 'video' });
-  });
-
-  test('an audio file → a media intent', () => {
-    const intent = classifyMediaPayload({ ...empty, files: [fakeFile('audio/mpeg')] });
-    expect(intent?.kind).toBe('media');
-    expect(intent && intent.kind === 'media' && intent.mediaKind).toBe('audio');
-  });
-
-  test('an image still wins over a co-dropped video', () => {
-    const intent = classifyMediaPayload({
-      ...empty,
-      files: [fakeFile('image/png'), fakeFile('video/mp4')],
-    });
-    expect(intent?.kind).toBe('image');
-  });
-
-  test('mediaSnippet emits the right Remotion element', () => {
-    expect(mediaSnippet('video', 'assets/ab12cd34.mp4')).toBe(
-      '<Video src="assets/ab12cd34.mp4" />'
-    );
-    expect(mediaSnippet('audio', 'assets/ff00aa11.mp3')).toBe(
-      '<Audio src="assets/ff00aa11.mp3" />'
-    );
-  });
-
-  test('a URL drop becomes a link with the anchor text as the title', () => {
-    const intent = classifyMediaPayload({
-      ...empty,
-      uriList: 'https://example.com/post',
-      html: '<a href="https://example.com/post">Read this</a>',
-    });
-    expect(intent).toEqual({ kind: 'link', url: 'https://example.com/post', title: 'Read this' });
-  });
-
-  test('a URL drop with no anchor text falls back to the prettified URL', () => {
-    const intent = classifyMediaPayload({ ...empty, uriList: 'https://example.com/post' });
-    expect(intent).toEqual({
-      kind: 'link',
-      url: 'https://example.com/post',
-      title: 'example.com/post',
-    });
-  });
-
-  test('a bare-domain paste (no scheme) becomes a link normalized to https', () => {
-    const intent = classifyMediaPayload({ ...empty, plain: 'example.com/post' });
-    expect(intent).toEqual({
-      kind: 'link',
-      url: 'https://example.com/post',
-      title: 'example.com/post',
-    });
-  });
-
-  test('a plain-text (non-media) paste classifies as null — caller leaves it alone', () => {
-    expect(classifyMediaPayload({ ...empty, plain: 'hello world' })).toBeNull();
-  });
-
-  test('a javascript: URL is never classified as a link', () => {
-    expect(classifyMediaPayload({ ...empty, plain: 'javascript:alert(1)' })).toBeNull();
-    expect(classifyMediaPayload({ ...empty, uriList: 'javascript:alert(1)' })).toBeNull();
-  });
-});