@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/photo-filters.test.ts

@@ -1,149 +0,0 @@
-// photo-filters.test.ts — Stage B, Task 4. Unit-tests the PURE pipeline planner
-// (`planPhotoPipeline`) — filter/step COUNT + ORDER + params, never pixel output
-// (pixel realization is browser-only, in pipeline.ts). No pixi import here: the
-// whole point of the planner split is that this suite runs headlessly.
-
-import { describe, expect, test } from 'bun:test';
-
-import type { PhotoPipelineStep } from '../photo/filters.ts';
-import { DUOTONE_FRAG_SOURCE, hexToRgb01, planPhotoPipeline } from '../photo/filters.ts';
-import type { PhotoEdit } from '../photo/schema.ts';
-import { PHOTO_PIPELINE_ORDER } from '../photo/schema.ts';
-
-const stages = (steps: PhotoPipelineStep[]) => steps.map((s) => s.stage);
-
-describe('planPhotoPipeline — neutrality', () => {
-  test('null / empty / all-neutral edits produce no steps', () => {
-    expect(planPhotoPipeline(null)).toEqual([]);
-    expect(planPhotoPipeline(undefined)).toEqual([]);
-    expect(planPhotoPipeline({})).toEqual([]);
-    expect(planPhotoPipeline({ adjustments: { brightness: 0, contrast: 0 } })).toEqual([]);
-    // Disabled sections never emit, regardless of their params.
-    expect(
-      planPhotoPipeline({
-        duotone: { enabled: false, colorA: '#000000', colorB: '#ffffff', intensity: 1 },
-        grain: { enabled: false, amount: 1 },
-        pattern: { enabled: false, opacity: 1 },
-        mask: { preset: 'none', strength: 1 },
-      })
-    ).toEqual([]);
-  });
-});
-
-describe('planPhotoPipeline — ordering', () => {
-  test('a fully-loaded edit emits every stage in PHOTO_PIPELINE_ORDER', () => {
-    const edit: PhotoEdit = {
-      // Deliberately author the object with keys OUT of pipeline order to prove
-      // the planner re-orders rather than echoing insertion order.
-      mask: { preset: 'vignette', strength: 0.5 },
-      pattern: { enabled: true, type: 'grid', scale: 2, opacity: 0.4, blend: 'multiply' },
-      grain: { enabled: true, amount: 0.3, size: 2 },
-      duotone: { enabled: true, colorA: '#1a1a2e', colorB: '#e94560', intensity: 0.8 },
-      adjustments: { contrast: 0.2, brightness: -0.1 },
-    };
-    const steps = planPhotoPipeline(edit);
-    expect(stages(steps)).toEqual([...PHOTO_PIPELINE_ORDER]);
-    // Exactly one step per stage.
-    expect(steps.length).toBe(5);
-  });
-
-  test('partial edits keep relative order and skip absent stages', () => {
-    const steps = planPhotoPipeline({
-      mask: { preset: 'edge-fade', strength: 0.7 },
-      adjustments: { hue: 40 },
-    });
-    expect(stages(steps)).toEqual(['adjustments', 'mask']);
-  });
-});
-
-describe('planPhotoPipeline — adjustments sub-order + params', () => {
-  test('color-matrix ops follow the fixed sub-order and carry normalized values', () => {
-    const steps = planPhotoPipeline({
-      // authored out of order:
-      adjustments: {
-        invert: 1,
-        brightness: 0.5,
-        hue: 90,
-        contrast: -0.3,
-        grayscale: 0.4,
-        saturation: 0.2,
-        sepia: 0.1,
-        exposure: 0.6,
-      },
-    });
-    expect(steps.length).toBe(1);
-    const adj = steps[0];
-    expect(adj.stage).toBe('adjustments');
-    if (adj.stage !== 'adjustments') throw new Error('unreachable');
-    expect(adj.ops.map((o) => o.op)).toEqual([
-      'brightness',
-      'exposure',
-      'contrast',
-      'saturation',
-      'hue',
-      'sepia',
-      'grayscale',
-      'invert',
-    ]);
-    // Values pass through untouched (normalization/mapping is a realizer concern).
-    const byOp = Object.fromEntries(adj.ops.map((o) => [o.op, o.value]));
-    expect(byOp.brightness).toBe(0.5);
-    expect(byOp.hue).toBe(90);
-    expect(byOp.contrast).toBe(-0.3);
-  });
-
-  test('only non-neutral adjustment fields become ops', () => {
-    const steps = planPhotoPipeline({
-      adjustments: { contrast: 0.5, brightness: 0, saturation: 0 },
-    });
-    const adj = steps[0];
-    if (adj.stage !== 'adjustments') throw new Error('expected adjustments');
-    expect(adj.ops.map((o) => o.op)).toEqual(['contrast']);
-  });
-});
-
-describe('planPhotoPipeline — section defaults when enabled-but-unset', () => {
-  test('enabled duotone/grain/pattern fill sensible defaults', () => {
-    const steps = planPhotoPipeline({
-      duotone: { enabled: true },
-      grain: { enabled: true },
-      pattern: { enabled: true },
-    });
-    const duo = steps.find((s) => s.stage === 'duotone');
-    const grain = steps.find((s) => s.stage === 'grain');
-    const pat = steps.find((s) => s.stage === 'pattern');
-    expect(duo).toBeTruthy();
-    expect(grain).toBeTruthy();
-    expect(pat).toBeTruthy();
-    if (duo?.stage === 'duotone') {
-      expect(duo.colorA).toMatch(/^#[0-9a-f]{6}$/);
-      expect(duo.colorB).toMatch(/^#[0-9a-f]{6}$/);
-      expect(duo.intensity).toBeGreaterThan(0);
-    }
-    if (pat?.stage === 'pattern') expect(pat.type).toBe('dots');
-  });
-});
-
-describe('hexToRgb01', () => {
-  test('parses to normalized rgb', () => {
-    expect(hexToRgb01('#000000')).toEqual([0, 0, 0]);
-    expect(hexToRgb01('#ffffff')).toEqual([1, 1, 1]);
-    const [r, g, b] = hexToRgb01('#804020');
-    expect(r).toBeCloseTo(128 / 255, 5);
-    expect(g).toBeCloseTo(64 / 255, 5);
-    expect(b).toBeCloseTo(32 / 255, 5);
-  });
-  test('throws on malformed input', () => {
-    expect(() => hexToRgb01('nope')).toThrow();
-    expect(() => hexToRgb01('#fff')).toThrow();
-  });
-});
-
-describe('duotone shader source', () => {
-  test('is a non-empty GLSL string with the expected uniforms', () => {
-    expect(DUOTONE_FRAG_SOURCE).toContain('uColorA');
-    expect(DUOTONE_FRAG_SOURCE).toContain('uColorB');
-    expect(DUOTONE_FRAG_SOURCE).toContain('uIntensity');
-    expect(DUOTONE_FRAG_SOURCE).toContain('uTexture');
-  });
-});

package/apps/studio/test/photo-pipeline.test.ts

@@ -1,106 +0,0 @@
-// photo-pipeline.test.ts — Stage B, Task 5. Exercises ONLY the pure decision
-// logic in pipeline.ts (`adjustmentCalls`, `resolveSourceUrl`, `needsCompositor`)
-// — no pixi filter is constructed, so this runs headlessly. The actual WebGL
-// render is verified via `maude design screenshot` (Task 6) + desktop dogfood
-// (Task 25). This suite ALSO proves importing pipeline.ts (which statically
-// imports pixi.js) does no construction at load time.
-
-import { describe, expect, test } from 'bun:test';
-
-import type { AdjustmentsStep } from '../photo/filters.ts';
-import { adjustmentCalls, needsCompositor, resolveSourceUrl } from '../photo/pipeline.ts';
-
-const adj = (ops: AdjustmentsStep['ops']): AdjustmentsStep => ({
-  stage: 'adjustments',
-  kind: 'colorMatrix',
-  ops,
-});
-
-describe('adjustmentCalls — normalized → pixi mapping + neutral references', () => {
-  test('brightness delta maps to pixi multiplier (neutral 1)', () => {
-    expect(adjustmentCalls(adj([{ op: 'brightness', value: 0 }]))[0]).toEqual({
-      method: 'brightness',
-      args: [1],
-    });
-    expect(adjustmentCalls(adj([{ op: 'brightness', value: 0.5 }]))[0].args).toEqual([1.5]);
-    expect(adjustmentCalls(adj([{ op: 'brightness', value: -1 }]))[0].args).toEqual([0]);
-  });
-
-  test('exposure maps to a 2^stop brightness', () => {
-    expect(adjustmentCalls(adj([{ op: 'exposure', value: 0 }]))[0]).toEqual({
-      method: 'brightness',
-      args: [1],
-    });
-    expect(adjustmentCalls(adj([{ op: 'exposure', value: 1 }]))[0].args).toEqual([2]);
-  });
-
-  test('contrast maps into pixi 0..1 with 0.5 neutral', () => {
-    expect(adjustmentCalls(adj([{ op: 'contrast', value: 0 }]))[0].args).toEqual([0.5]);
-    expect(adjustmentCalls(adj([{ op: 'contrast', value: 1 }]))[0].args).toEqual([1]);
-    expect(adjustmentCalls(adj([{ op: 'contrast', value: -1 }]))[0].args).toEqual([0]);
-  });
-
-  test('saturation and hue pass through', () => {
-    expect(adjustmentCalls(adj([{ op: 'saturation', value: -0.5 }]))[0]).toEqual({
-      method: 'saturate',
-      args: [-0.5],
-    });
-    expect(adjustmentCalls(adj([{ op: 'hue', value: 120 }]))[0]).toEqual({
-      method: 'hue',
-      args: [120],
-    });
-  });
-
-  test('sepia and invert become isolate-alpha toggles (amount honored)', () => {
-    const sepia = adjustmentCalls(adj([{ op: 'sepia', value: 0.7 }]))[0];
-    expect(sepia.method).toBe('sepia');
-    expect(sepia.args).toEqual([]);
-    expect(sepia.isolateAlpha).toBeCloseTo(0.7, 5);
-    const invert = adjustmentCalls(adj([{ op: 'invert', value: 1 }]))[0];
-    expect(invert.method).toBe('negative');
-    expect(invert.isolateAlpha).toBe(1);
-  });
-
-  test('order is preserved end-to-end', () => {
-    const calls = adjustmentCalls(
-      adj([
-        { op: 'brightness', value: 0.2 },
-        { op: 'contrast', value: 0.1 },
-        { op: 'sepia', value: 0.5 },
-        { op: 'invert', value: 0.3 },
-      ])
-    );
-    expect(calls.map((c) => c.method)).toEqual(['brightness', 'contrast', 'sepia', 'negative']);
-  });
-});
-
-describe('resolveSourceUrl — background-removal cutout replaces original', () => {
-  const SRC = 'assets/aaaa1111.jpg';
-  const MATTE = 'assets/bbbb2222.png';
-  test('unedited → original source', () => {
-    expect(resolveSourceUrl(null, SRC)).toBe(SRC);
-    expect(resolveSourceUrl({}, SRC)).toBe(SRC);
-  });
-  test('bg-removed enabled with a matte → the matte', () => {
-    expect(resolveSourceUrl({ backgroundRemoved: { enabled: true, maskAsset: MATTE } }, SRC)).toBe(
-      MATTE
-    );
-  });
-  test('bg-removed disabled OR no matte → original (non-destructive toggle)', () => {
-    expect(resolveSourceUrl({ backgroundRemoved: { enabled: false, maskAsset: MATTE } }, SRC)).toBe(
-      SRC
-    );
-    expect(resolveSourceUrl({ backgroundRemoved: { enabled: true } }, SRC)).toBe(SRC);
-  });
-});
-
-describe('needsCompositor — lazy-bundle gate', () => {
-  test('mirrors isDefaultEdit inverse', () => {
-    expect(needsCompositor(null)).toBe(false);
-    expect(needsCompositor({})).toBe(false);
-    expect(needsCompositor({ adjustments: { contrast: 0.4 } })).toBe(true);
-    expect(
-      needsCompositor({ backgroundRemoved: { enabled: true, maskAsset: 'assets/cc33.png' } })
-    ).toBe(true);
-  });
-});

package/apps/studio/test/photo-taxonomy.test.ts

@@ -1,96 +0,0 @@
-// photo-taxonomy.test.ts — regression guard for the DDR-115 "three lists must
-// agree" invariant, extended to the new `assets/<sha8>.photo.json` PhotoEdit
-// sidecar (feature-photo-editor, Task 3).
-//
-// The invariant: a VERSIONED path must be classified VERSIONED by ALL THREE
-// lists that encode the taxonomy —
-//   (1) apps/studio/git/service.ts  → `isMaudeRuntimeState` (panel backstop),
-//   (2) cli/lib/gitignore-block.mjs → `buildBlock` (the `maude init` template),
-//   (3) the repo root `.gitignore`  → tested via `git check-ignore` ground truth.
-// `assets/**` (binaries AND `.photo.json` sidecars) is VERSIONED, so none of the
-// three may hide it. This is the automated form of DDR-115 §3's manual claim.
-
-import { describe, expect, test } from 'bun:test';
-import { spawnSync } from 'node:child_process';
-
-import { buildBlock } from '../../../cli/lib/gitignore-block.mjs';
-import { __testing } from '../git/service.ts';
-
-const { isMaudeRuntimeState } = __testing;
-
-// Representative content-addressed paths under `assets/`.
-const PHOTO_SIDECAR_REL = 'assets/ab12cd34.photo.json';
-const PHOTO_SIDECAR_DESIGN = '.design/assets/ab12cd34.photo.json';
-const ASSET_BINARY_DESIGN = '.design/assets/ab12cd34.png';
-const MATTE_ASSET_DESIGN = '.design/assets/ff00aa99.png';
-
-describe('DDR-115 taxonomy — assets/<sha8>.photo.json is VERSIONED', () => {
-  test('isMaudeRuntimeState does NOT classify photo sidecars/assets as runtime', () => {
-    expect(isMaudeRuntimeState(PHOTO_SIDECAR_REL)).toBe(false);
-    expect(isMaudeRuntimeState(PHOTO_SIDECAR_DESIGN)).toBe(false);
-    expect(isMaudeRuntimeState(ASSET_BINARY_DESIGN)).toBe(false);
-    expect(isMaudeRuntimeState(MATTE_ASSET_DESIGN)).toBe(false);
-  });
-
-  // Positive control — proves the classifier's mechanism actually fires, so the
-  // negatives above aren't passing for a trivial reason (e.g. a broken regex).
-  test('isMaudeRuntimeState still classifies real runtime state as IGNORED', () => {
-    expect(isMaudeRuntimeState('.design/_server.json')).toBe(true);
-    expect(isMaudeRuntimeState('.design/_history/foo/bar.png')).toBe(true);
-    expect(isMaudeRuntimeState('.design/_canvas-state/x.view.json')).toBe(true);
-  });
-
-  // `_photo/` (Task 18/20's headless bg-remove proof canvases, mirroring
-  // `_draw/`'s draw-proof canvases) must agree as IGNORED across all three lists.
-  test('_photo/ (headless bg-remove proof canvases) is IGNORED across all three lists', () => {
-    expect(isMaudeRuntimeState('.design/_photo/smoke-tsx.bgremove.tsx')).toBe(true);
-
-    const block = buildBlock('.design');
-    expect(block).toContain('.design/_photo/');
-
-    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
-    if (top.status !== 0) {
-      console.warn('git rev-parse failed; skipping root .gitignore ground-truth check');
-      return;
-    }
-    const root = top.stdout.trim();
-    const r = spawnSync('git', ['check-ignore', '-q', '--', '.design/_photo/x.bgremove.tsx'], {
-      cwd: root,
-    });
-    expect(r.status).toBe(0);
-  });
-
-  test('the gitignore-block template ignores no assets/ path', () => {
-    for (const root of ['.design', 'design', 'mock']) {
-      const block = buildBlock(root);
-      // buildBlock only lists `${root}/_*` runtime prefixes — VERSIONED content
-      // (assets, canvases, meta) is deliberately absent. A future editor adding
-      // an `assets`/`.photo.json` ignore line trips this.
-      expect(block).not.toContain('assets');
-      expect(block).not.toContain('.photo.json');
-    }
-  });
-
-  test('root .gitignore (git check-ignore ground truth) does not ignore photo assets', () => {
-    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
-    if (top.status !== 0) {
-      // Not in a git checkout (unexpected in CI/dev) — skip rather than false-fail.
-      console.warn('git rev-parse failed; skipping root .gitignore ground-truth check');
-      return;
-    }
-    const root = top.stdout.trim();
-
-    const isIgnored = (relPath: string): boolean => {
-      const r = spawnSync('git', ['check-ignore', '-q', '--', relPath], { cwd: root });
-      // exit 0 = ignored, 1 = not ignored, other = error.
-      return r.status === 0;
-    };
-
-    // VERSIONED assets must NOT be ignored by the repo's own .gitignore.
-    expect(isIgnored(PHOTO_SIDECAR_DESIGN)).toBe(false);
-    expect(isIgnored(ASSET_BINARY_DESIGN)).toBe(false);
-
-    // Positive control — a known runtime path IS ignored, proving check-ignore works here.
-    expect(isIgnored('.design/_server.json')).toBe(true);
-  });
-});

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

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

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

@@ -1,173 +0,0 @@
-// feature-2-print-artboards T1 — print/units.ts unit tests + the single-source
-// lint guard (no `25.4` outside this module — see the plan's T1 gotcha).
-
-import { describe, expect, test } from 'bun:test';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
-
-import {
-  CSS_DPI,
-  defaultBleedMm,
-  getPaperPreset,
-  MM_PER_INCH,
-  mmToPt,
-  mmToPx,
-  PAPER_PRESETS,
-  pxToMm,
-  pxToPt,
-  resolvePrintArtboard,
-  trimSizeMm,
-} from '../print/units.ts';
-
-describe('print/units — conversions', () => {
-  test('mmToPx / pxToMm are inverses at 96dpi', () => {
-    expect(mmToPx(MM_PER_INCH)).toBeCloseTo(CSS_DPI, 10);
-    expect(pxToMm(CSS_DPI)).toBeCloseTo(MM_PER_INCH, 10);
-    expect(pxToMm(mmToPx(37))).toBeCloseTo(37, 10);
-  });
-
-  test('mmToPt: 25.4mm === 72pt (1 inch)', () => {
-    expect(mmToPt(MM_PER_INCH)).toBeCloseTo(72, 10);
-  });
-
-  test('pxToPt: 96px @96dpi === 72pt (1 inch)', () => {
-    expect(pxToPt(96)).toBeCloseTo(72, 10);
-  });
-});
-
-describe('print/units — PAPER_PRESETS', () => {
-  test('every ISO A-series preset id resolves', () => {
-    for (const id of ['a6', 'a5', 'a4', 'a3', 'a2', 'a1', 'a0']) {
-      expect(getPaperPreset(id)).toBeDefined();
-    }
-  });
-
-  test('A4 is 210×297mm portrait', () => {
-    const a4 = getPaperPreset('a4');
-    expect(a4?.width).toBe(210);
-    expect(a4?.height).toBe(297);
-    expect(a4?.unit).toBe('mm');
-  });
-
-  test('Letter is a US in-unit preset', () => {
-    const letter = getPaperPreset('letter');
-    expect(letter?.unit).toBe('in');
-    expect(letter?.width).toBe(8.5);
-    expect(letter?.height).toBe(11);
-  });
-
-  test('unknown id is undefined', () => {
-    expect(getPaperPreset('nope')).toBeUndefined();
-  });
-
-  test('no duplicate ids', () => {
-    const ids = PAPER_PRESETS.map((p) => p.id);
-    expect(new Set(ids).size).toBe(ids.length);
-  });
-});
-
-describe('print/units — orientation', () => {
-  test('landscape swaps width/height', () => {
-    const a4 = getPaperPreset('a4');
-    expect(a4).toBeDefined();
-    const portrait = trimSizeMm(a4 as NonNullable<typeof a4>, 'portrait');
-    const landscape = trimSizeMm(a4 as NonNullable<typeof a4>, 'landscape');
-    expect(portrait.widthMm).toBe(210);
-    expect(portrait.heightMm).toBe(297);
-    expect(landscape.widthMm).toBe(297);
-    expect(landscape.heightMm).toBe(210);
-  });
-});
-
-describe('print/units — default bleed', () => {
-  test('mm-unit presets default to 3mm bleed', () => {
-    const a4 = getPaperPreset('a4');
-    expect(a4).toBeDefined();
-    expect(defaultBleedMm(a4 as NonNullable<typeof a4>)).toBe(3);
-  });
-
-  test('in-unit presets default to 0.125in bleed, expressed in mm', () => {
-    const letter = getPaperPreset('letter');
-    expect(letter).toBeDefined();
-    expect(defaultBleedMm(letter as NonNullable<typeof letter>)).toBeCloseTo(
-      0.125 * MM_PER_INCH,
-      10
-    );
-  });
-});
-
-describe('print/units — resolvePrintArtboard', () => {
-  test('throws on unknown paper', () => {
-    expect(() => resolvePrintArtboard({ paper: 'nope' })).toThrow(/unknown paper preset/);
-  });
-
-  test('A4 portrait, default bleed — artboard px = trim + 2×bleed exactly', () => {
-    const r = resolvePrintArtboard({ paper: 'a4' });
-    expect(r.bleedMm).toBe(3);
-    expect(r.widthPx).toBe(r.trimWidthPx + 2 * r.bleedPx);
-    expect(r.heightPx).toBe(r.trimHeightPx + 2 * r.bleedPx);
-    // Sanity band around the nominal A4-at-96dpi size (~794×1123px trim).
-    expect(r.trimWidthPx).toBeGreaterThan(790);
-    expect(r.trimWidthPx).toBeLessThan(798);
-    expect(r.trimHeightPx).toBeGreaterThan(1118);
-    expect(r.trimHeightPx).toBeLessThan(1128);
-  });
-
-  test('landscape orientation swaps the resolved trim dimensions', () => {
-    const portrait = resolvePrintArtboard({ paper: 'a4', orientation: 'portrait' });
-    const landscape = resolvePrintArtboard({ paper: 'a4', orientation: 'landscape' });
-    expect(landscape.trimWidthPx).toBe(portrait.trimHeightPx);
-    expect(landscape.trimHeightPx).toBe(portrait.trimWidthPx);
-  });
-
-  test('explicit bleedMm=0 removes the bleed border entirely', () => {
-    const r = resolvePrintArtboard({ paper: 'a4', bleedMm: 0 });
-    expect(r.bleedPx).toBe(0);
-    expect(r.widthPx).toBe(r.trimWidthPx);
-    expect(r.heightPx).toBe(r.trimHeightPx);
-  });
-
-  test('margins default to 5mm on all sides when unset', () => {
-    const r = resolvePrintArtboard({ paper: 'a4' });
-    expect(r.marginsMm).toEqual({ top: 5, right: 5, bottom: 5, left: 5 });
-  });
-
-  test('partial margin override only replaces the given sides', () => {
-    const r = resolvePrintArtboard({ paper: 'a4', marginsMm: { top: 10 } });
-    expect(r.marginsMm).toEqual({ top: 10, right: 5, bottom: 5, left: 5 });
-  });
-});
-
-describe('print/units — single-source lint guard', () => {
-  const STUDIO_ROOT = join(import.meta.dir, '..');
-  const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', '_history']);
-
-  function walk(dir: string, out: string[]): string[] {
-    for (const entry of readdirSync(dir)) {
-      if (SKIP_DIRS.has(entry)) continue;
-      const full = join(dir, entry);
-      const st = statSync(full);
-      if (st.isDirectory()) walk(full, out);
-      else if (/\.(ts|tsx|mjs|jsx)$/.test(entry)) out.push(full);
-    }
-    return out;
-  }
-
-  test('the mm-per-inch conversion constant (25.4 in arithmetic) appears ONLY in print/units.ts', () => {
-    // Matches `25.4` used as a division/multiplication operand (the shape a
-    // hand-rolled mm↔px conversion would take, e.g. `mm * 96 / 25.4`) — NOT
-    // any bare occurrence of the substring, which also shows up coincidentally
-    // in unrelated numeric data (e.g. SVG path coordinates in canvas-cursors.ts).
-    const CONVERSION_SHAPE = /[*/]\s*25\.4\b|\b25\.4\s*[*/]/;
-    const files = walk(STUDIO_ROOT, []);
-    const offenders: string[] = [];
-    for (const file of files) {
-      const rel = relative(STUDIO_ROOT, file);
-      if (rel === join('print', 'units.ts')) continue;
-      if (rel === join('test', 'print-units.test.ts')) continue;
-      const text = readFileSync(file, 'utf8');
-      if (CONVERSION_SHAPE.test(text)) offenders.push(rel);
-    }
-    expect(offenders).toEqual([]);
-  });
-});