@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/test/fixtures/mock-acp-agent-permission-flood.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+// Mock ACP agent proving the MAX_PENDING_PERMISSIONS cap (SECURITY /
+// ethical-hacker finding, retroactive review of Milestone B — a single agent
+// turn can legitimately issue several tool calls back to back, so "one per
+// tool call" is not a natural rate limit). Fires MORE than the cap
+// concurrently, without waiting for each one, and reports which ones actually
+// round-tripped to the client vs. were denied immediately by the bridge's
+// own cap.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const FLOOD_COUNT = 13; // > MAX_PENDING_PERMISSIONS (10) in acp/bridge.ts
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-permission-flood' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-perm-flood-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    const requests = Array.from({ length: FLOOD_COUNT }, (_, i) =>
+      ctx.client.request(acp.methods.client.session.requestPermission, {
+        sessionId: ctx.params.sessionId,
+        toolCall: { toolCallId: `tc${i}`, title: `Flood tool call ${i}`, kind: 'edit' },
+        options: [
+          { optionId: 'allow-once', name: 'Allow once', kind: 'allow_once' },
+          { optionId: 'reject-once', name: 'Reject', kind: 'reject_once' },
+        ],
+      })
+    );
+    const outcomes = await Promise.all(requests);
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: {
+          type: 'text',
+          text: `outcomes=${JSON.stringify(outcomes.map((o) => o.outcome))}`,
+        },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-permission.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+// Mock ACP agent exercising the permission approve/deny gate (Milestone B,
+// retires DDR-125 F2) — session/prompt calls back INTO the client via
+// `ctx.client.requestPermission(...)` (a real request, not a notification)
+// before streaming its final reply, mirroring how claude-agent-acp asks for
+// tool authorization mid-turn. No real `claude` needed.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-permission' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-perm-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    // `ctx.client` (AgentContext) only exposes the generic request()/notify() —
+    // no typed `.requestPermission()` convenience method — so call the raw ACP
+    // method via `acp.methods.client.session.requestPermission`.
+    const outcome = await ctx.client.request(acp.methods.client.session.requestPermission, {
+      sessionId: ctx.params.sessionId,
+      toolCall: {
+        toolCallId: 'tc1',
+        title: 'Write file',
+        kind: 'edit',
+        rawInput: { path: '/tmp/x' },
+      },
+      options: [
+        { optionId: 'allow-once', name: 'Allow once', kind: 'allow_once' },
+        { optionId: 'allow-always', name: 'Allow always', kind: 'allow_always' },
+        { optionId: 'reject-once', name: 'Reject', kind: 'reject_once' },
+      ],
+    });
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `outcome=${JSON.stringify(outcome.outcome)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-usage.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+// Mock ACP agent emitting `usage_update` notifications (Milestone D) — one
+// after the prompt result (context/cost), and one carrying the thin
+// `_meta["_claude/rateLimit"]` rate-limit signal (mirrors the real adapter's
+// `rate_limit_event` forwarding, acp-agent.js:1768-1776). No real `claude` needed.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-usage' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-usage-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'ok' } },
+    });
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'usage_update',
+        used: 4200,
+        size: 200000,
+        cost: { amount: 0.0123, currency: 'USD' },
+      },
+    });
+    if (ctx.params.prompt?.[0]?.text === 'trigger-rate-limit') {
+      await ctx.client.notify('session/update', {
+        sessionId: ctx.params.sessionId,
+        update: {
+          sessionUpdate: 'usage_update',
+          used: 4200,
+          size: 200000,
+          _meta: {
+            '_claude/rateLimit': {
+              status: 'allowed_warning',
+              rateLimitType: 'five_hour',
+              utilization: 82,
+              resetsAt: 1234567890,
+            },
+          },
+        },
+      });
+    }
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/import-asset.test.ts

@@ -42,16 +42,44 @@ describe('svgPreParseReject', () => {
     expect(() => svgPreParseReject(huge)).toThrow(/cap/);
   });
 
-  test('rejects DOCTYPE (XXE class)', () => {
+  test('rejects a DOCTYPE with an internal subset carrying an ENTITY (XXE class)', () => {
     const xxe =
       '<?xml version="1.0"?><!DOCTYPE svg [<!ENTITY x "y">]><svg xmlns="http://www.w3.org/2000/svg"/>';
-    expect(() => svgPreParseReject(xxe)).toThrow(/DOCTYPE/);
+    expect(() => svgPreParseReject(xxe)).toThrow(/entity-expansion/i);
   });
 
   test('rejects a bare ENTITY declaration even without DOCTYPE wrapping', () => {
     expect(() =>
       svgPreParseReject('<!ENTITY x "y"><svg xmlns="http://www.w3.org/2000/svg"/>')
-    ).toThrow(/DOCTYPE\/ENTITY/);
+    ).toThrow(/ENTITY/);
+  });
+
+  test('rejects an internal DTD subset even with no ENTITY declared', () => {
+    expect(() =>
+      svgPreParseReject('<!DOCTYPE svg [ <!-- x --> ]><svg xmlns="http://www.w3.org/2000/svg"/>')
+    ).toThrow(/internal subset/i);
+  });
+
+  // ethical-hacker review: a `>` inside a quoted external-id literal must NOT let
+  // an internal subset slip past the detector (a naive non-greedy regex truncated
+  // there and missed the `[`).
+  test('rejects an internal subset hidden behind a `>` in a quoted SYSTEM literal', () => {
+    expect(() =>
+      svgPreParseReject(
+        '<!DOCTYPE svg SYSTEM "http://attacker/x>y" [ <!ELEMENT foo ANY> ]><svg xmlns="http://www.w3.org/2000/svg"/>'
+      )
+    ).toThrow(/internal subset/i);
+  });
+
+  // RCA G8 — a plain external-identifier DOCTYPE (no internal subset, no ENTITY)
+  // is what Illustrator/Serif/Inkscape emit; rejecting the whole class turned away
+  // real clean logos. It must be accepted (the sanitizer drops it from the output).
+  test('accepts a plain external-identifier DOCTYPE (Illustrator/Serif export)', () => {
+    const illustrator =
+      '<?xml version="1.0" encoding="UTF-8"?>\n' +
+      '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
+      '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="10" height="10" fill="#3B5BDB"/></svg>';
+    expect(() => svgPreParseReject(illustrator)).not.toThrow();
   });
 
   test('rejects a non-declaration processing instruction (xml-stylesheet)', () => {

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

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