@1agh/maude 0.45.2 → 0.46.0

package/apps/studio/test/element-structural-edit.test.ts

@@ -12,9 +12,13 @@ import {
   applyInsertElement,
   applyInsertElementIntoArtboard,
   applyResizeArtboard,
+  applySetArtboardGuides,
   applySetArtboardHug,
+  applySetArtboardKind,
+  applySetArtboardPrint,
   applySetArtboardStyle,
   CanvasEditError,
+  readArtboardPrintProp,
 } from '../canvas-edit.ts';
 import { transpileCanvasSource } from '../canvas-pipeline.ts';
 
@@ -337,6 +341,252 @@ describe('canvas-edit / applySetArtboardStyle (background/padding/layout/gap)',
       CanvasEditError
     );
   });
+
+  // Dogfood (artboard panel ↔ shared inspector controls) — padding/gap accept
+  // a var(--token) STRING binding alongside raw px numbers.
+  test('padding/gap accept a var(--token) string (space-token binding)', () => {
+    const out = applySetArtboardStyle(CANVAS, canvas, 'home', {
+      padding: 'var(--space-4)',
+      gap: 'var(--space-2)',
+    });
+    expect(out.source).toContain('padding="var(--space-4)"');
+    expect(out.source).toContain('gap="var(--space-2)"');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a token binding round-trips back to a raw number (detach) and vice versa', () => {
+    const bound = applySetArtboardStyle(CANVAS, canvas, 'home', { padding: 'var(--space-4)' });
+    const detached = applySetArtboardStyle(CANVAS, bound.source, 'home', { padding: 24 });
+    expect(detached.source).toContain('padding={24}');
+    expect(detached.source).not.toContain('var(--space-4)');
+    const rebound = applySetArtboardStyle(CANVAS, detached.source, 'home', {
+      padding: 'var(--space-6)',
+    });
+    expect(rebound.source).toContain('padding="var(--space-6)"');
+    expect(rebound.source).not.toContain('padding={24}');
+    expect(parses(rebound.source)).toBe(true);
+  });
+});
+
+// feature-1-artboard-kinds-foundation, T5/T8 — kind-switch write lane.
+describe('canvas-edit / applySetArtboardKind', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('writes kind as a plain string-literal prop', () => {
+    const out = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    expect(out.source).toContain('kind="print"');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('switching kind replaces the previous value, no duplicate attr', () => {
+    const printed = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    const out = applySetArtboardKind(CANVAS, printed.source, 'home', 'web');
+    expect(out.source).toContain('kind="web"');
+    expect(out.source).not.toContain('kind="print"');
+    expect(out.source.match(/\bkind=/g)?.length).toBe(1);
+  });
+
+  test('kind=null clears back to the implicit default', () => {
+    const printed = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    const out = applySetArtboardKind(CANVAS, printed.source, 'home', null);
+    expect(out.source).not.toContain('kind=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('an invalid kind value throws rather than writing garbage', () => {
+    expect(() => applySetArtboardKind(CANVAS, canvas, 'home', 'poster')).toThrow(CanvasEditError);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardKind(CANVAS, canvas, 'nope', 'print')).toThrow(CanvasEditError);
+  });
+});
+
+// feature-1-artboard-kinds-foundation, T5 — generic layout guides write lane.
+describe('canvas-edit / applySetArtboardGuides (replace-whole-prop)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('inserts guides as a {{...}} object-expression prop', () => {
+    const out = applySetArtboardGuides(CANVAS, canvas, 'home', {
+      columns: { count: 12, gutter: 24, margin: 80 },
+    });
+    expect(out.source).toContain('guides={{"columns":{"count":12,"gutter":24,"margin":80}}}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a second write REPLACES the whole prop rather than merging', () => {
+    const first = applySetArtboardGuides(CANVAS, canvas, 'home', {
+      columns: { count: 12, gutter: 24, margin: 80 },
+    });
+    const out = applySetArtboardGuides(CANVAS, first.source, 'home', { grid: { size: 8 } });
+    expect(out.source).toContain('guides={{"grid":{"size":8}}}');
+    expect(out.source).not.toContain('columns');
+    expect(out.source.match(/\bguides=/g)?.length).toBe(1);
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('guides=null removes the prop', () => {
+    const written = applySetArtboardGuides(CANVAS, canvas, 'home', { grid: { size: 8 } });
+    const out = applySetArtboardGuides(CANVAS, written.source, 'home', null);
+    expect(out.source).not.toContain('guides=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardGuides(CANVAS, canvas, 'nope', { grid: { size: 8 } })).toThrow(
+      CanvasEditError
+    );
+  });
+});
+
+// feature-2-print-artboards T2 — print prop write lane (same replace-whole-
+// prop shape as applySetArtboardGuides).
+describe('canvas-edit / applySetArtboardPrint (replace-whole-prop)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('inserts print as a {{...}} object-expression prop', () => {
+    const out = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4', bleedMm: 3 });
+    expect(out.source).toContain('print={{"paper":"a4","bleedMm":3}}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a second write REPLACES the whole prop rather than merging', () => {
+    const first = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4', bleedMm: 3 });
+    const out = applySetArtboardPrint(CANVAS, first.source, 'home', {
+      paper: 'letter',
+      orientation: 'landscape',
+    });
+    expect(out.source).toContain('print={{"paper":"letter","orientation":"landscape"}}');
+    expect(out.source).not.toContain('a4');
+    expect(out.source.match(/\bprint=/g)?.length).toBe(1);
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('print=null removes the prop', () => {
+    const written = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4' });
+    const out = applySetArtboardPrint(CANVAS, written.source, 'home', null);
+    expect(out.source).not.toContain('print=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardPrint(CANVAS, canvas, 'nope', { paper: 'a4' })).toThrow(
+      CanvasEditError
+    );
+  });
+});
+
+// feature-2-print-artboards T5 — the AST-only (no-eval) reader the PDF
+// exporter uses to resolve an artboard's print geometry.
+describe('canvas-edit / readArtboardPrintProp (no-eval AST read)', () => {
+  test('reads a JSON-shaped print prop on a kind="print" artboard (the picker\'s own write shape)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={816} height={1146} print={{"paper":"a4","bleedMm":3}}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toEqual({ paper: 'a4', bleedMm: 3 });
+  });
+
+  test('reads a hand-authored JS-literal print prop (unquoted keys, nested object)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={816} height={1146} print={{ paper: \'a4\', orientation: \'landscape\', marginsMm: { top: 10, left: 5 } }}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toEqual({
+      paper: 'a4',
+      orientation: 'landscape',
+      marginsMm: { top: 10, left: 5 },
+    });
+  });
+
+  test('no print prop → null', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={1440} height={1024}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toBeNull();
+  });
+
+  test('unknown artboard id → null (not a throw — read-only, best-effort)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={1440} height={1024}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'nope')).toBeNull();
+  });
+
+  test('dogfood regression — a print prop present but kind NOT "print" → null (a stale prop from a prior kind switch must never leak into export)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" width={1440} height={1024} print={{"paper":"a4","bleedMm":3}}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toBeNull();
+  });
 });
 
 describe('canvas-edit / applyInsertArtboard (I4)', () => {

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

@@ -8,7 +8,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { clampScale, run } from '../../exporters/png.ts';
+import { clampDpi, clampScale, resolveDeviceScale, run } from '../../exporters/png.ts';
 
 const CTX = {
   designRoot: '/tmp/.design',
@@ -53,3 +53,51 @@ describe('png clampScale — size presets (item 1)', () => {
     expect(clampScale(1.2)).toBe(1);
   });
 });
+
+describe('png clampDpi — feature-2-print-artboards T4', () => {
+  test('undefined/null → undefined (falls back to scale)', () => {
+    expect(clampDpi(undefined)).toBeUndefined();
+    expect(clampDpi(null)).toBeUndefined();
+  });
+
+  test('non-numeric → undefined', () => {
+    expect(clampDpi('nonsense')).toBeUndefined();
+  });
+
+  test('exact presets pass through', () => {
+    expect(clampDpi(96)).toBe(96);
+    expect(clampDpi(150)).toBe(150);
+    expect(clampDpi(300)).toBe(300);
+    expect(clampDpi(600)).toBe(600);
+  });
+
+  test('snaps to the nearest preset', () => {
+    expect(clampDpi(200)).toBe(150);
+    expect(clampDpi(250)).toBe(300);
+    expect(clampDpi(1000)).toBe(600);
+    expect(clampDpi(0)).toBe(96);
+  });
+});
+
+describe('png resolveDeviceScale — dpi wins over scale', () => {
+  test('dpi=300 → 3.125× (300/96)', () => {
+    expect(resolveDeviceScale({ dpi: 300 })).toBeCloseTo(300 / 96, 10);
+  });
+
+  test('dpi=600 → 6.25× (300dpi ceiling raise, item T4)', () => {
+    expect(resolveDeviceScale({ dpi: 600 })).toBeCloseTo(600 / 96, 10);
+  });
+
+  test('dpi=96 → 1× (no-op)', () => {
+    expect(resolveDeviceScale({ dpi: 96 })).toBeCloseTo(1, 10);
+  });
+
+  test('no dpi → falls back to the legacy scale preset', () => {
+    expect(resolveDeviceScale({ scale: 3 })).toBe(3);
+    expect(resolveDeviceScale({})).toBe(2); // clampScale default
+  });
+
+  test('dpi present but not a number → falls back to scale', () => {
+    expect(resolveDeviceScale({ dpi: 'nope', scale: 1 })).toBe(1);
+  });
+});

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

@@ -0,0 +1,272 @@
+// 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 {
+  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);
+  });
+});
+
+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 });
+  });
+});