@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/ensure-browser.test.ts

@@ -1,92 +0,0 @@
-// Screenshot-browser resolver (bundled-screenshots feature). Covers the pure
-// resolution priority; the actual download (priority 5) is exercised only when no
-// browser exists on the host — untestable in CI where system Chrome / a Playwright
-// headless-shell are usually present, so we assert `download:false` never fetches.
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { CFT_VERSION_RE, isTrustedDownloadUrl, resolveBrowser } from '../bin/_ensure-browser.mjs';
-
-function withEnv<T>(patch: Record<string, string | undefined>, fn: () => T): T {
-  const saved: Record<string, string | undefined> = {};
-  for (const k of Object.keys(patch)) {
-    saved[k] = process.env[k];
-    if (patch[k] === undefined) delete process.env[k];
-    else process.env[k] = patch[k];
-  }
-  try {
-    return fn();
-  } finally {
-    for (const k of Object.keys(patch)) {
-      if (saved[k] === undefined) delete process.env[k];
-      else process.env[k] = saved[k];
-    }
-  }
-}
-
-describe('resolveBrowser — resolution priority', () => {
-  test('AGENT_BROWSER_EXECUTABLE_PATH override wins', async () => {
-    const r = await withEnv({ AGENT_BROWSER_EXECUTABLE_PATH: import.meta.path }, () =>
-      resolveBrowser({ download: false })
-    );
-    expect(r.source).toBe('override');
-    expect(r.path).toBe(import.meta.path);
-  });
-
-  test('a cached chrome-headless-shell in MAUDE_BROWSERS_DIR resolves before system Chrome', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'maude-browsers-'));
-    const sub = join(dir, 'chrome-headless-shell-1.2.3-mac-arm64');
-    mkdirSync(sub, { recursive: true });
-    const exeName =
-      process.platform === 'win32' ? 'chrome-headless-shell.exe' : 'chrome-headless-shell';
-    const exe = join(sub, exeName);
-    writeFileSync(exe, '#!/bin/sh\n');
-    try {
-      const r = await withEnv(
-        {
-          MAUDE_BROWSERS_DIR: dir,
-          AGENT_BROWSER_EXECUTABLE_PATH: undefined,
-          MAUDE_BROWSER_EXECUTABLE: undefined,
-        },
-        () => resolveBrowser({ download: false })
-      );
-      expect(r.source).toBe('cache');
-      expect(r.path).toBe(exe);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('download:false never fetches (source is never "downloaded")', async () => {
-    const r = await resolveBrowser({ download: false });
-    expect(r.source).not.toBe('downloaded');
-  });
-});
-
-describe('download hardening (DDR-144 security fixes)', () => {
-  test('isTrustedDownloadUrl accepts only https on the allowlisted CDN hosts (F2)', () => {
-    expect(
-      isTrustedDownloadUrl('https://storage.googleapis.com/chrome-for-testing-public/x.zip')
-    ).toBe(true);
-    expect(isTrustedDownloadUrl('https://googlechromelabs.github.io/x.json')).toBe(true);
-    // plaintext scheme (MITM-able) rejected
-    expect(isTrustedDownloadUrl('http://storage.googleapis.com/x.zip')).toBe(false);
-    // foreign host (manifest tampering / redirect) rejected
-    expect(isTrustedDownloadUrl('https://evil.example.com/x.zip')).toBe(false);
-    // garbage rejected, no throw
-    expect(isTrustedDownloadUrl('not a url')).toBe(false);
-    expect(isTrustedDownloadUrl('')).toBe(false);
-  });
-
-  test('CFT_VERSION_RE accepts real versions, rejects shell-injection payloads (F3)', () => {
-    expect(CFT_VERSION_RE.test('150.0.7871.46')).toBe(true);
-    expect(CFT_VERSION_RE.test('120')).toBe(true);
-    // the PowerShell -Command break-out attempt
-    expect(CFT_VERSION_RE.test("1.0'; Remove-Item C:\\ -Recurse #")).toBe(false);
-    expect(CFT_VERSION_RE.test('$(rm -rf /)')).toBe(false);
-    expect(CFT_VERSION_RE.test('../../etc')).toBe(false);
-  });
-});

package/apps/studio/test/equal-spacing-detector.test.ts

@@ -1,257 +0,0 @@
-// equal-spacing-detector — T27 (Wave 3). Pure detector fixtures.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  computeAlign,
-  computeDistribute,
-  computePairGap,
-  computeTidyGrid,
-  detectEqualSpacing,
-  type KeyedRect,
-} from '../equal-spacing-detector.ts';
-import type { Rect } from '../use-snap-guides.tsx';
-
-const r = (x: number, y: number, w = 100, h = 60): Rect => ({ x, y, w, h });
-const kr = (key: string, x: number, y: number, w = 100, h = 60): KeyedRect => ({
-  key,
-  x,
-  y,
-  w,
-  h,
-});
-
-describe('detectEqualSpacing / preconditions', () => {
-  test('fewer than 3 rects → null', () => {
-    expect(detectEqualSpacing([], 'x')).toBeNull();
-    expect(detectEqualSpacing([r(0, 0)], 'x')).toBeNull();
-    expect(detectEqualSpacing([r(0, 0), r(200, 0)], 'x')).toBeNull();
-  });
-
-  test('overlapping rects → null (gap < 0)', () => {
-    // r1 spans 0..100, r2 starts at 90 (overlap by 10)
-    expect(detectEqualSpacing([r(0, 0), r(90, 0), r(220, 0)], 'x')).toBeNull();
-  });
-});
-
-describe('detectEqualSpacing / horizontal axis', () => {
-  test('3 rects, equal gap 20 → detects with gap=20 + 2 midpoints', () => {
-    // 0..100, 120..220, 240..340 — gap = 20
-    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(240, 0)], 'x');
-    expect(out).not.toBeNull();
-    expect(out?.axis).toBe('x');
-    expect(out?.gapPx).toBe(20);
-    expect(out?.midpoints).toHaveLength(2);
-    expect(out?.midpoints[0]).toEqual({ x: 110, y: 30 });
-    expect(out?.midpoints[1]).toEqual({ x: 230, y: 30 });
-  });
-
-  test('uneven gaps outside tolerance → null', () => {
-    // gaps: 20, 30
-    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(250, 0)], 'x');
-    expect(out).toBeNull();
-  });
-
-  test('within 1 px tolerance is accepted', () => {
-    // gaps: 20, 21 — within default tolerance of 1
-    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(241, 0)], 'x');
-    expect(out).not.toBeNull();
-    expect(out?.gapPx).toBeGreaterThanOrEqual(20);
-    expect(out?.gapPx).toBeLessThanOrEqual(21);
-  });
-
-  test('explicit tolerance allows wider band', () => {
-    // gaps: 20, 25
-    const tightFail = detectEqualSpacing([r(0, 0), r(120, 0), r(245, 0)], 'x');
-    expect(tightFail).toBeNull();
-    const loosePass = detectEqualSpacing([r(0, 0), r(120, 0), r(245, 0)], 'x', {
-      tolerancePx: 5,
-    });
-    expect(loosePass).not.toBeNull();
-  });
-
-  test('rects passed in random order → sorted internally', () => {
-    const out = detectEqualSpacing([r(240, 0), r(0, 0), r(120, 0)], 'x');
-    expect(out).not.toBeNull();
-    expect(out?.gapPx).toBe(20);
-  });
-});
-
-describe('detectEqualSpacing / vertical axis', () => {
-  test('3 rects stacked, equal gap 30 → detects', () => {
-    // y: 0..60, 90..150, 180..240 — gap 30
-    const out = detectEqualSpacing([r(0, 0), r(0, 90), r(0, 180)], 'y');
-    expect(out).not.toBeNull();
-    expect(out?.axis).toBe('y');
-    expect(out?.gapPx).toBe(30);
-    expect(out?.midpoints).toHaveLength(2);
-    expect(out?.midpoints[0]?.y).toBe(75); // 60 + 30/2
-    expect(out?.midpoints[1]?.y).toBe(165);
-  });
-});
-
-describe('detectEqualSpacing / 4+ rects', () => {
-  test('4 rects equally distributed → 3 midpoints', () => {
-    // gaps 20, 20, 20
-    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(240, 0), r(360, 0)], 'x');
-    expect(out).not.toBeNull();
-    expect(out?.midpoints).toHaveLength(3);
-    expect(out?.gapPx).toBe(20);
-  });
-
-  test('one bad gap in a 4-rect set → null', () => {
-    // gaps 20, 50, 20
-    const out = detectEqualSpacing([r(0, 0), r(120, 0), r(270, 0), r(390, 0)], 'x');
-    expect(out).toBeNull();
-  });
-});
-
-// Task L7 — Alt-hover measurement pairwise gap.
-
-describe('computePairGap', () => {
-  test('measures the x-axis gap regardless of argument order', () => {
-    const a = r(0, 0, 100, 50);
-    const b = r(150, 20, 80, 50);
-    const fwd = computePairGap(a, b, 'x');
-    const rev = computePairGap(b, a, 'x');
-    expect(fwd).toEqual({ axis: 'x', gap: 50, from: 100, cross: 35 });
-    expect(rev).toEqual(fwd);
-  });
-
-  test('measures the y-axis gap', () => {
-    const a = r(0, 0, 50, 60);
-    const b = r(10, 150, 50, 60);
-    const out = computePairGap(a, b, 'y');
-    expect(out).toEqual({ axis: 'y', gap: 90, from: 60, cross: 30 });
-  });
-
-  test('overlapping on the axis → null (no gap to show)', () => {
-    const a = r(0, 0, 100, 50);
-    const b = r(50, 0, 100, 50); // overlaps a on x
-    expect(computePairGap(a, b, 'x')).toBeNull();
-  });
-
-  test('touching (gap === 0) → null', () => {
-    const a = r(0, 0, 100, 50);
-    const b = r(100, 0, 100, 50);
-    expect(computePairGap(a, b, 'x')).toBeNull();
-  });
-});
-
-// Task L5 — distribute / align / tidy-up pure math.
-
-describe('computeAlign', () => {
-  test('fewer than 2 rects → []', () => {
-    expect(computeAlign([], 'left')).toEqual([]);
-    expect(computeAlign([kr('a', 0, 0)], 'left')).toEqual([]);
-  });
-
-  test('left/right/top/bottom hold the union-bbox edge', () => {
-    const rects = [kr('a', 0, 0, 100, 50), kr('b', 40, 100, 60, 50), kr('c', 200, 30, 100, 50)];
-    const left = computeAlign(rects, 'left');
-    // union xMin = 0 → 'a' already at x=0 is a no-op (skipped); b/c move.
-    expect(left).toEqual(
-      expect.arrayContaining([
-        { key: 'b', x: 0, y: 100 },
-        { key: 'c', x: 0, y: 30 },
-      ])
-    );
-    expect(left.find((m) => m.key === 'a')).toBeUndefined();
-
-    const right = computeAlign(rects, 'right');
-    // union xMax = 300 (c: 200+100)
-    expect(right.find((m) => m.key === 'a')).toEqual({ key: 'a', x: 200, y: 0 });
-    expect(right.find((m) => m.key === 'b')).toEqual({ key: 'b', x: 240, y: 100 });
-    expect(right.find((m) => m.key === 'c')).toBeUndefined(); // already at right edge
-
-    const top = computeAlign(rects, 'top');
-    expect(top.find((m) => m.key === 'a')).toBeUndefined(); // already yMin=0
-    expect(top.find((m) => m.key === 'b')).toEqual({ key: 'b', x: 40, y: 0 });
-    expect(top.find((m) => m.key === 'c')).toEqual({ key: 'c', x: 200, y: 0 });
-  });
-
-  test('center-x / center-y align to the union-bbox midpoint', () => {
-    const rects = [kr('a', 0, 0, 100, 100), kr('b', 300, 0, 100, 100)];
-    // union bbox x: 0..400, cx=200
-    const centerX = computeAlign(rects, 'center-x');
-    expect(centerX).toEqual(
-      expect.arrayContaining([
-        { key: 'a', x: 150, y: 0 },
-        { key: 'b', x: 150, y: 0 },
-      ])
-    );
-  });
-
-  test('no-op rects (already aligned) are omitted from the result', () => {
-    const rects = [kr('a', 0, 0), kr('b', 0, 50)];
-    expect(computeAlign(rects, 'left')).toEqual([]);
-  });
-});
-
-describe('computeDistribute', () => {
-  test('fewer than 3 rects → []', () => {
-    expect(computeDistribute([kr('a', 0, 0), kr('b', 200, 0)], 'x')).toEqual([]);
-  });
-
-  test('holds first + last, spaces the middle evenly on x', () => {
-    // 0..100, then a bunched pair at 110/130, then 300..400 — total span
-    // first.x(0) to last.x+w(400) = 400, minus side-lengths(100+80+90+100=370) = 30 → gap 10
-    const rects = [
-      kr('a', 0, 0, 100, 50),
-      kr('b', 110, 0, 80, 50),
-      kr('c', 130, 0, 90, 50),
-      kr('d', 300, 0, 100, 50),
-    ];
-    const out = computeDistribute(rects, 'x');
-    expect(out).toHaveLength(2); // only the 2 middle rects move
-    expect(out.find((m) => m.key === 'b')).toEqual({ key: 'b', x: 110, y: 0 });
-    expect(out.find((m) => m.key === 'c')).toEqual({ key: 'c', x: 200, y: 0 });
-  });
-
-  test('already-equal gaps still returns the (unchanged) middle positions', () => {
-    const rects = [kr('a', 0, 0), kr('b', 120, 0), kr('c', 240, 0)];
-    const out = computeDistribute(rects, 'x');
-    expect(out).toEqual([{ key: 'b', x: 120, y: 0 }]);
-  });
-
-  test('distributes on y', () => {
-    // y: 0..60, 90..150, 300..360 — total sides 180, span 360-180=180, gap 90
-    const rects = [kr('a', 0, 0, 50, 60), kr('b', 0, 90, 50, 60), kr('c', 0, 300, 50, 60)];
-    const out = computeDistribute(rects, 'y');
-    expect(out).toHaveLength(1);
-    expect(out[0]).toEqual({ key: 'b', x: 0, y: 150 });
-  });
-});
-
-describe('computeTidyGrid', () => {
-  test('fewer than 2 rects → []', () => {
-    expect(computeTidyGrid([kr('a', 5, 5)])).toEqual([]);
-  });
-
-  test('4 rects → 2×2 grid, reading-order sorted, from the union-bbox origin', () => {
-    // scattered, deliberately out of reading order
-    const rects = [
-      kr('br', 500, 500, 50, 50),
-      kr('tl', 0, 0, 50, 50),
-      kr('tr', 400, 10, 50, 50),
-      kr('bl', 20, 490, 50, 50),
-    ];
-    const out = computeTidyGrid(rects, { gap: 10 });
-    expect(out).toHaveLength(4);
-    const byKey = Object.fromEntries(out.map((m) => [m.key, m]));
-    // reading order (y then x): tl(0,0) → tr(400,10) → bl(20,490) → br(500,500)
-    // columns = round(sqrt(4)) = 2 → row0: tl,tr · row1: bl,br
-    expect(byKey.tl).toEqual({ key: 'tl', x: 0, y: 0 });
-    expect(byKey.tr).toEqual({ key: 'tr', x: 60, y: 0 }); // col0 width 50 + gap 10
-    expect(byKey.bl).toEqual({ key: 'bl', x: 0, y: 60 });
-    expect(byKey.br).toEqual({ key: 'br', x: 60, y: 60 });
-  });
-
-  test('honors an explicit column count', () => {
-    const rects = [kr('a', 0, 0, 40, 20), kr('b', 0, 0, 40, 20), kr('c', 0, 0, 40, 20)];
-    const out = computeTidyGrid(rects, { gap: 5, columns: 1 });
-    // 1 column → stacked vertically
-    expect(out.map((m) => m.x)).toEqual([0, 0, 0]);
-    expect(out.map((m) => m.y)).toEqual([0, 25, 50]);
-  });
-});

package/apps/studio/test/export-assemble.test.ts

@@ -1,53 +0,0 @@
-// export-assemble.test.ts — DDR-231: the in-cell half of the pptx browser
-// lane. assemblePngDeck composes client-captured PNG bytes into a deck with
-// PptxGenJS — pure JS over pure data (the zip containment class), so it must
-// work with no browser, no filesystem inputs, no tenant checkout.
-
-import { describe, expect, test } from 'bun:test';
-
-import { assemblePngDeck } from '../exporters/pptx.ts';
-
-// 1×1 transparent PNG.
-const PNG_1PX = Uint8Array.from(
-  atob(
-    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=='
-  ),
-  (c) => c.charCodeAt(0)
-);
-
-describe('assemblePngDeck — bytes in, deck out', () => {
-  test('two PNGs become a two-slide .pptx (zip container with per-slide parts)', async () => {
-    const body = await assemblePngDeck([PNG_1PX, PNG_1PX], 3);
-    // .pptx IS a zip — PK\x03\x04 magic.
-    expect(body[0]).toBe(0x50);
-    expect(body[1]).toBe(0x4b);
-    const JSZip = (await import('jszip')).default;
-    const zip = await JSZip.loadAsync(body);
-    expect(zip.file('ppt/slides/slide1.xml')).toBeTruthy();
-    expect(zip.file('ppt/slides/slide2.xml')).toBeTruthy();
-    expect(zip.file('ppt/slides/slide3.xml')).toBeFalsy();
-  });
-
-  test('non-PNG bytes are refused, not composed into a corrupt deck', async () => {
-    await expect(assemblePngDeck([new TextEncoder().encode('<svg/>')], 3)).rejects.toThrow(
-      /not a PNG/
-    );
-  });
-
-  test('a \\x89PNG prefix on non-PNG bytes is caught by the full 8-byte signature (L3)', async () => {
-    // First 4 bytes match the old check, bytes 4-7 do not.
-    const fake = new Uint8Array(24);
-    fake.set([0x89, 0x50, 0x4e, 0x47, 0x00, 0x00, 0x00, 0x00], 0);
-    await expect(assemblePngDeck([fake], 3)).rejects.toThrow(/not a PNG/);
-  });
-
-  test('an implausible IHDR dimension is refused, not fed to the geometry math (F3)', async () => {
-    // Valid 8-byte sig + IHDR claiming 0x7fffffff × 0x7fffffff.
-    const bomb = new Uint8Array(24);
-    bomb.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], 0);
-    const dv = new DataView(bomb.buffer);
-    dv.setUint32(16, 0x7fffffff);
-    dv.setUint32(20, 0x7fffffff);
-    await expect(assemblePngDeck([bomb], 3)).rejects.toThrow(/implausible PNG dimensions/);
-  });
-});

package/apps/studio/test/export-browser-lane.test.ts

@@ -1,126 +0,0 @@
-// export-browser-lane.test.ts — DDR-231 lane-resolution matrix for the client
-// half of the hybrid export lanes (client/export-lane.js). Fail-first: red
-// before the browser lane existed (the module didn't).
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  BROWSER_CAPTURE_FORMATS,
-  browserCaptureEligible,
-  captureScale,
-  MAX_CAPTURE_ITEMS,
-  sanitizeCapturedItems,
-} from '../client/export-lane.js';
-
-const PNG_1PX = Uint8Array.from(
-  atob(
-    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=='
-  ),
-  (c) => c.charCodeAt(0)
-);
-const pngBlob = () => new Blob([PNG_1PX], { type: 'image/png' });
-
-describe('browserCaptureEligible — who captures where', () => {
-  const base = { format: 'png', scope: 'artboard', artboardId: 'board-1' };
-
-  test('desktop/local NEVER routes through the browser bridge (playwright spine owns it)', () => {
-    expect(browserCaptureEligible({ ...base, exportLane: 'local' })).toBe(false);
-    expect(browserCaptureEligible({ ...base, exportLane: undefined })).toBe(false);
-  });
-
-  test('a workspace WITH a render service still prefers the browser for png/svg artboard', () => {
-    expect(browserCaptureEligible({ ...base, exportLane: 'remote' })).toBe(true);
-    expect(browserCaptureEligible({ ...base, exportLane: 'remote', format: 'svg' })).toBe(true);
-  });
-
-  test('a workspace WITHOUT a render service gets png/svg artboard too (the DDR-231 win)', () => {
-    expect(browserCaptureEligible({ ...base, exportLane: 'none' })).toBe(true);
-  });
-
-  test('video formats stay on the jobs lane (Canva/Kapwing pattern — full-CSS fidelity)', () => {
-    for (const format of ['mp4', 'webm', 'gif', 'pdf', 'html', 'zip', 'canva']) {
-      expect(browserCaptureEligible({ ...base, exportLane: 'remote', format })).toBe(false);
-    }
-  });
-
-  test('the pptx deck rides the browser lane on its (only) canvas-as-separate scope', () => {
-    const deck = { format: 'pptx', scope: 'canvas-as-separate' };
-    expect(browserCaptureEligible({ ...deck, exportLane: 'remote' })).toBe(true);
-    expect(browserCaptureEligible({ ...deck, exportLane: 'none' })).toBe(true);
-    expect(browserCaptureEligible({ ...deck, exportLane: 'local' })).toBe(false);
-    expect(
-      browserCaptureEligible({ format: 'pptx', scope: 'artboard', exportLane: 'remote' })
-    ).toBe(false);
-  });
-
-  test('non-artboard scopes stay on the jobs lane (v1: capture what you are looking at)', () => {
-    for (const scope of ['selection', 'canvas-as-separate', 'project-raw']) {
-      expect(browserCaptureEligible({ ...base, exportLane: 'remote', scope })).toBe(false);
-    }
-  });
-
-  test('no known artboard → no browser capture (the bridge selects by id)', () => {
-    expect(browserCaptureEligible({ ...base, exportLane: 'remote', artboardId: null })).toBe(false);
-  });
-
-  test('the format set matches what canvas-lib can actually produce', () => {
-    expect([...BROWSER_CAPTURE_FORMATS].sort()).toEqual(['png', 'svg']);
-  });
-});
-
-describe('sanitizeCapturedItems — the untrusted-reply neutralizer (F1)', () => {
-  test('a forged non-PNG blob named .png is REJECTED by magic sniffing', async () => {
-    const evil = [
-      { name: 'invoice.png', blob: new Blob(['<script>alert(1)</script>'], { type: 'image/png' }) },
-    ];
-    await expect(sanitizeCapturedItems(evil, 'png')).rejects.toThrow(/not a valid png/);
-  });
-
-  test('a real PNG passes and gets a path-stripped name + forced MIME', async () => {
-    const [safe] = await sanitizeCapturedItems(
-      [{ name: '../../etc/passwd\r\n.png', blob: pngBlob() }],
-      'png'
-    );
-    expect(safe.name).not.toContain('/');
-    expect(safe.name).not.toContain('..');
-    expect(safe.name.endsWith('.png')).toBe(true);
-    expect(safe.blob.type).toBe('image/png');
-  });
-
-  test('svg magic (<svg / <?xml) is accepted; other bytes rejected', async () => {
-    const [ok] = await sanitizeCapturedItems(
-      [{ name: 'b.svg', blob: new Blob(['<svg/>']) }],
-      'svg'
-    );
-    expect(ok.name).toBe('b.svg');
-    expect(ok.blob.type).toBe('image/svg+xml');
-    await expect(
-      sanitizeCapturedItems([{ name: 'x.svg', blob: new Blob(['not svg']) }], 'svg')
-    ).rejects.toThrow(/not a valid svg/);
-  });
-
-  test('too many items is refused (a forged reply cannot drive N downloads)', async () => {
-    const many = Array.from({ length: MAX_CAPTURE_ITEMS + 1 }, () => ({ blob: pngBlob() }));
-    await expect(sanitizeCapturedItems(many, 'png')).rejects.toThrow(/too many items/);
-  });
-
-  test('a non-blob item is refused', async () => {
-    await expect(
-      sanitizeCapturedItems([{ name: 'x.png', blob: 'not a blob' as unknown as Blob }], 'png')
-    ).rejects.toThrow(/not a blob/);
-  });
-});
-
-describe('captureScale — dpi folds over scale, clamped to the raster guard window', () => {
-  test('scale multiplier passes through', () => {
-    expect(captureScale({ scale: 2 })).toBe(2);
-  });
-  test('dpi wins over scale (mirrors exporters/png.ts resolveDeviceScale)', () => {
-    expect(captureScale({ dpi: 300, scale: 2 })).toBe(300 / 96);
-  });
-  test('clamped to [1, 8]', () => {
-    expect(captureScale({ dpi: 1200 })).toBe(8);
-    expect(captureScale({ scale: 0 })).toBe(1);
-    expect(captureScale()).toBe(1);
-  });
-});

package/apps/studio/test/export-capture-fidelity.test.ts

@@ -1,146 +0,0 @@
-// export-capture-fidelity.test.ts — DDR-231 T6: the fidelity gate for the
-// browser export lane.
-//
-// The browser lane rasterizes dom-to-svg output (capture-core.ts); the
-// reference spine screenshots the live element (the playwright path the
-// desktop + render worker use). dom-to-svg RECONSTRUCTS the DOM as SVG
-// primitives, so the two are not byte-identical — this gate pins how far
-// apart they may drift on a representative artboard (tokens-styled text,
-// gradient, border-radius, shadow, nested layout). A capture regression
-// (dropped background, missing text, wrong geometry) blows well past these
-// thresholds; anti-aliasing and shadow-softness differences do not.
-//
-// Runs a real Chromium (repo playwright) — lives in the studio suite, not the
-// sync lane.
-
-import { describe, expect, test } from 'bun:test';
-
-import { getBrowserBundle, getCaptureCoreBundle } from '../exporters/_browser-bundles.ts';
-
-const FIXTURE = `<!doctype html><html><body style="margin:0;background:#222">
-  <div class="dc-world">
-    <div data-dc-screen="board-1" style="position:absolute;left:0;top:0;width:420px;height:300px;
-         background:linear-gradient(135deg,#1c2340,#3a1f47);border-radius:16px;overflow:hidden;
-         font-family:Arial,Helvetica,sans-serif;color:#f5f2ea">
-      <div style="padding:28px">
-        <div style="font-size:24px;font-weight:700;letter-spacing:-0.4px">Summer Camp</div>
-        <div style="font-size:13px;opacity:.75;margin-top:6px">Brno · 12–16 August</div>
-        <div style="display:flex;gap:10px;margin-top:18px">
-          <div style="flex:1;height:64px;background:rgba(255,255,255,.08);border:1px solid rgba(255,255,255,.15);border-radius:10px"></div>
-          <div style="flex:1;height:64px;background:#e4572e;border-radius:10px;box-shadow:0 8px 24px rgba(0,0,0,.4)"></div>
-        </div>
-        <div style="margin-top:16px;font-size:12px;line-height:1.5;opacity:.85">
-          Registrace do konce července. Kapacita 60 hráčů.
-        </div>
-      </div>
-    </div>
-  </div></body></html>`;
-
-describe('browser-lane capture vs playwright reference', () => {
-  test(
-    'raster stays within the drift thresholds on a representative artboard',
-    async () => {
-      const [iife, core] = await Promise.all([
-        getBrowserBundle('dom-to-svg', 'domToSvg'),
-        getCaptureCoreBundle(),
-      ]);
-      const { launchChromium } = (await import('../bin/_pw-launch.mjs')) as {
-        launchChromium: () => Promise<{
-          newContext: (o: unknown) => Promise<{ newPage: () => Promise<unknown> }>;
-          close: () => Promise<void>;
-        }>;
-      };
-      const browser = await launchChromium();
-      try {
-        const ctx = await browser.newContext({
-          viewport: { width: 800, height: 600 },
-          deviceScaleFactor: 1,
-        });
-        // biome-ignore lint/suspicious/noExplicitAny: playwright page surface
-        const page: any = await ctx.newPage();
-        await page.setContent(FIXTURE);
-        await page.evaluate(() => document.fonts.ready);
-        await page.addScriptTag({ path: iife });
-        await page.addScriptTag({ path: core, type: 'module' });
-        await page.waitForFunction(
-          () => !!(window as never as Record<string, unknown>)['__maudeCaptureCore']
-        );
-
-        // Reference: the playwright spine's capture of the same element.
-        const el = page.locator('[data-dc-screen]');
-        const refBytes: Uint8Array = await el.screenshot();
-        const refB64 = Buffer.from(refBytes).toString('base64');
-
-        const verdict = await page.evaluate(async (refDataUri: string) => {
-          // biome-ignore lint/suspicious/noExplicitAny: injected globals
-          const w = window as any;
-          const core = w.__maudeCaptureCore;
-          const target = document.querySelector('[data-dc-screen]') as Element;
-          const svg = await core.svgForElement(target, w.domToSvg);
-          const blob: Blob = await core.rasterizeSvg(svg, 1);
-
-          const load = (src: string) =>
-            new Promise<HTMLImageElement>((resolve, reject) => {
-              const img = new Image();
-              img.onload = () => resolve(img);
-              img.onerror = () => reject(new Error('decode failed'));
-              img.src = src;
-            });
-          const candUrl = URL.createObjectURL(blob);
-          const [ref, cand] = await Promise.all([load(refDataUri), load(candUrl)]);
-          const W = ref.naturalWidth;
-          const H = ref.naturalHeight;
-          const draw = (img: HTMLImageElement) => {
-            const c = document.createElement('canvas');
-            c.width = W;
-            c.height = H;
-            const g = c.getContext('2d') as CanvasRenderingContext2D;
-            g.drawImage(img, 0, 0, W, H);
-            return g.getImageData(0, 0, W, H).data;
-          };
-          const a = draw(ref);
-          const b = draw(cand);
-          let sum = 0;
-          let close = 0;
-          const n = W * H;
-          for (let i = 0; i < n * 4; i += 4) {
-            const d =
-              (Math.abs(a[i] - b[i]) +
-                Math.abs(a[i + 1] - b[i + 1]) +
-                Math.abs(a[i + 2] - b[i + 2])) /
-              3;
-            sum += d;
-            if (d <= 32) close += 1;
-          }
-          URL.revokeObjectURL(candUrl);
-          return {
-            refW: W,
-            refH: H,
-            candW: cand.naturalWidth,
-            candH: cand.naturalHeight,
-            meanDelta: sum / n,
-            closeRatio: close / n,
-          };
-        }, `data:image/png;base64,${refB64}`);
-
-        // Geometry must agree exactly — a size mismatch is a broken capture,
-        // not drift.
-        expect(verdict.candW).toBe(verdict.refW);
-        expect(verdict.candH).toBe(verdict.refH);
-        // Thresholds set from the MEASURED baseline (fail-first evidence,
-        // 2026-08-23): healthy capture = meanDelta 1.48, closeRatio 1.0;
-        // a simulated dropped-text regression = meanDelta 5.37, closeRatio
-        // 0.974. Both captures render in the SAME engine, so platform font
-        // variance cancels — the residual is dom-to-svg reconstruction only.
-        // meanDelta < 4 / closeRatio > 0.99 keeps ~2.7× headroom over healthy
-        // while catching the text-drop class (mean-only thresholds missed it —
-        // text is a small pixel fraction, hence the paired closeRatio gate).
-        expect(verdict.meanDelta).toBeLessThan(4);
-        expect(verdict.closeRatio).toBeGreaterThan(0.99);
-      } finally {
-        await browser.close();
-      }
-    },
-    { timeout: 60_000 }
-  );
-});