@1agh/maude 0.45.2 → 0.47.0

package/apps/studio/test/input-router.test.ts

@@ -17,10 +17,13 @@ const base = (over: Partial<ClassifyInput>): ClassifyInput => ({
   ...over,
 });
 
-describe('input-router / pointermove — move tool', () => {
-  test('bare hover → no-op (native interactions pass through)', () => {
+describe('input-router / pointermove — move (select) tool', () => {
+  // feature-4 (browse/move split, DDR-187) — the Move tool is now a SELECT
+  // tool: a bare hover paints a TOP-level preview halo (Figma's hover outline),
+  // Cmd-hover previews the deepest element.
+  test('bare hover → hover preview with deep=false (top-level outline)', () => {
     const action = classify(base({ type: 'pointermove', clientX: 10, clientY: 20 }));
-    expect(action.kind).toBe('no-op');
+    expect(action).toMatchObject({ kind: 'hover', deep: false });
   });
 
   test('cmd-hover → hover preview with deep=true', () => {
@@ -46,15 +49,22 @@ describe('input-router / pointermove — move tool', () => {
   });
 });
 
-describe('input-router / pointerdown — move tool select', () => {
-  test('bare left-click → no-op (native interactions pass through)', () => {
+describe('input-router / pointerdown — move (select) tool ladder', () => {
+  // feature-4 (browse/move split, DDR-187) — the full Figma select ladder.
+  test('bare left-click → select replace, deep=false (TOP-level object)', () => {
     const action = classify(base({ type: 'pointerdown', button: 0, clientX: 100, clientY: 200 }));
-    expect(action.kind).toBe('no-op');
+    expect(action).toEqual({
+      kind: 'select',
+      mode: 'replace',
+      deep: false,
+      clientX: 100,
+      clientY: 200,
+    });
   });
 
-  test('shift+left-click (no cmd) → no-op (no select without Cmd)', () => {
+  test('shift+left-click (no cmd) → select add, deep=false (add TOP-level)', () => {
     const action = classify(base({ type: 'pointerdown', button: 0, shiftKey: true }));
-    expect(action.kind).toBe('no-op');
+    expect(action).toMatchObject({ kind: 'select', mode: 'add', deep: false });
   });
 
   test('cmd+left-click → select replace, deep=true (nested single)', () => {
@@ -128,6 +138,70 @@ describe('input-router / pointerdown — tool-aware', () => {
   });
 });
 
+// ─────────────────────────────────────────────────────────────────────────────
+// feature-4 (browse/move split, DDR-187) — POSTURE INVARIANTS. The browse tool
+// is the boot default and must be a PURE native pass-through: it claims NOTHING,
+// so a freshly-opened mock stays alive (buttons click, links follow). This
+// promotes the old `input-router.tsx` comment-invariant ("bare clicks pass
+// through") into an enforced gate. If any of these flip to a claim, an existing
+// canvas silently loses its native interactivity on boot.
+describe('input-router / browse tool — pure pass-through (boot default)', () => {
+  const browse = (over: Partial<ClassifyInput>): ClassifyInput =>
+    base({ activeTool: 'browse', ...over });
+
+  test('bare left-click → no-op (native button/link/input fires)', () => {
+    expect(classify(browse({ type: 'pointerdown', button: 0, clientX: 5, clientY: 6 })).kind).toBe(
+      'no-op'
+    );
+  });
+
+  test('cmd+left-click → select deep (the escape hatch; consumer flips tool to move)', () => {
+    // User steer 2026-07-19 — "I clicked to edit" shouldn't require V first.
+    expect(classify(browse({ type: 'pointerdown', button: 0, metaKey: true }))).toMatchObject({
+      kind: 'select',
+      mode: 'replace',
+      deep: true,
+    });
+  });
+
+  test('shift+left-click → no-op (Shift alone is NOT the escape hatch)', () => {
+    expect(classify(browse({ type: 'pointerdown', button: 0, shiftKey: true })).kind).toBe('no-op');
+  });
+
+  test('bare hover → no-op; Cmd-hover previews deep (escape-hatch affordance)', () => {
+    expect(classify(browse({ type: 'pointermove', clientX: 1, clientY: 2 })).kind).toBe('no-op');
+    expect(classify(browse({ type: 'pointermove', metaKey: true }))).toMatchObject({
+      kind: 'hover',
+      deep: true,
+    });
+  });
+
+  test('right-click → still context-menu (chrome, not canvas content)', () => {
+    expect(classify(browse({ type: 'pointerdown', button: 2, clientX: 3, clientY: 4 })).kind).toBe(
+      'context-menu'
+    );
+  });
+
+  test('V keydown → tool move (the router stays live in browse so V switches)', () => {
+    expect(classify(browse({ type: 'keydown', key: 'v' }))).toEqual({
+      kind: 'tool',
+      tool: 'move',
+    });
+  });
+});
+
+// The select action must NEVER be produced from a non-select tool on a bare
+// gesture. Guards the "select leaked into comment/draw/hand/browse" regression.
+describe('input-router / select never leaks into non-select tools', () => {
+  const nonSelectBare: Tool[] = ['browse', 'hand', 'comment', 'pen', 'shape', 'sticky', 'eraser'];
+  for (const activeTool of nonSelectBare) {
+    test(`bare left-click in ${activeTool} → not a select`, () => {
+      const action = classify(base({ type: 'pointerdown', button: 0, activeTool }));
+      expect(action.kind).not.toBe('select');
+    });
+  }
+});
+
 describe('input-router / contextmenu event', () => {
   test('always opens menu + carries cursor coords', () => {
     const action = classify(base({ type: 'contextmenu', clientX: 77, clientY: 88 }));

package/apps/studio/test/layers-synthetic-groups.test.ts

@@ -0,0 +1,96 @@
+// layers-synthetic-groups — feature-4 T7. The serializer that feeds the shell's
+// Layers panel must emit SYNTHETIC group rows for unstamped wrappers that hold
+// stamped descendants (so the tree mirrors real nesting), while still omitting
+// purely-decorative wrappers with no addressable content. This is the fix for
+// the "some layers don't show up / the tree is flat" report.
+//
+// Needs a live DOM (children / querySelector / closest) — register happy-dom.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+beforeAll(() => {
+  GlobalRegistrator.register();
+});
+afterAll(() => {
+  GlobalRegistrator.unregister();
+});
+
+import { serializeArtboardTree } from '../canvas-shell.tsx';
+
+function root(html: string): Element {
+  const el = document.createElement('div');
+  el.className = 'dc-artboard-body';
+  el.innerHTML = html;
+  return el;
+}
+
+describe('serializeArtboardTree — synthetic group rows for unstamped wrappers', () => {
+  test('unstamped wrapper WITH a stamped descendant → synthetic group parent (nesting preserved)', () => {
+    const tree = serializeArtboardTree(
+      root('<div class="hero-wrap"><button data-cd-id="aabbccdd">Go</button></div>')
+    );
+    expect(tree).toHaveLength(1);
+    const group = tree[0]!;
+    expect(group.synthetic).toBe(true);
+    expect(group.type).toBe('group');
+    expect(group.id.startsWith('__grp:')).toBe(true);
+    expect(group.tag).toBe('div');
+    // The stamped button is now a CHILD of the group (not hoisted to the root).
+    expect(group.children).toHaveLength(1);
+    expect(group.children[0]!.id).toBe('aabbccdd');
+    expect(group.children[0]!.synthetic).toBeUndefined();
+  });
+
+  test('unstamped wrapper with NO stamped descendant → omitted (no decorative noise)', () => {
+    const tree = serializeArtboardTree(root('<div class="deco"><span>just text</span></div>'));
+    expect(tree).toHaveLength(0);
+  });
+
+  test('stamped child directly → a normal (non-synthetic) row, no group wrapper', () => {
+    const tree = serializeArtboardTree(root('<section data-cd-id="11112222">Hi</section>'));
+    expect(tree).toHaveLength(1);
+    expect(tree[0]!.synthetic).toBeUndefined();
+    expect(tree[0]!.id).toBe('11112222');
+  });
+
+  test('nested unstamped wrappers → nested synthetic groups (each rung shown)', () => {
+    const tree = serializeArtboardTree(
+      root('<div class="outer"><div class="inner"><a data-cd-id="deadbeef">L</a></div></div>')
+    );
+    expect(tree).toHaveLength(1);
+    const outer = tree[0]!;
+    expect(outer.synthetic).toBe(true);
+    expect(outer.children).toHaveLength(1);
+    const inner = outer.children[0]!;
+    expect(inner.synthetic).toBe(true);
+    expect(inner.children[0]!.id).toBe('deadbeef');
+  });
+
+  test('synthetic group ids are unique across same-signature siblings (stable keys)', () => {
+    const tree = serializeArtboardTree(
+      root(
+        '<div class="col"><span data-cd-id="aaaa1111">a</span></div>' +
+          '<div class="col"><span data-cd-id="bbbb2222">b</span></div>'
+      )
+    );
+    expect(tree).toHaveLength(2);
+    expect(tree[0]!.id).not.toBe(tree[1]!.id);
+    expect(tree[0]!.synthetic).toBe(true);
+    expect(tree[1]!.synthetic).toBe(true);
+  });
+
+  test('mixed: a stamped element AND a sibling unstamped-wrapper-with-content both surface', () => {
+    const tree = serializeArtboardTree(
+      root(
+        '<h1 data-cd-id="head0001">Title</h1>' +
+          '<div class="body"><p data-cd-id="para0001">copy</p></div>'
+      )
+    );
+    expect(tree).toHaveLength(2);
+    expect(tree[0]!.id).toBe('head0001');
+    expect(tree[0]!.synthetic).toBeUndefined();
+    expect(tree[1]!.synthetic).toBe(true);
+    expect(tree[1]!.children[0]!.id).toBe('para0001');
+  });
+});

package/apps/studio/test/pdf-print-boxes.test.ts

@@ -0,0 +1,326 @@
+// feature-2-print-artboards T5 — the load-bearing golden gate: MediaBox ⊇
+// BleedBox ⊇ TrimBox with exact expected pt values, plus marks presence.
+// Exercises pdf-lib directly (no Playwright/Chromium needed — box-setting
+// and mark-drawing are pure pdf-lib API calls); the page size mirrors what
+// Chromium's page.pdf() would actually produce for an artboard authored via
+// resolvePrintArtboard (96dpi CSS px → pt, same ratio as mm → pt).
+
+import { describe, expect, test } from 'bun:test';
+import { PDFDocument } from 'pdf-lib';
+
+import { readArtboardPrintProp } from '../canvas-edit.ts';
+import {
+  applyPageFit,
+  applyPrintBoxesAndMarks,
+  artboardIdFromCssPath,
+  type PdfPrintOptions,
+  parsePageFit,
+  parsePdfPrintOptions,
+  resolvePdfDeviceScale,
+} from '../exporters/pdf.ts';
+import { requiredSlugPt } from '../print/marks.ts';
+import {
+  getPaperPreset,
+  mmToPt,
+  pxToPt,
+  resolvePrintArtboard,
+  trimSizeMm,
+} from '../print/units.ts';
+
+const NO_MARKS: PdfPrintOptions = {
+  marks: { crop: false, registration: false, colorBars: false, pageInfo: false },
+};
+
+describe('pdf.ts — artboardIdFromCssPath', () => {
+  test('extracts the id from the artboard-by-id selector shape', () => {
+    expect(artboardIdFromCssPath('[data-dc-screen="home"]')).toBe('home');
+  });
+
+  test('a descendant / :first-of-type selector yields null', () => {
+    expect(artboardIdFromCssPath('.some .descendant')).toBeNull();
+    expect(artboardIdFromCssPath('[data-dc-screen]:first-of-type')).toBeNull();
+    expect(artboardIdFromCssPath('[data-dc-screen]')).toBeNull();
+  });
+});
+
+describe('pdf.ts — parsePdfPrintOptions', () => {
+  test('absent/malformed → null (print post-pass off)', () => {
+    expect(parsePdfPrintOptions(undefined)).toBeNull();
+    expect(parsePdfPrintOptions(null)).toBeNull();
+    expect(parsePdfPrintOptions('nope')).toBeNull();
+    expect(parsePdfPrintOptions([1, 2])).toBeNull();
+  });
+
+  test('valid shape passes through with marks defaulting false', () => {
+    expect(parsePdfPrintOptions({})).toEqual({
+      includeBleed: undefined,
+      marks: { crop: false, registration: false, colorBars: false, pageInfo: false },
+    });
+  });
+
+  test('marks flags coerce to strict booleans (non-true → false)', () => {
+    expect(parsePdfPrintOptions({ marks: { crop: 'yes', registration: 1 } })).toEqual({
+      includeBleed: undefined,
+      marks: { crop: false, registration: false, colorBars: false, pageInfo: false },
+    });
+    expect(parsePdfPrintOptions({ marks: { crop: true, registration: true } })).toEqual({
+      includeBleed: undefined,
+      marks: { crop: true, registration: true, colorBars: false, pageInfo: false },
+    });
+  });
+
+  test('includeBleed passes through only when a strict boolean', () => {
+    expect(parsePdfPrintOptions({ includeBleed: false })?.includeBleed).toBe(false);
+    expect(parsePdfPrintOptions({ includeBleed: 'false' })?.includeBleed).toBeUndefined();
+  });
+});
+
+describe('pdf.ts — parsePageFit', () => {
+  test('a known paper id passes through', () => {
+    expect(parsePageFit('a4')).toBe('a4');
+    expect(parsePageFit('letter')).toBe('letter');
+  });
+
+  test('unknown id / non-string → null', () => {
+    expect(parsePageFit('not-a-paper')).toBeNull();
+    expect(parsePageFit(42)).toBeNull();
+    expect(parsePageFit(undefined)).toBeNull();
+  });
+});
+
+// Dogfood follow-up (2026-07-16) — a "vector PDF" still embeds raster
+// content (dropped photos, large-format art) as a bitmap whose density is
+// set by the capturing context's deviceScaleFactor; `dpi` controls that.
+describe('pdf.ts — resolvePdfDeviceScale (raster-content density, dogfood follow-up)', () => {
+  test("no dpi → 1× (today's unchanged default — NOT png.ts's 2× default)", () => {
+    expect(resolvePdfDeviceScale({})).toBe(1);
+  });
+
+  test('dpi=300 → 3.125× (300/96)', () => {
+    expect(resolvePdfDeviceScale({ dpi: 300 })).toBeCloseTo(300 / 96, 10);
+  });
+
+  test('dpi=600 → 6.25×', () => {
+    expect(resolvePdfDeviceScale({ dpi: 600 })).toBeCloseTo(600 / 96, 10);
+  });
+
+  test("a bare `scale` option (PNG's legacy field) is ignored — PDF has no scale concept", () => {
+    expect(resolvePdfDeviceScale({ scale: 3 })).toBe(1);
+  });
+});
+
+describe('pdf-print-boxes — GOLDEN: A4 + 3mm bleed, no marks', () => {
+  test('MediaBox === BleedBox (full page); TrimBox insets by bleedPt exactly', async () => {
+    const resolved = resolvePrintArtboard({ paper: 'a4', bleedMm: 3 });
+    const pageWidthPt = pxToPt(resolved.widthPx);
+    const pageHeightPt = pxToPt(resolved.heightPx);
+
+    const doc = await PDFDocument.create();
+    const page = doc.addPage([pageWidthPt, pageHeightPt]);
+    applyPrintBoxesAndMarks(page, 3, NO_MARKS);
+
+    const bleedPt = mmToPt(3);
+    const media = page.getMediaBox();
+    const bleed = page.getBleedBox();
+    const trim = page.getTrimBox();
+
+    // No marks requested → no slug → MediaBox is exactly the bleed box.
+    expect(media.x).toBeCloseTo(0, 6);
+    expect(media.y).toBeCloseTo(0, 6);
+    expect(media.width).toBeCloseTo(pageWidthPt, 6);
+    expect(media.height).toBeCloseTo(pageHeightPt, 6);
+
+    expect(bleed.x).toBeCloseTo(0, 6);
+    expect(bleed.y).toBeCloseTo(0, 6);
+    expect(bleed.width).toBeCloseTo(pageWidthPt, 6);
+    expect(bleed.height).toBeCloseTo(pageHeightPt, 6);
+
+    expect(trim.x).toBeCloseTo(bleedPt, 6);
+    expect(trim.y).toBeCloseTo(bleedPt, 6);
+    expect(trim.width).toBeCloseTo(pageWidthPt - 2 * bleedPt, 6);
+    expect(trim.height).toBeCloseTo(pageHeightPt - 2 * bleedPt, 6);
+
+    // The load-bearing nesting invariant, independent of the exact numbers above.
+    expect(media.x).toBeLessThanOrEqual(bleed.x);
+    expect(media.y).toBeLessThanOrEqual(bleed.y);
+    expect(media.x + media.width).toBeGreaterThanOrEqual(bleed.x + bleed.width);
+    expect(bleed.x).toBeLessThanOrEqual(trim.x);
+    expect(bleed.y).toBeLessThanOrEqual(trim.y);
+    expect(bleed.x + bleed.width).toBeGreaterThanOrEqual(trim.x + trim.width);
+  });
+});
+
+describe('pdf-print-boxes — GOLDEN: A4 + 3mm bleed + crop + registration marks', () => {
+  test('MediaBox enlarges by the exact required slug, negative origin, content-box unmoved', async () => {
+    const resolved = resolvePrintArtboard({ paper: 'a4', bleedMm: 3 });
+    const pageWidthPt = pxToPt(resolved.widthPx);
+    const pageHeightPt = pxToPt(resolved.heightPx);
+
+    const doc = await PDFDocument.create();
+    const page = doc.addPage([pageWidthPt, pageHeightPt]);
+    const printOpts: PdfPrintOptions = {
+      marks: { crop: true, registration: true, colorBars: false, pageInfo: false },
+    };
+    applyPrintBoxesAndMarks(page, 3, printOpts);
+
+    const bleedPt = mmToPt(3);
+    const slugPt = requiredSlugPt({ crop: true, registration: true });
+    const media = page.getMediaBox();
+    const bleed = page.getBleedBox();
+    const trim = page.getTrimBox();
+
+    // Exact expected pt values — the golden assertion.
+    expect(media.x).toBeCloseTo(-slugPt, 6);
+    expect(media.y).toBeCloseTo(-slugPt, 6);
+    expect(media.width).toBeCloseTo(pageWidthPt + 2 * slugPt, 6);
+    expect(media.height).toBeCloseTo(pageHeightPt + 2 * slugPt, 6);
+    // MediaBox's negative origin is the marks slug ONLY — bleed box content
+    // coordinates are untouched (still start at the page's own (0,0)).
+    expect(bleed.x).toBeCloseTo(0, 6);
+    expect(bleed.y).toBeCloseTo(0, 6);
+    expect(bleed.width).toBeCloseTo(pageWidthPt, 6);
+    expect(bleed.height).toBeCloseTo(pageHeightPt, 6);
+    expect(trim.x).toBeCloseTo(bleedPt, 6);
+    expect(trim.y).toBeCloseTo(bleedPt, 6);
+    expect(trim.width).toBeCloseTo(pageWidthPt - 2 * bleedPt, 6);
+    expect(trim.height).toBeCloseTo(pageHeightPt - 2 * bleedPt, 6);
+
+    // MediaBox ⊇ BleedBox ⊇ TrimBox, strictly (marks slug > 0 here).
+    expect(media.x).toBeLessThan(bleed.x);
+    expect(media.width + media.x).toBeGreaterThan(bleed.width + bleed.x);
+    expect(bleed.x).toBeLessThan(trim.x);
+    expect(bleed.width + bleed.x).toBeGreaterThan(trim.width + trim.x);
+  });
+
+  test('marks present as vector ops — saved PDF is measurably larger with marks than without', async () => {
+    const resolved = resolvePrintArtboard({ paper: 'a4', bleedMm: 3 });
+    const pageWidthPt = pxToPt(resolved.widthPx);
+    const pageHeightPt = pxToPt(resolved.heightPx);
+
+    const withoutMarks = await PDFDocument.create();
+    applyPrintBoxesAndMarks(withoutMarks.addPage([pageWidthPt, pageHeightPt]), 3, NO_MARKS);
+    const withoutBytes = await withoutMarks.save();
+
+    const withMarks = await PDFDocument.create();
+    applyPrintBoxesAndMarks(withMarks.addPage([pageWidthPt, pageHeightPt]), 3, {
+      marks: { crop: true, registration: true, colorBars: false, pageInfo: false },
+    });
+    const withBytes = await withMarks.save();
+
+    // 8 crop-mark line segments + 4 registration circles (each an approximated
+    // bezier ellipse) + 8 crosshair segments is a non-trivial amount of vector
+    // content — the byte-size delta is a reliable proxy without depending on
+    // pdf-lib's internal (and version-specific) content-stream compression
+    // format for a literal operator-string grep.
+    expect(withBytes.byteLength).toBeGreaterThan(withoutBytes.byteLength);
+  });
+});
+
+describe('pdf-print-boxes — includeBleed:false crops the bleed strip out', () => {
+  test('MediaBox/BleedBox collapse onto TrimBox (degenerate but valid nesting)', async () => {
+    const resolved = resolvePrintArtboard({ paper: 'a4', bleedMm: 3 });
+    const pageWidthPt = pxToPt(resolved.widthPx);
+    const pageHeightPt = pxToPt(resolved.heightPx);
+    const bleedPt = mmToPt(3);
+
+    const doc = await PDFDocument.create();
+    const page = doc.addPage([pageWidthPt, pageHeightPt]);
+    applyPrintBoxesAndMarks(page, 3, { ...NO_MARKS, includeBleed: false });
+
+    const media = page.getMediaBox();
+    const bleed = page.getBleedBox();
+    const trim = page.getTrimBox();
+
+    expect(media.x).toBeCloseTo(bleedPt, 6);
+    expect(media.y).toBeCloseTo(bleedPt, 6);
+    expect(media.width).toBeCloseTo(pageWidthPt - 2 * bleedPt, 6);
+    expect(bleed.x).toBeCloseTo(trim.x, 6);
+    expect(bleed.width).toBeCloseTo(trim.width, 6);
+  });
+});
+
+// RCA issue-pdf-print-export-marks-missing — the shape that shipped broken:
+// two `kind="print"` artboards sharing one `print` spec via a top-level const
+// (AlligatorsAcko.tsx's actual authoring pattern), not a repeated inline
+// literal per artboard. The multi-page loop in exporters/pdf.ts `run()`
+// re-resolves readArtboardPrintProp independently per written page (keyed by
+// the artboard's own data-dc-screen id — see safeArtboardFilename), so
+// asserting it resolves per-artboard-id here is the load-bearing regression
+// guard: both pages must get the SAME resolved geometry, not just page 1.
+describe('readArtboardPrintProp — shared const print spec resolves for every page (multi-page correlation)', () => {
+  const canvas = [
+    'const A1_PRINT = { paper: "a1", orientation: "portrait", bleedMm: 3 } as const;',
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="acko-front" label="A" kind="print" width={816} height={1146} print={A1_PRINT as any}>',
+    '        <div>front</div>',
+    '      </DCArtboard>',
+    '      <DCArtboard id="acko-back" label="B" kind="print" width={816} height={1146} print={A1_PRINT as any}>',
+    '        <div>back</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('both artboard ids resolve to the same non-null print geometry, driving non-degenerate boxes+marks on each page', async () => {
+    const front = readArtboardPrintProp('/abs/AlligatorsAcko.tsx', canvas, 'acko-front');
+    const back = readArtboardPrintProp('/abs/AlligatorsAcko.tsx', canvas, 'acko-back');
+    expect(front).toEqual({ paper: 'a1', orientation: 'portrait', bleedMm: 3 });
+    expect(back).toEqual(front);
+
+    const printOpts: PdfPrintOptions = {
+      marks: { crop: true, registration: true, colorBars: false, pageInfo: false },
+    };
+    for (const printProp of [front, back]) {
+      if (!printProp) throw new Error('expected a resolved print prop');
+      const bleedMm = typeof printProp.bleedMm === 'number' ? printProp.bleedMm : 0;
+      const resolved = resolvePrintArtboard({ paper: printProp.paper as string, bleedMm });
+      const pageWidthPt = pxToPt(resolved.widthPx);
+      const pageHeightPt = pxToPt(resolved.heightPx);
+      const doc = await PDFDocument.create();
+      const page = doc.addPage([pageWidthPt, pageHeightPt]);
+      applyPrintBoxesAndMarks(page, bleedMm, printOpts);
+      const media = page.getMediaBox();
+      const trim = page.getTrimBox();
+      // Non-degenerate: TrimBox strictly inside MediaBox on every side — the
+      // exact thing that silently failed to happen when printProp was null.
+      expect(media.width).toBeGreaterThan(trim.width);
+      expect(media.height).toBeGreaterThan(trim.height);
+    }
+  });
+});
+
+describe('pdf-print-boxes — applyPageFit (non-print artboard scale-to-paper)', () => {
+  test('the resulting page is sized to the target paper, content preserved', async () => {
+    const doc = await PDFDocument.create();
+    // A wide, non-print-sized artboard (e.g. a 1440×1024 digital screen at 96dpi).
+    const origWidthPt = pxToPt(1440);
+    const origHeightPt = pxToPt(1024);
+    doc.addPage([origWidthPt, origHeightPt]);
+    expect(doc.getPageCount()).toBe(1);
+
+    await applyPageFit(doc, 0, 'a4');
+
+    expect(doc.getPageCount()).toBe(1); // swapped in place, not appended
+    const page = doc.getPage(0);
+    // Expected size mirrors applyPageFit's OWN derivation (mmToPt of the
+    // preset's raw mm dims via trimSizeMm) — NOT a px-rounded roundtrip via
+    // resolvePrintArtboard, which would introduce a spurious sub-pt mismatch.
+    const preset = getPaperPreset('a4');
+    if (!preset) throw new Error('a4 preset missing');
+    const { widthMm, heightMm } = trimSizeMm(preset, 'portrait');
+    const { width, height } = page.getSize();
+    expect(width).toBeCloseTo(mmToPt(widthMm), 6);
+    expect(height).toBeCloseTo(mmToPt(heightMm), 6);
+  });
+
+  test('unknown paper id is a no-op (never throws, never mutates)', async () => {
+    const doc = await PDFDocument.create();
+    doc.addPage([100, 100]);
+    await applyPageFit(doc, 0, 'not-a-paper');
+    expect(doc.getPageCount()).toBe(1);
+    expect(doc.getPage(0).getSize()).toEqual({ width: 100, height: 100 });
+  });
+});

package/apps/studio/test/print-marks.test.ts

@@ -0,0 +1,113 @@
+// feature-2-print-artboards T5 — print/marks.ts pure geometry unit tests.
+
+import { describe, expect, test } from 'bun:test';
+
+import { computeMarksGeometry, MARK_STROKE_PT, requiredSlugPt } from '../print/marks.ts';
+import { mmToPt } from '../print/units.ts';
+
+const PAGE_W = 600; // pt, arbitrary
+const PAGE_H = 800;
+const BLEED = mmToPt(3);
+
+describe('print/marks — requiredSlugPt', () => {
+  test('neither crop nor registration → 0', () => {
+    expect(requiredSlugPt({})).toBe(0);
+  });
+
+  test('crop only → the mark length', () => {
+    expect(requiredSlugPt({ crop: true })).toBeCloseTo(mmToPt(3.5), 6);
+  });
+
+  test('registration reaches further than crop alone', () => {
+    const cropOnly = requiredSlugPt({ crop: true });
+    const both = requiredSlugPt({ crop: true, registration: true });
+    expect(both).toBeGreaterThan(cropOnly);
+  });
+});
+
+describe('print/marks — computeMarksGeometry', () => {
+  test('crop:false, registration:false → both arrays empty', () => {
+    const g = computeMarksGeometry({ pageWidthPt: PAGE_W, pageHeightPt: PAGE_H, bleedPt: BLEED });
+    expect(g.cropMarks).toEqual([]);
+    expect(g.registrationMarks).toEqual([]);
+  });
+
+  test('crop:true → exactly 8 segments (2 per corner × 4 corners)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    expect(g.cropMarks.length).toBe(8);
+  });
+
+  test('every crop-mark segment lies OUTSIDE the bleed box (page) bounds', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    for (const seg of g.cropMarks) {
+      const outside = (x: number, y: number) => x < 0 || x > PAGE_W || y < 0 || y > PAGE_H;
+      // At least one endpoint of every mark segment must be outside the page —
+      // the whole point of a crop mark is to be visible in the bleed/slug area.
+      expect(outside(seg.x1, seg.y1) || outside(seg.x2, seg.y2)).toBe(true);
+    }
+  });
+
+  test('crop-mark segments align to the trim line (bleed inset)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    const trimX0 = BLEED;
+    const trimX1 = PAGE_W - BLEED;
+    const trimY0 = BLEED;
+    const trimY1 = PAGE_H - BLEED;
+    const xs = g.cropMarks.filter((s) => s.x1 === s.x2).map((s) => s.x1);
+    const ys = g.cropMarks.filter((s) => s.y1 === s.y2).map((s) => s.y1);
+    expect(new Set(xs)).toEqual(new Set([trimX0, trimX1]));
+    expect(new Set(ys)).toEqual(new Set([trimY0, trimY1]));
+  });
+
+  test('registration:true → 4 marks, each a circle + 2-segment crosshair', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      registration: true,
+    });
+    expect(g.registrationMarks.length).toBe(4);
+    for (const m of g.registrationMarks) {
+      expect(m.crosshair.length).toBe(2);
+      expect(m.circle.r).toBeGreaterThan(0);
+    }
+  });
+
+  test('registration marks sit beyond the crop marks (no visual collision)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+      registration: true,
+    });
+    const topCenterReg = g.registrationMarks.find((m) => m.circle.cy > PAGE_H);
+    expect(topCenterReg).toBeDefined();
+    const topCropTip = Math.max(
+      ...g.cropMarks.filter((s) => s.y1 > PAGE_H || s.y2 > PAGE_H).map((s) => Math.max(s.y1, s.y2))
+    );
+    expect((topCenterReg?.circle.cy ?? 0) - (topCenterReg?.circle.r ?? 0)).toBeGreaterThan(
+      topCropTip
+    );
+  });
+});
+
+test('MARK_STROKE_PT is a small positive value (0.25mm)', () => {
+  expect(MARK_STROKE_PT).toBeCloseTo(mmToPt(0.25), 6);
+  expect(MARK_STROKE_PT).toBeGreaterThan(0);
+});