@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/exporters/endpoint.test.ts

@@ -1,121 +0,0 @@
-// 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/apps/studio/test/exporters/history.test.ts

@@ -1,107 +0,0 @@
-// Phase 6.5 T10 — export history persistence + endpoint.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-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 20 most-recent entries', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      for (let i = 0; i < 23; 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(20);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('old-shape entries (no id/status) still parse on a fresh boot', async () => {
-    const { root, designRoot } = makeSandbox();
-    const { mkdirSync, writeFileSync } = await import('node:fs');
-    mkdirSync(designRoot, { recursive: true });
-    writeFileSync(
-      join(designRoot, '_export-history.json'),
-      JSON.stringify([
-        {
-          format: 'png',
-          scope: 'artboard',
-          filename: 'legacy.png',
-          at: '2026-01-01T00:00:00.000Z',
-        },
-      ])
-    );
-    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.length).toBe(1);
-      expect(body.history[0].format).toBe('png');
-      expect(body.history[0].filename).toBe('legacy.png');
-    } finally {
-      await killProc(proc);
-    }
-  });
-});

package/apps/studio/test/exporters/html.test.ts

@@ -1,26 +0,0 @@
-// 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/apps/studio/test/exporters/jobs.test.ts

@@ -1,342 +0,0 @@
-// feature-background-export-notification-center — job queue concurrency,
-// history persistence under concurrency, and byte retrieval/eviction.
-
-import { describe, expect, test } from 'bun:test';
-import { randomBytes } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { bootServer, killProc, makeSandbox, nextPort } from '../_helpers.ts';
-
-interface JobShape {
-  id: string;
-  status: 'queued' | 'running' | 'done' | 'failed';
-  createdAt: string;
-}
-
-async function listJobs(port: number): Promise<JobShape[]> {
-  const r = await fetch(`http://localhost:${port}/_api/export-jobs`);
-  const body = (await r.json()) as { jobs: JobShape[] };
-  return body.jobs;
-}
-
-/** A `project-raw` zip export takes real, measurable time when the sandbox is
- * large enough (DEFLATE-compressing several MB) — no browser/Playwright
- * needed, so this stays a fast, deterministic-enough integration test. */
-function seedLargeSandbox(designRoot: string, fileCount = 5000): void {
-  const dir = join(designRoot, 'ui', 'big');
-  mkdirSync(dir, { recursive: true });
-  for (let i = 0; i < fileCount; i += 1) {
-    writeFileSync(join(dir, `f${i}.txt`), randomBytes(2000).toString('base64'));
-  }
-}
-
-describe('exporters/jobs — concurrency gate', () => {
-  test('caps concurrent render-heavy jobs at MAUDE_EXPORT_MAX_CONCURRENT', async () => {
-    const { root, designRoot } = makeSandbox();
-    seedLargeSandbox(designRoot);
-    const port = nextPort();
-    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_CONCURRENT: '2' });
-    try {
-      const jobIds: string[] = [];
-      for (let i = 0; i < 3; i += 1) {
-        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
-        });
-        expect(r.status).toBe(202);
-        const { jobId } = (await r.json()) as { jobId: string };
-        jobIds.push(jobId);
-      }
-
-      let sawThirdQueued = false;
-      let maxRunningObserved = 0;
-      let allDone = false;
-      // Generous: the assertion below is "the queue drains at all", not "it
-      // drains fast". The budget only has to outlast DEFLATE over the seeded
-      // sandbox on the slowest machine we run on — a budget tuned to one
-      // machine's disk speed fails there while the queue is working fine.
-      const deadline = Date.now() + 20_000;
-      while (Date.now() < deadline && !allDone) {
-        const jobs = await listJobs(port);
-        const byId = new Map(jobs.map((j) => [j.id, j]));
-        const running = jobs.filter((j) => j.status === 'running').length;
-        maxRunningObserved = Math.max(maxRunningObserved, running);
-        if (byId.get(jobIds[2])?.status === 'queued') sawThirdQueued = true;
-        allDone = jobIds.every((id) => byId.get(id)?.status === 'done');
-        if (!allDone) await Bun.sleep(15);
-      }
-
-      expect(allDone).toBe(true);
-      // Never more than the configured cap ran at once.
-      expect(maxRunningObserved).toBeLessThanOrEqual(2);
-      // The 3rd job was genuinely gated behind the semaphore at some point,
-      // not just "coincidentally" always running — proves the queue, not just
-      // that everything happened to finish fast.
-      expect(sawThirdQueued).toBe(true);
-    } finally {
-      await killProc(proc);
-    }
-  }, 30_000);
-});
-
-describe('exporters/jobs — pending-queue cap (security fan-out, /flow:done)', () => {
-  test('enqueue() 429s past MAUDE_EXPORT_MAX_QUEUED, then accepts more once jobs drain', async () => {
-    const { root, designRoot } = makeSandbox();
-    seedLargeSandbox(designRoot); // keeps jobs 'queued'/'running' long enough to observe
-    const port = nextPort();
-    const proc = await bootServer(root, port, {
-      MAUDE_EXPORT_MAX_CONCURRENT: '1',
-      MAUDE_EXPORT_MAX_QUEUED: '2',
-    });
-    try {
-      const post = () =>
-        fetch(`http://localhost:${port}/_api/export-jobs`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
-        });
-
-      const r1 = await post();
-      const r2 = await post();
-      expect(r1.status).toBe(202);
-      expect(r2.status).toBe(202);
-
-      // A 3rd job while the first 2 are still queued/running must be rejected
-      // with 429, not silently accepted (the DoS-protection cap).
-      const r3 = await post();
-      expect(r3.status).toBe(429);
-      const text = await r3.text();
-      expect(text.toLowerCase()).toContain('queue');
-
-      // Once jobs drain below the cap, enqueue works again — this is a
-      // capacity limit, not a permanent lockout.
-      let drained = false;
-      // Same reasoning as the concurrency gate above — budget for the slowest
-      // machine, since what's under test is that the cap lifts, not latency.
-      const deadline = Date.now() + 20_000;
-      while (Date.now() < deadline && !drained) {
-        const jobs = await listJobs(port);
-        drained = jobs.every((j) => j.status === 'done' || j.status === 'failed');
-        if (!drained) await Bun.sleep(15);
-      }
-      expect(drained).toBe(true);
-      const r4 = await post();
-      expect(r4.status).toBe(202);
-    } finally {
-      await killProc(proc);
-    }
-  }, 30_000);
-});
-
-describe('exporters/jobs — list() + history under concurrency', () => {
-  test('list() returns newest-first', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      // `canvas-as-separate` against an empty sandbox (`active: null`)
-      // resolves to zero targets → the adapter's empty-input branch, no
-      // Playwright spawn — fast + deterministic (mirrors endpoint.test.ts).
-      for (let i = 0; i < 3; i += 1) {
-        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ format: 'png', scope: 'canvas-as-separate' }),
-        });
-        expect(r.status).toBe(202);
-      }
-      // Give the fire-and-forget jobs a moment to land.
-      await Bun.sleep(200);
-      const jobs = await listJobs(port);
-      expect(jobs.length).toBeGreaterThanOrEqual(3);
-      const createdAts = jobs.map((j) => j.createdAt);
-      const sorted = [...createdAts].sort((a, b) => b.localeCompare(a));
-      expect(createdAts).toEqual(sorted);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('history ledger caps at 20 without dropping entries under concurrent completions', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    // MAUDE_EXPORT_MAX_QUEUED override — this test deliberately fires 25 jobs
-    // in one burst (the concurrent-completion race itself), well above the
-    // production default's DoS-protection cap; a real flood is hundreds of
-    // requests, not a legitimate test burst.
-    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_QUEUED: '30' });
-    try {
-      // Fire 25 jobs concurrently (not sequentially) — the exact race the old
-      // read-modify-write appendExportHistory had.
-      await Promise.all(
-        Array.from({ length: 25 }, () =>
-          fetch(`http://localhost:${port}/_api/export-jobs`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ format: 'png', scope: 'canvas-as-separate' }),
-          }).then((r) => expect(r.status).toBe(202))
-        )
-      );
-      // Poll until the ledger settles at the cap.
-      let historyLen = 0;
-      const deadline = Date.now() + 4000;
-      while (Date.now() < deadline && historyLen < 20) {
-        const r = await fetch(`http://localhost:${port}/_api/export-history`);
-        const body = (await r.json()) as { history: unknown[] };
-        historyLen = body.history.length;
-        if (historyLen < 20) await Bun.sleep(20);
-      }
-      expect(historyLen).toBe(20);
-    } finally {
-      await killProc(proc);
-    }
-  });
-});
-
-describe('exporters/jobs — byte retrieval + eviction', () => {
-  test("a finished job's bytes are downloadable, then gone once evicted past the cap", async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    // MAUDE_EXPORT_MAX_QUEUED override — this test pushes 26 jobs through in
-    // one burst (deliberately, to force eviction), above the production
-    // default's DoS-protection cap.
-    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_QUEUED: '30' });
-    try {
-      const enqueue = async () => {
-        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
-        });
-        expect(r.status).toBe(202);
-        const { jobId } = (await r.json()) as { jobId: string };
-        return jobId;
-      };
-
-      const firstId = await enqueue();
-      // Wait for it to finish.
-      let done = false;
-      const deadline = Date.now() + 3000;
-      while (Date.now() < deadline && !done) {
-        const jobs = await listJobs(port);
-        done = jobs.find((j) => j.id === firstId)?.status === 'done';
-        if (!done) await Bun.sleep(15);
-      }
-      expect(done).toBe(true);
-
-      const dl = await fetch(`http://localhost:${port}/_api/export-jobs/download?id=${firstId}`);
-      expect(dl.status).toBe(200);
-      expect(dl.headers.get('Content-Type')).toBe('application/zip');
-      const bytes = await dl.arrayBuffer();
-      expect(bytes.byteLength).toBeGreaterThan(0);
-
-      // 404 for an unknown id.
-      const missing = await fetch(`http://localhost:${port}/_api/export-jobs/download?id=nope`);
-      expect(missing.status).toBe(404);
-
-      // Push 25 more jobs through so the first one rolls past the 20-cap and
-      // gets evicted (bytes removed from disk + dropped from the in-memory
-      // map). Eviction runs on EVERY completion, so the oldest jobs drop out
-      // of list() entirely well before the last of the 25 finishes — poll for
-      // "nothing left pending" rather than tracking specific (possibly
-      // already-evicted) ids.
-      for (let i = 0; i < 25; i += 1) {
-        await enqueue();
-      }
-      let settled = false;
-      const deadline2 = Date.now() + 4000;
-      while (Date.now() < deadline2 && !settled) {
-        const jobs = await listJobs(port);
-        settled = jobs.every((j) => j.status === 'done' || j.status === 'failed');
-        if (!settled) await Bun.sleep(15);
-      }
-      expect(settled).toBe(true);
-
-      const r = await fetch(`http://localhost:${port}/_api/export-history`);
-      const body = (await r.json()) as { history: unknown[] };
-      expect(body.history.length).toBe(20);
-
-      const evicted = await fetch(
-        `http://localhost:${port}/_api/export-jobs/download?id=${firstId}`
-      );
-      expect(evicted.status).toBe(404);
-    } finally {
-      await killProc(proc);
-    }
-  });
-});
-
-// DDR-232 follow-up — the cloud video export that "didn't answer" after 4½
-// minutes. Bun's `fetch` carries its OWN default ceiling of 300 s, independent
-// of the AbortSignal, and rejects with a bare TimeoutError that renderRemotely's
-// catch reported as a waking service. `timeout: false` lifts it (measured:
-// a 315 s response then arrives; without it the same fetch rejects at 300 s
-// exactly). A behavioural test would take five minutes per run, so this pins
-// the source instead — remove the option and a real video job silently
-// re-inherits the ceiling.
-describe('renderRemotely — no second timeout under the job timeout', () => {
-  test("the render fetch disables Bun's default 300 s fetch ceiling", async () => {
-    const { readFileSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const src = readFileSync(join(import.meta.dir, '..', '..', 'exporters', 'remote.ts'), 'utf8');
-    const call = src.slice(
-      src.indexOf('${service.url}/render') - 600,
-      src.indexOf('${service.url}/render') + 200
-    );
-    expect(call).toContain('timeout: false');
-  });
-});
-
-// Security review F2 — a viewer flooding the browser-lane ledger must not evict
-// another member's real export bytes. `recordBrowserExport` fabricates a
-// `done` row stamped now (top of the sort); before the fix, `persistAndEvict`
-// ranked ALL finished jobs together, so 20 byteless browser rows pushed a real
-// job past HISTORY_DEPTH and `rm`'d its bytes — an append that was secretly a
-// delete primitive, reachable by the lowest-privilege role.
-describe('exporters/jobs — browser-lane rows never evict real job bytes (F2)', () => {
-  test('a real job stays downloadable after a flood of recordBrowserExport rows', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_QUEUED: '30' });
-    try {
-      // A real completed export with bytes on disk.
-      const r0 = await fetch(`http://localhost:${port}/_api/export-jobs`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
-      });
-      const { jobId } = (await r0.json()) as { jobId: string };
-      let done = false;
-      const deadline = Date.now() + 4000;
-      while (Date.now() < deadline && !done) {
-        const jobs = await listJobs(port);
-        done = jobs.find((j) => j.id === jobId)?.status === 'done';
-        if (!done) await Bun.sleep(15);
-      }
-      expect(done).toBe(true);
-      expect(
-        (await fetch(`http://localhost:${port}/_api/export-jobs/download?id=${jobId}`)).status
-      ).toBe(200);
-
-      // Flood: 30 browser-lane ledger rows (what a viewer POSTs), well past the
-      // 20-row cap — enough to have evicted the real job under the old logic.
-      for (let i = 0; i < 30; i += 1) {
-        const rr = await fetch(`http://localhost:${port}/_api/export-history`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json', origin: `http://localhost:${port}` },
-          body: JSON.stringify({ format: 'png', scope: 'artboard', filename: `flood-${i}.png` }),
-        });
-        expect(rr.status).toBe(201);
-      }
-
-      // The real job's bytes must still be there.
-      const dl = await fetch(`http://localhost:${port}/_api/export-jobs/download?id=${jobId}`);
-      expect(dl.status).toBe(200);
-      expect((await dl.arrayBuffer()).byteLength).toBeGreaterThan(0);
-    } finally {
-      await killProc(proc);
-    }
-  });
-});

package/apps/studio/test/exporters/pdf.test.ts

@@ -1,85 +0,0 @@
-// 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 { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { PDFDocument } from 'pdf-lib';
-import { assertTotalSizeOk, MAX_TOTAL_OUTPUT_BYTES, 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 adapter — total output-size guard (RCA issue-desktop-print-pdf-save-as-hang-large-payload)', () => {
-  test('passes when total bytes are under the ceiling', () => {
-    const tmp = mkdtempSync(path.join(tmpdir(), 'maude-pdf-guard-'));
-    try {
-      const p = path.join(tmp, 'a.pdf');
-      writeFileSync(p, Buffer.alloc(1024));
-      expect(() => assertTotalSizeOk([p])).not.toThrow();
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-
-  test('throws an actionable error when total bytes exceed the ceiling', () => {
-    const tmp = mkdtempSync(path.join(tmpdir(), 'maude-pdf-guard-'));
-    try {
-      // Two files, each just over half the ceiling — sums past the limit
-      // without needing to actually allocate a giant single buffer.
-      const half = Math.ceil(MAX_TOTAL_OUTPUT_BYTES / 2) + 1024;
-      const a = path.join(tmp, 'a.pdf');
-      const b = path.join(tmp, 'b.pdf');
-      writeFileSync(a, Buffer.alloc(half));
-      writeFileSync(b, Buffer.alloc(half));
-      expect(() => assertTotalSizeOk([a, b])).toThrow(/too large/i);
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-});
-
-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-');
-  });
-});