@1agh/maude 0.16.0 → 0.17.2

package/plugins/design/dev-server/http.ts

@@ -13,6 +13,8 @@ import { buildCanvasModule } from './canvas-build.ts';
 import { canvasLibPath } from './canvas-lib-resolver.ts';
 import { TranspileError } from './canvas-pipeline.ts';
 import type { Context } from './context.ts';
+import { isFormat, isScope, runExport } from './exporters/index.ts';
+import type { ActiveJsonShape } from './exporters/scope.ts';
 import type { Inspect } from './inspect.ts';
 import { canvasSlug, writeLocator } from './locator.ts';
 import { RUNTIME_PACKAGES, getRuntimeBundle, packageForSlug, slugFor } from './runtime-bundle.ts';
@@ -295,6 +297,84 @@ export function createHttp(ctx: Context, api: Api, inspect: Inspect): Http {
       return new Response('Method not allowed', { status: 405 });
     },
 
+    '/_api/export-history': async (req: Request) => {
+      // Phase 6.5 T10 — read-only recent-exports feed for the dialog's
+      // Recent tab. Writes happen as a side-effect of `/_api/export`.
+      if (req.method !== 'GET') return new Response('Method not allowed', { status: 405 });
+      const history = await api.loadExportHistory();
+      return Response.json({ history }, { headers: { 'Cache-Control': 'no-store' } });
+    },
+
+    '/_api/export': async (req: Request) => {
+      // Phase 6.5 — single dispatch endpoint for the export pipeline.
+      // POST body { format, scope, options? } → binary stream with
+      // Content-Disposition + Content-Type set by the adapter.
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      const body = await readJson<{
+        format?: unknown;
+        scope?: unknown;
+        options?: Record<string, unknown>;
+      }>(req, 64 * 1024);
+      if (!body) return new Response('body required', { status: 400 });
+      if (!isFormat(body.format)) return new Response('unknown or missing format', { status: 400 });
+      if (!isScope(body.scope)) return new Response('unknown or missing scope', { status: 400 });
+      // `inspect.state` is the live `_active.json` — readers narrow to the
+      // resolver's subset locally so the export pipeline doesn't pin the
+      // wider ActiveState interface.
+      const activeJson = inspect.state as unknown as ActiveJsonShape;
+      try {
+        const result = await runExport({
+          format: body.format,
+          scope: body.scope,
+          options: body.options ?? {},
+          resolve: { activeJson, designRoot: ctx.paths.designRoot, repoRoot: ctx.paths.repoRoot },
+          ctx: {
+            designRoot: ctx.paths.designRoot,
+            repoRoot: ctx.paths.repoRoot,
+            // Adapters reach back into the server via this origin only when
+            // they need Playwright rendering (PNG / PDF / SVG / HTML). The
+            // host that received this request is, by definition, the one
+            // serving the canvas.
+            serverOrigin: new URL(req.url).origin,
+            // Mirror `client/app.jsx:85` — the per-DS tokensCssRel wins over
+            // the legacy top-level default (which still points at the pre-
+            // multi-DS layout `system/colors_and_type.css`). Without the
+            // per-DS path, the standalone `_canvas-shell.html` 404s on the
+            // tokens link and the rendered DOM uses `var(--bg-0)` unresolved
+            // → screenshots come out blank. See canvasShellUrl().
+            tokensCssRel: ctx.cfg.designSystems?.[0]?.tokensCssRel ?? ctx.cfg.tokensCssRel,
+          },
+        });
+        // Fire-and-forget history append — failure here doesn't block the
+        // download. Synchronous await keeps the order: history reflects the
+        // export the moment the client sees a 200.
+        try {
+          await api.appendExportHistory({
+            format: body.format,
+            scope: body.scope,
+            options: body.options ?? {},
+            filename: result.filename,
+            at: new Date().toISOString(),
+          });
+        } catch {
+          /* ignore — history is best-effort */
+        }
+        // Bun.serve accepts Uint8Array directly; the cast satisfies the
+        // SharedArrayBuffer-strict BodyInit narrowing on @types/bun.
+        return new Response(result.body as unknown as BodyInit, {
+          status: 200,
+          headers: {
+            'Content-Type': result.contentType,
+            'Content-Disposition': `attachment; filename="${result.filename}"`,
+            'Cache-Control': 'no-store',
+          },
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return new Response(`export failed: ${msg}`, { status: 500 });
+      }
+    },
+
     '/_canvas-state': async (req: Request) => {
       const url = new URL(req.url);
       if (req.method === 'GET') {

package/plugins/design/dev-server/inspect.ts

@@ -227,7 +227,7 @@ const INSPECTOR_SCRIPT = `
 
   var styleEl = document.createElement('style');
   styleEl.textContent = [
-    '.dgn-pin { position: absolute; top: 0; left: 0; z-index: 2147483646; width: 22px; height: 22px; padding: 0; border: 0; border-radius: 999px 999px 999px 4px; background: #facc15; color: #1c1917; font: 600 11px/22px ui-sans-serif, system-ui, sans-serif; text-align: center; cursor: pointer; box-shadow: 0 2px 6px rgba(0,0,0,0.5), 0 0 0 1px rgba(0,0,0,0.4); transition: filter 120ms; transform-origin: bottom left; will-change: transform; }',
+    '.dgn-pin { position: absolute; top: 0; left: 0; z-index: 2147483646; width: 22px; height: 22px; padding: 0; border: 0; border-radius: 999px 999px 999px 4px; background: #facc15; color: #1c1917; font: 600 11px/22px var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace); text-align: center; cursor: pointer; box-shadow: 0 2px 6px rgba(0,0,0,0.5), 0 0 0 1px rgba(0,0,0,0.4); transition: filter 120ms; transform-origin: bottom left; will-change: transform; }',
     '.dgn-pin:hover { filter: brightness(1.1); outline: 2px solid rgba(0,0,0,0.3); }',
     '.dgn-pin.resolved { background: #22c55e; color: #052e16; }',
     '.dgn-pin.focused { box-shadow: 0 4px 12px rgba(0,0,0,0.6), 0 0 0 2px #fff; outline: 2px solid #fff; }'

package/plugins/design/dev-server/server.mjs

@@ -573,7 +573,7 @@ const INSPECTOR_SCRIPT = `
     '.dgn-insp-selected { outline: 2px solid #00D4E4 !important; outline-offset: 1px !important; box-shadow: 0 0 0 4px rgba(0,212,228,0.18) !important; }',
     '.dgn-insp-label { position: fixed; z-index: 2147483647; font: 11px/1 ui-monospace,SFMono-Regular,Menlo,monospace; background: #00D4E4; color: #000; padding: 4px 8px; border-radius: 4px; pointer-events: none; box-shadow: 0 2px 8px rgba(0,0,0,0.4); transform: translate(0, -110%); white-space: nowrap; max-width: 320px; overflow: hidden; text-overflow: ellipsis; }',
     '.dgn-insp-label.warn { background: #ef4444; color: #fff; }',
-    '.dgn-pin { position: absolute; top: 0; left: 0; z-index: 2147483646; width: 22px; height: 22px; padding: 0; border: 0; border-radius: 999px 999px 999px 4px; background: #facc15; color: #1c1917; font: 600 11px/22px ui-sans-serif, system-ui, sans-serif; text-align: center; cursor: pointer; box-shadow: 0 2px 6px rgba(0,0,0,0.5), 0 0 0 1px rgba(0,0,0,0.4); transition: filter 120ms; transform-origin: bottom left; will-change: transform; }',
+    '.dgn-pin { position: absolute; top: 0; left: 0; z-index: 2147483646; width: 22px; height: 22px; padding: 0; border: 0; border-radius: 999px 999px 999px 4px; background: #facc15; color: #1c1917; font: 600 11px/22px var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace); text-align: center; cursor: pointer; box-shadow: 0 2px 6px rgba(0,0,0,0.5), 0 0 0 1px rgba(0,0,0,0.4); transition: filter 120ms; transform-origin: bottom left; will-change: transform; }',
     '.dgn-pin:hover { filter: brightness(1.1); outline: 2px solid rgba(0,0,0,0.3); }',
     '.dgn-pin.resolved { background: #22c55e; color: #052e16; }',
     '.dgn-pin.focused { box-shadow: 0 4px 12px rgba(0,0,0,0.6), 0 0 0 2px #fff; outline: 2px solid #fff; }'

package/plugins/design/dev-server/test/compile-entry.test.ts

@@ -0,0 +1,134 @@
+// Regression test for writeCompileEntry — the per-target build helper that
+// works around Bun 1.3.4+ --compile NAPI native-binding embedding (DDR-NNN-
+// oxc-parser-bun-compile-workaround). The helper itself is pure (no compile,
+// no spawn): given a target, it writes two files (`init-oxc-<slug>.ts` +
+// `server-<slug>.ts`) under dist/.compile-entries/ and returns the entry path.
+
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, test } from 'bun:test';
+
+import { writeCompileEntry } from '../build.ts';
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const DEV_SERVER_ROOT = join(ROOT, '..');
+const ENTRY_DIR = join(DEV_SERVER_ROOT, 'dist', '.compile-entries');
+
+// PlatformTarget union mirrored from build.ts. Kept inline so the test fails
+// loudly if build.ts adds/removes a target without updating the test.
+const ALL_TARGETS = [
+  'bun-darwin-arm64',
+  'bun-darwin-x64',
+  'bun-linux-x64',
+  'bun-linux-arm64',
+  'bun-linux-x64-musl',
+  'bun-linux-arm64-musl',
+  'bun-windows-x64',
+] as const;
+
+// Maude-slug → @oxc-parser/binding-<X> NAPI slug. Mirrored from
+// build.ts:oxcBindingSlug — kept in sync intentionally.
+const EXPECTED_OXC_SLUG: Record<string, string> = {
+  'darwin-arm64': 'darwin-arm64',
+  'darwin-x64': 'darwin-x64',
+  'linux-x64': 'linux-x64-gnu',
+  'linux-arm64': 'linux-arm64-gnu',
+  'linux-x64-musl': 'linux-x64-musl',
+  'linux-arm64-musl': 'linux-arm64-musl',
+  'win32-x64': 'win32-x64-msvc',
+};
+
+function maudeSlug(target: string): string {
+  const s = target.replace(/^bun-/, '');
+  return s === 'windows-x64' ? 'win32-x64' : s;
+}
+
+describe('writeCompileEntry', () => {
+  test('produces init + entry files for every supported target', () => {
+    for (const target of ALL_TARGETS) {
+      const slug = maudeSlug(target);
+      const initPath = join(ENTRY_DIR, `init-oxc-${slug}.ts`);
+      const entryPath = join(ENTRY_DIR, `server-${slug}.ts`);
+
+      const returned = writeCompileEntry(target);
+      expect(returned).toBe(entryPath);
+      expect(existsSync(initPath)).toBe(true);
+      expect(existsSync(entryPath)).toBe(true);
+    }
+  });
+
+  test('init file embeds the matching oxc binding via with-type-file', () => {
+    for (const target of ALL_TARGETS) {
+      const slug = maudeSlug(target);
+      const oxcSlug = EXPECTED_OXC_SLUG[slug];
+      const initPath = join(ENTRY_DIR, `init-oxc-${slug}.ts`);
+
+      writeCompileEntry(target);
+      const content = readFileSync(initPath, 'utf8');
+
+      // Asset embed via Bun's with-type-file syntax — load-bearing for the
+      // workaround. Without `with { type: 'file' }` the import resolves to
+      // the .node's exports rather than its filesystem path.
+      expect(content).toContain(
+        `import bindingPath from "@oxc-parser/binding-${oxcSlug}/parser.${oxcSlug}.node" with { type: 'file' };`
+      );
+      // Env var must be set so oxc-parser's NAPI-RS loader (bindings.js)
+      // skips its broken platform-detection switch.
+      expect(content).toContain('process.env.NAPI_RS_NATIVE_LIBRARY_PATH = bindingPath;');
+    }
+  });
+
+  test('entry file imports init BEFORE server.ts (ESM evaluation order matters)', () => {
+    for (const target of ALL_TARGETS) {
+      const slug = maudeSlug(target);
+      const entryPath = join(ENTRY_DIR, `server-${slug}.ts`);
+
+      writeCompileEntry(target);
+      const content = readFileSync(entryPath, 'utf8');
+
+      const initIdx = content.indexOf(`./init-oxc-${slug}.ts`);
+      const serverIdx = content.indexOf('server.ts');
+      expect(initIdx).toBeGreaterThanOrEqual(0);
+      expect(serverIdx).toBeGreaterThanOrEqual(0);
+      // If server.ts is imported before init-oxc, oxc-parser evaluates first
+      // and reads NAPI_RS_NATIVE_LIBRARY_PATH before our env-var setter runs.
+      expect(initIdx).toBeLessThan(serverIdx);
+    }
+  });
+
+  test('entry uses POSIX path separators in the server.ts import', () => {
+    writeCompileEntry('bun-windows-x64');
+    const content = readFileSync(join(ENTRY_DIR, 'server-win32-x64.ts'), 'utf8');
+    // Even on a Windows host the generated import specifier must use forward
+    // slashes — ESM specifiers are not OS paths.
+    expect(content).not.toMatch(/\\/);
+  });
+
+  test('idempotent — calling twice yields identical content', () => {
+    const target = 'bun-darwin-arm64';
+    const slug = maudeSlug(target);
+
+    writeCompileEntry(target);
+    const a1 = readFileSync(join(ENTRY_DIR, `init-oxc-${slug}.ts`), 'utf8');
+    const e1 = readFileSync(join(ENTRY_DIR, `server-${slug}.ts`), 'utf8');
+
+    writeCompileEntry(target);
+    const a2 = readFileSync(join(ENTRY_DIR, `init-oxc-${slug}.ts`), 'utf8');
+    const e2 = readFileSync(join(ENTRY_DIR, `server-${slug}.ts`), 'utf8');
+
+    expect(a2).toBe(a1);
+    expect(e2).toBe(e1);
+  });
+
+  test('cleanup — generated files live under dist/.compile-entries/', () => {
+    // Sanity: the helper writes only to the expected directory; nothing
+    // leaks elsewhere. Sweep a stale prior dir, regenerate, verify scope.
+    rmSync(ENTRY_DIR, { recursive: true, force: true });
+    writeCompileEntry('bun-darwin-arm64');
+    expect(existsSync(ENTRY_DIR)).toBe(true);
+    expect(existsSync(join(ENTRY_DIR, 'init-oxc-darwin-arm64.ts'))).toBe(true);
+    expect(existsSync(join(ENTRY_DIR, 'server-darwin-arm64.ts'))).toBe(true);
+  });
+});

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
+    );
+  });
+});