@1agh/maude 0.16.0 → 0.17.1

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

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

@@ -0,0 +1,105 @@
+// Phase 6.5 T7 — project-raw ZIP adapter tests.
+//
+// Real walk + bundle against a sandboxed designRoot, then unzip the result
+// and diff against expected contents.
+
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+import JSZip from 'jszip';
+
+import { resolveScope } from '../../exporters/scope.ts';
+import { run } from '../../exporters/zip.ts';
+
+function setupTree(): { root: string; designRoot: string } {
+  const root = mkdtempSync(join(tmpdir(), 'zip-adapter-'));
+  const designRoot = join(root, '.design');
+  mkdirSync(join(designRoot, 'ui'), { recursive: true });
+  mkdirSync(join(designRoot, 'system', 'project'), { recursive: true });
+  mkdirSync(join(designRoot, '_history', 'old'), { recursive: true });
+  writeFileSync(join(designRoot, 'config.json'), '{"name":"x"}');
+  writeFileSync(join(designRoot, 'README.md'), '# proj');
+  writeFileSync(join(designRoot, 'ui', 'Home.tsx'), 'export default ()=>null');
+  writeFileSync(join(designRoot, 'system', 'project', 'README.md'), '# ds');
+  writeFileSync(join(designRoot, '_history', 'old', 'snap.tsx'), '// snap');
+  writeFileSync(join(designRoot, '.DS_Store'), ' ');
+  return { root, designRoot };
+}
+
+describe('zip adapter — project-raw', () => {
+  test('bundles designRoot and excludes runtime artefacts by default', async () => {
+    const { root, designRoot } = setupTree();
+    const targets = await resolveScope({
+      scope: 'project-raw',
+      activeJson: { active: null, selected: null },
+      designRoot,
+      repoRoot: root,
+    });
+    const r = await run(targets, {}, { designRoot, repoRoot: root, serverOrigin: '' });
+    expect(r.contentType).toBe('application/zip');
+    expect(r.body.byteLength).toBeGreaterThan(0);
+
+    const unzipped = await JSZip.loadAsync(r.body);
+    const names = Object.keys(unzipped.files).sort();
+    expect(names).toContain('config.json');
+    expect(names).toContain('README.md');
+    expect(names).toContain('ui/Home.tsx');
+    expect(names).toContain('system/project/README.md');
+    expect(names).not.toContain('.DS_Store');
+    expect(names.every((n) => !n.startsWith('_history/'))).toBe(true);
+  });
+
+  test('options.exclude prunes additional paths', async () => {
+    const { root, designRoot } = setupTree();
+    const targets = await resolveScope({
+      scope: 'project-raw',
+      activeJson: { active: null, selected: null },
+      designRoot,
+      repoRoot: root,
+    });
+    const r = await run(
+      targets,
+      { exclude: ['ui/**'] },
+      { designRoot, repoRoot: root, serverOrigin: '' }
+    );
+    const unzipped = await JSZip.loadAsync(r.body);
+    const names = Object.keys(unzipped.files);
+    expect(names.every((n) => !n.startsWith('ui/'))).toBe(true);
+    expect(names).toContain('system/project/README.md');
+  });
+
+  test('options.include narrows to a single subtree', async () => {
+    const { root, designRoot } = setupTree();
+    const targets = await resolveScope({
+      scope: 'project-raw',
+      activeJson: { active: null, selected: null },
+      designRoot,
+      repoRoot: root,
+    });
+    const r = await run(
+      targets,
+      { include: ['system'] },
+      { designRoot, repoRoot: root, serverOrigin: '' }
+    );
+    const unzipped = await JSZip.loadAsync(r.body);
+    const names = Object.keys(unzipped.files);
+    expect(names.every((n) => n.startsWith('system/'))).toBe(true);
+  });
+
+  test('empty targets → zero-byte ZIP placeholder', async () => {
+    const r = await run([], {}, { designRoot: '/tmp/.design', repoRoot: '/tmp', serverOrigin: '' });
+    expect(r.body.byteLength).toBe(0);
+  });
+
+  test('element targets → throws', async () => {
+    await expect(
+      run(
+        [{ kind: 'element', cssPath: '.x', canvasSlug: 'x', file: 'ui/x.tsx' }],
+        {},
+        { designRoot: '/tmp/.design', repoRoot: '/tmp', serverOrigin: '' }
+      )
+    ).rejects.toThrow(/file-tree targets/i);
+  });
+});