@1agh/maude 0.15.0 → 0.17.1

package/plugins/design/dev-server/test/comments-api.test.ts

@@ -0,0 +1,229 @@
+// Phase 6 — comments API extensions: author / thread / mentions schema,
+// POST /_api/comments/<id>/reply, GET /_api/git-committers.
+//
+// Verifies:
+//   - New comments include `author`, `thread`, `mentions`
+//   - parseMentions in `text` lands in `mentions[]`
+//   - POST .../reply appends to thread + folds reply mentions into the union
+//   - Legacy comments (no author/thread/mentions on disk) round-trip with
+//     defaults filled in memory; disk shape stays untouched until next write
+//   - GET /_api/git-committers returns the committer list (≥1 entry in a real
+//     git sandbox; gracefully empty if git fails)
+//   - Reply on unknown id → 404
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
+
+async function initGit(root: string) {
+  // Make the sandbox a tiny git repo so `git config user.name` + `git shortlog`
+  // can answer. The boot path doesn't need a real repo, but the gitCommitters /
+  // gitCurrentUser helpers do.
+  //
+  // GIT_CONFIG_GLOBAL=/dev/null + GIT_CONFIG_SYSTEM=/dev/null isolate the
+  // sandbox from the developer's global git config (which may require GPG
+  // signing, set a non-test identity, or otherwise interfere with the
+  // throwaway commit). This is repo isolation, not a sign-bypass on a real
+  // commit — the test never produces an artifact outside its temp dir.
+  const env = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_CONFIG_SYSTEM: '/dev/null',
+  };
+  await Bun.spawn(['git', 'init', '-q'], { cwd: root, env }).exited;
+  await Bun.spawn(['git', 'config', 'user.email', 'tester@example.com'], { cwd: root, env }).exited;
+  await Bun.spawn(['git', 'config', 'user.name', 'Test User'], { cwd: root, env }).exited;
+  writeFileSync(join(root, 'README.md'), '# sandbox\n');
+  await Bun.spawn(['git', 'add', '.'], { cwd: root, env }).exited;
+  await Bun.spawn(['git', 'commit', '-q', '-m', 'init'], { cwd: root, env }).exited;
+}
+
+describe('Phase 6 — comments author + thread + mentions', () => {
+  test('commentsAdd populates author + empty thread + parsed mentions', async () => {
+    const { root, designRoot } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      writeFileSync(
+        join(designRoot, 'ui', 'Foo.tsx'),
+        'export default function P(){return <main/>}\n'
+      );
+      const r = await fetch(`http://localhost:${port}/_comments-all`);
+      expect(r.status).toBe(200);
+
+      // POST through the WS path is the normal route, but for unit-coverage we
+      // use the file-system view: write a comment via the http endpoint
+      // doesn't exist (commentsAdd is WS-driven). Instead, hand-author a
+      // single comment via filesystem + read it back to verify the loader
+      // backfill, then exercise reply via /_api/comments/<id>/reply.
+      const slug = 'ui-foo';
+      mkdirSync(join(designRoot, '_comments'), { recursive: true });
+      const legacy = [
+        {
+          id: 'c_legacy0',
+          file: '.design/ui/Foo.tsx',
+          selector: 'main',
+          dom_path: ['main'],
+          tag: 'main',
+          classes: '',
+          bounds: null,
+          html_excerpt: '',
+          text: 'old comment',
+          status: 'open',
+          created: '2026-01-01T00:00:00.000Z',
+          resolved_at: null,
+          // no author / thread / mentions
+        },
+      ];
+      writeFileSync(join(designRoot, '_comments', `${slug}.json`), JSON.stringify(legacy, null, 2));
+
+      const list = await fetch(
+        `http://localhost:${port}/_comments?file=${encodeURIComponent('.design/ui/Foo.tsx')}`
+      ).then((x) => x.json());
+      expect(list.comments).toHaveLength(1);
+      expect(list.comments[0].author).toBe('');
+      expect(list.comments[0].thread).toEqual([]);
+      expect(list.comments[0].mentions).toEqual([]);
+
+      // Disk shape preserved — legacy file not rewritten on read.
+      const onDisk = JSON.parse(
+        readFileSync(join(designRoot, '_comments', `${slug}.json`), 'utf8')
+      );
+      expect(onDisk[0].author).toBeUndefined();
+      expect(onDisk[0].thread).toBeUndefined();
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('POST /_api/comments/<id>/reply appends to thread + folds mentions', async () => {
+    const { root, designRoot } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      writeFileSync(
+        join(designRoot, 'ui', 'Bar.tsx'),
+        'export default function P(){return <main/>}\n'
+      );
+      mkdirSync(join(designRoot, '_comments'), { recursive: true });
+      const seed = [
+        {
+          id: 'c_seed01',
+          file: '.design/ui/Bar.tsx',
+          selector: 'button.cta',
+          dom_path: ['main', 'button.cta'],
+          tag: 'button',
+          classes: 'cta',
+          bounds: { x: 10, y: 20, w: 100, h: 40 },
+          html_excerpt: '<button class="cta">x</button>',
+          text: 'needs more padding @ada',
+          status: 'open',
+          created: '2026-05-20T10:00:00.000Z',
+          resolved_at: null,
+          author: 'Original Author',
+          thread: [],
+          mentions: ['@ada'],
+        },
+      ];
+      writeFileSync(join(designRoot, '_comments', 'ui-bar.json'), JSON.stringify(seed, null, 2));
+
+      const reply = await fetch(`http://localhost:${port}/_api/comments/c_seed01/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ body: 'fixed in next pass @lin', author: 'Replier' }),
+      });
+      expect(reply.status).toBe(200);
+      const updated = await reply.json();
+      expect(updated.thread).toHaveLength(1);
+      expect(updated.thread[0].author).toBe('Replier');
+      expect(updated.thread[0].body).toBe('fixed in next pass @lin');
+      expect(updated.thread[0].id).toMatch(/^r_[0-9a-f]+$/);
+      expect(new Set(updated.mentions)).toEqual(new Set(['@ada', '@lin']));
+
+      // Persisted to disk in the v2 shape.
+      const onDisk = JSON.parse(readFileSync(join(designRoot, '_comments', 'ui-bar.json'), 'utf8'));
+      expect(onDisk[0].thread).toHaveLength(1);
+      expect(onDisk[0].thread[0].body).toBe('fixed in next pass @lin');
+      expect(new Set(onDisk[0].mentions)).toEqual(new Set(['@ada', '@lin']));
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('POST /_api/comments/<id>/reply 404s on unknown id', async () => {
+    const { root } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/comments/c_ghost/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ body: 'orphan' }),
+      });
+      expect(r.status).toBe(404);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('POST /_api/comments/<id>/reply 400 on empty body', async () => {
+    const { root } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/comments/c_anyid/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ body: '   ' }),
+      });
+      expect(r.status).toBe(400);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('GET /_api/git-committers returns the committer list', async () => {
+    const { root } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/git-committers`);
+      expect(r.status).toBe(200);
+      const data = await r.json();
+      expect(Array.isArray(data.committers)).toBe(true);
+      // The sandbox just made one commit, so at least one committer should exist.
+      expect(data.committers.length).toBeGreaterThanOrEqual(1);
+      expect(data.committers[0]).toMatchObject({
+        name: 'Test User',
+        email: 'tester@example.com',
+      });
+      expect(data.committers[0].commits).toBeGreaterThanOrEqual(1);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('GET /_api/git-committers 405 on POST', async () => {
+    const { root } = makeSandbox();
+    await initGit(root);
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/git-committers`, { method: 'POST' });
+      expect(r.status).toBe(405);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

package/plugins/design/dev-server/test/exporters/canva.test.ts

@@ -0,0 +1,64 @@
+// Phase 6.5 T6c — Canva handoff adapter + prompt artifact tests.
+//
+// Real browser walk is integration. Here we cover the pure markdown builder
+// + the empty/file-tree branches.
+
+import { describe, expect, test } from 'bun:test';
+
+import { buildHandoffMarkdown } from '../../exporters/canva-handoff-prompt.ts';
+import { run } from '../../exporters/canva.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('canva-handoff-prompt — buildHandoffMarkdown', () => {
+  test('emits a self-contained markdown with all three sections', () => {
+    const md = buildHandoffMarkdown({
+      pptxFilename: 'home.pptx',
+      absolutePath: '/Users/dev/Downloads/home.pptx',
+      canvasSlug: 'home',
+      artboardCount: 5,
+      artboardTitles: ['Hero', 'Pricing', 'FAQ', 'Footer A', 'Footer B'],
+    });
+    expect(md).toContain('# Canva handoff — home');
+    expect(md).toContain('**5** artboards');
+    expect(md).toContain('## Option A — drag-drop');
+    expect(md).toContain('## Option B — automate via your Canva MCP');
+    // Prompt block present, slot-filled.
+    expect(md).toContain('```text');
+    expect(md).toContain('/Users/dev/Downloads/home.pptx');
+    expect(md).toContain('Slides expected: 5');
+    expect(md).toContain('## Fidelity caveats');
+    // Hero through Footer B listed.
+    expect(md).toContain('1. Hero');
+    expect(md).toContain('5. Footer B');
+  });
+
+  test('singular-vs-plural copy switches at count=1', () => {
+    const md = buildHandoffMarkdown({
+      pptxFilename: 'solo.pptx',
+      absolutePath: '<your-unzip-location>/solo.pptx',
+      canvasSlug: 'solo',
+      artboardCount: 1,
+    });
+    expect(md).toContain('**1** artboard ');
+    expect(md).toContain('1 Canva page on import');
+  });
+});
+
+describe('canva adapter — contract', () => {
+  test('empty targets → zero-byte ZIP placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe('application/zip');
+    expect(r.body.byteLength).toBe(0);
+  });
+
+  test('file-tree targets → throws', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});

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

@@ -0,0 +1,121 @@
+// Phase 6.5 T1 — `/_api/export` endpoint smoke.
+//
+// Boots a real server (per `_helpers.bootServer`) and confirms every format
+// stub returns 200 with the right MIME + filename. The stubs themselves emit
+// zero-byte bodies; this test only checks the dispatch contract, not adapter
+// fidelity (those tests land alongside each adapter in T2…T7).
+
+import { describe, expect, test } from 'bun:test';
+
+import { bootServer, killProc, makeSandbox, nextPort } from '../_helpers.ts';
+
+// Each adapter is paired with a scope that, against the empty sandbox `_active.json`,
+// resolves to zero targets so the adapter takes its empty-input branch. That keeps
+// the dispatch contract test isolated from real screenshot/render integration
+// (those land alongside each adapter's own unit tests).
+const FORMATS = [
+  // PNG/PDF/SVG/HTML/PPTX/Canva expect element targets — `canvas-as-separate`
+  // against `active: null` resolves to [] → adapters short-circuit.
+  { format: 'png', scope: 'canvas-as-separate', expectedExt: '.png', expectedMime: 'image/png' },
+  {
+    format: 'pdf',
+    scope: 'canvas-as-separate',
+    expectedExt: '.pdf',
+    expectedMime: 'application/pdf',
+  },
+  {
+    format: 'svg',
+    scope: 'canvas-as-separate',
+    expectedExt: '.svg',
+    expectedMime: 'image/svg+xml',
+  },
+  {
+    format: 'html',
+    scope: 'canvas-as-separate',
+    expectedExt: '.zip',
+    expectedMime: 'application/zip',
+  },
+  {
+    format: 'pptx',
+    scope: 'canvas-as-separate',
+    expectedExt: '.pptx',
+    expectedMime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  },
+  {
+    format: 'canva',
+    scope: 'canvas-as-separate',
+    expectedExt: '.zip',
+    expectedMime: 'application/zip',
+  },
+  // ZIP consumes `project-raw` — designRoot walk over the sandbox returns at
+  // least the fixture file.
+  { format: 'zip', scope: 'project-raw', expectedExt: '.zip', expectedMime: 'application/zip' },
+] as const;
+
+describe('/_api/export — endpoint dispatch', () => {
+  for (const { format, scope, expectedExt, expectedMime } of FORMATS) {
+    test(`POST format=${format} scope=${scope} returns 200 + ${expectedMime}`, async () => {
+      const { root } = makeSandbox();
+      const port = nextPort();
+      const proc = await bootServer(root, port);
+      try {
+        const r = await fetch(`http://localhost:${port}/_api/export`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format, scope }),
+        });
+        expect(r.status).toBe(200);
+        expect(r.headers.get('Content-Type')).toBe(expectedMime);
+        const disp = r.headers.get('Content-Disposition') ?? '';
+        expect(disp).toMatch(/^attachment; filename=/);
+        expect(disp.endsWith(`${expectedExt}"`)).toBe(true);
+      } finally {
+        await killProc(proc);
+      }
+    });
+  }
+
+  test('rejects unknown format with 400', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/export`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ format: 'jpg', scope: 'project-raw' }),
+      });
+      expect(r.status).toBe(400);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('rejects unknown scope with 400', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/export`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ format: 'png', scope: 'everything' }),
+      });
+      expect(r.status).toBe(400);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('rejects non-POST with 405', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/export`);
+      expect(r.status).toBe(405);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

package/plugins/design/dev-server/test/exporters/history.test.ts

@@ -0,0 +1,79 @@
+// Phase 6.5 T10 — export history persistence + endpoint.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import { bootServer, killProc, makeSandbox, nextPort } from '../_helpers.ts';
+
+interface HistoryShape {
+  history: Array<{ format: string; scope: string; filename: string; at: string }>;
+}
+
+describe('/_api/export-history — GET', () => {
+  test('returns empty list on fresh sandbox', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      const r = await fetch(`http://localhost:${port}/_api/export-history`);
+      expect(r.status).toBe(200);
+      const body = (await r.json()) as HistoryShape;
+      expect(body.history).toEqual([]);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('POST /_api/export appends a history entry, GET surfaces it', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      // Trigger a project-raw zip export (resolver returns file-tree → zip
+      // adapter consumes; no Playwright dependency).
+      const exp = await fetch(`http://localhost:${port}/_api/export`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
+      });
+      expect(exp.status).toBe(200);
+      // Read-back via the dedicated endpoint.
+      const r = await fetch(`http://localhost:${port}/_api/export-history`);
+      const body = (await r.json()) as HistoryShape;
+      expect(body.history.length).toBe(1);
+      expect(body.history[0].format).toBe('zip');
+      expect(body.history[0].scope).toBe('project-raw');
+      expect(body.history[0].filename).toMatch(/\.zip$/);
+      // On-disk file persists across server restarts (writes during request).
+      const onDisk = JSON.parse(
+        readFileSync(join(designRoot, '_export-history.json'), 'utf8')
+      ) as HistoryShape['history'];
+      expect(onDisk.length).toBe(1);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('caps to 5 most-recent entries', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      for (let i = 0; i < 7; i += 1) {
+        const r = await fetch(`http://localhost:${port}/_api/export`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
+        });
+        expect(r.status).toBe(200);
+      }
+      const r = await fetch(`http://localhost:${port}/_api/export-history`);
+      const body = (await r.json()) as HistoryShape;
+      expect(body.history.length).toBe(5);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

package/plugins/design/dev-server/test/exporters/html.test.ts

@@ -0,0 +1,26 @@
+// Phase 6.5 T5 — HTML adapter contract tests.
+
+import { describe, expect, test } from 'bun:test';
+
+import { run } from '../../exporters/html.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('html adapter — contract', () => {
+  test('empty targets → zero-byte ZIP placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe('application/zip');
+    expect(r.body.byteLength).toBe(0);
+    expect(r.filename.endsWith('.zip')).toBe(true);
+  });
+
+  test('file-tree targets → throws', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});

package/plugins/design/dev-server/test/exporters/pdf.test.ts

@@ -0,0 +1,53 @@
+// Phase 6.5 T3 — PDF adapter unit tests.
+//
+// Real PNG capture is integration-shape — covered by the export scenario.
+// Here we cover the empty-input + file-tree-rejection contract, and the
+// raster→pdf assembly itself by feeding a known PNG into the gather path
+// via a synthetic single-target run that short-circuits screenshot.
+
+import { describe, expect, test } from 'bun:test';
+
+import { PDFDocument } from 'pdf-lib';
+import { run } from '../../exporters/pdf.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('pdf adapter — contract', () => {
+  test('empty targets → zero-byte PDF placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe('application/pdf');
+    expect(r.body.byteLength).toBe(0);
+    expect(r.filename.endsWith('.pdf')).toBe(true);
+  });
+
+  test('file-tree targets → throws', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});
+
+describe('pdf-lib smoke — embed + save', () => {
+  test('embeds a PNG and produces a valid PDF buffer', async () => {
+    const pdf = await PDFDocument.create();
+    // 1x1 transparent PNG, hand-encoded — keeps the test hermetic.
+    const png = Uint8Array.from(
+      Buffer.from(
+        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVQYV2NgYAAAAAMAAWgmWQ0AAAAASUVORK5CYII=',
+        'base64'
+      )
+    );
+    const img = await pdf.embedPng(png);
+    expect(img.width).toBe(1);
+    expect(img.height).toBe(1);
+    const page = pdf.addPage([100, 100]);
+    page.drawImage(img, { x: 0, y: 0, width: 100, height: 100 });
+    const bytes = await pdf.save();
+    // PDF magic — every spec-conformant PDF starts with `%PDF-`.
+    expect(new TextDecoder().decode(bytes.slice(0, 5))).toBe('%PDF-');
+  });
+});

package/plugins/design/dev-server/test/exporters/png.test.ts

@@ -0,0 +1,32 @@
+// Phase 6.5 T2 — PNG adapter unit tests.
+//
+// Skips the real `screenshot.sh` invocation — that path lands as a scenario
+// under `.ai/scenarios/export-from-toolbar/` (T2 plan §Validate). Here we
+// cover the contract-shape branches:
+//   - empty target list → zero-byte placeholder
+//   - file-tree-only targets → throws (PNG adapter rejects)
+
+import { describe, expect, test } from 'bun:test';
+
+import { run } from '../../exporters/png.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('png adapter — contract', () => {
+  test('empty targets → zero-byte PNG placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe('image/png');
+    expect(r.body.byteLength).toBe(0);
+    expect(r.filename.endsWith('.png')).toBe(true);
+  });
+
+  test('file-tree targets → throws (PNG cannot render a project)', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});

package/plugins/design/dev-server/test/exporters/pptx.test.ts

@@ -0,0 +1,31 @@
+// Phase 6.5 T6b — PPTX adapter contract.
+//
+// dom-to-pptx runs inside playwright + the headless browser; real conversion
+// is integration-shape (covered by the export scenario). Here we cover empty
+// targets + file-tree rejection so the API surface stays guarded.
+
+import { describe, expect, test } from 'bun:test';
+
+import { run } from '../../exporters/pptx.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('pptx adapter — contract', () => {
+  test('empty targets → zero-byte PPTX placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe(
+      'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+    );
+    expect(r.body.byteLength).toBe(0);
+  });
+
+  test('file-tree targets → throws', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});

package/plugins/design/dev-server/test/exporters/svg.test.ts

@@ -0,0 +1,29 @@
+// Phase 6.5 T4 — SVG adapter contract tests.
+//
+// Real Playwright walk is integration-shape (lands as scenario). Here we
+// cover empty-input + file-tree-rejection.
+
+import { describe, expect, test } from 'bun:test';
+
+import { run } from '../../exporters/svg.ts';
+
+const CTX = {
+  designRoot: '/tmp/.design',
+  repoRoot: '/tmp',
+  serverOrigin: 'http://localhost:0',
+};
+
+describe('svg adapter — contract', () => {
+  test('empty targets → zero-byte SVG placeholder', async () => {
+    const r = await run([], {}, CTX);
+    expect(r.contentType).toBe('image/svg+xml');
+    expect(r.body.byteLength).toBe(0);
+    expect(r.filename.endsWith('.svg')).toBe(true);
+  });
+
+  test('file-tree targets → throws', async () => {
+    await expect(run([{ kind: 'file-tree', paths: ['ui/Home.tsx'] }], {}, CTX)).rejects.toThrow(
+      /element targets/i
+    );
+  });
+});