partforge 0.132.1 → 0.133.0

package/src/framework/lint/rules-sheet.js

@@ -0,0 +1,172 @@
+// Group 13 — sheet parts: sub-parts made with sheetPart() (partforge/geometry). A
+// sheet part is recognised ONLY by its plain-data `sheet` declaration
+// (isSheetPart), never by identity: in partforge-cloud's part worker the part's
+// partforge/geometry and this linter are separate module instances, so an
+// instanceof or a module-scoped Symbol would silently never match there.
+//
+// Every finding carries the guide section's id as `pattern` (SHEET_DOC_ID), and a
+// hint that stands on its own in at most 500 characters — cloud's sanitizers cut
+// message and hint there, and an agent whose copy of the guide was pruned from its
+// history still has both. Error or warning only, never a note: cloud's lint
+// sanitizer drops notes. The process registry adds each process's own rules
+// (PROCESS_LINT_RULES: the laser thickness range today); these seven hold for any
+// sheet process.
+import { err, warn } from "./finding.js";
+import { collectDescriptors } from "./rules-schema.js";
+import { SHEET_DOC_ID, isSheetPart, fmtMm } from "../sheet/constants.js";
+import { validatePose } from "../sheet/pose.js";
+import { PROCESS_IDS, PROCESS_LINT_RULES } from "../process/registry.js";
+
+const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+const partEntries = (part) => (isPlainObject(part?.parts) ? Object.entries(part.parts) : []);
+const messageOf = (e) => e?.message || String(e);
+// A number prints as itself (NaN and Infinity included, which JSON would call null);
+// anything else as JSON, which quotes a string.
+const show = (v) => (typeof v === "number" ? String(v) : v === undefined ? "undefined" : JSON.stringify(v));
+
+// What is wrong with a `sheet` declaration's SHAPE, or null. sheetPart() validates
+// every field at module load, so this only ever fires on a hand-written or
+// hand-edited declaration.
+function sheetDeclarationProblem(sheet) {
+  if (!isPlainObject(sheet)) return "sheet must be a plain object";
+  if (!PROCESS_IDS.includes(sheet.process)) return `process must be one of: ${PROCESS_IDS.join(", ")}`;
+  if (!(typeof sheet.material === "function" || (typeof sheet.material === "string" && sheet.material.trim() !== ""))) {
+    return "material must be a non-empty string or a (p, d) => string function";
+  }
+  if (!(typeof sheet.thickness === "function" || typeof sheet.thickness === "number")) {
+    return "thickness must be a number or a (p, d) => number function";
+  }
+  if (typeof sheet.profile !== "function") return "profile must be a (k, p, d) function";
+  if (sheet.score != null && typeof sheet.score !== "function") return "score must be a (k, p, d) function or null";
+  if (sheet.engrave != null && typeof sheet.engrave !== "function") return "engrave must be a (k, p, d) function or null";
+  if (!(sheet.pose == null || typeof sheet.pose === "function" || isPlainObject(sheet.pose))) {
+    return "pose must be a { face, up, at } object, a (p, d) function, or null";
+  }
+  return null;
+}
+
+// The sheet sub-parts whose VALUES the rules below judge: recognised, buildable, and
+// well-formed. A malformed declaration is sheet-invalid's one error; judging its
+// values as well would report one cause twice.
+const judgedSheets = (part) => partEntries(part).filter(([, sp]) =>
+  isSheetPart(sp) && typeof sp.build === "function" && sheetDeclarationProblem(sp.sheet) === null);
+
+// `thickness` at lint's params: { value } or { threw }.
+function thicknessAt(sheet, p, d) {
+  try { return { value: typeof sheet.thickness === "function" ? sheet.thickness(p, d) : sheet.thickness }; }
+  catch (e) { return { threw: messageOf(e) }; }
+}
+const validThickness = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+
+// The keys of `p` and `d` a thickness function reads, through recording proxies; null
+// when it throws (sheet-thickness-invalid's business).
+function thicknessReads(fn, p, d) {
+  const read = new Set();
+  const spy = (obj, tag) => new Proxy(obj ?? {}, {
+    get(target, key, receiver) {
+      if (typeof key === "string") read.add(`${tag}.${key}`);
+      return Reflect.get(target, key, receiver);
+    },
+  });
+  try { fn(spy(p, "p"), spy(d, "d")); } catch { return null; }
+  return read;
+}
+
+const HINTS = {
+  invalid: "Build laser-cut parts with `sheetPart({ material, thickness, profile, … })` from partforge/geometry instead of writing `sheet` by hand — it validates every field and supplies build and place. See \"Sheet parts\" in the authoring guide.",
+  thickness: "Bind thickness to a measured-value control, e.g. `thickness: (p) => p.t` with a `t` number control defaulting to the measured sheet thickness (plywood sold as 3 mm is often 2.7–3.3).",
+  pose: "A pose is { face, up, at }: face is the laser face's outward normal and up is the drawing's +y, each an axis word (+X, -X, +Y, -Y, +Z, -Z), perpendicular to each other; at is where drawing [0, 0] lands. A box's front panel: { face: \"-Y\", up: \"+Z\", at: [-W/2, -D/2, 0] }. fingerBox() computes every panel's pose.",
+  literal: "Sheet stock varies ±0.3–0.5 mm from its nominal size; bind thickness to the measured-value control (thickness: (p) => p.t, with a t control the user sets to what they measured) so every joint fits the sheet they actually have.",
+  kerf: "Kerf is chosen when the cut & print kit is downloaded (it offsets the cut lines only), so a kerf control double-counts it. Use a clearance control instead: joinery clearance is the finished joint's total play.",
+  customBuild: "The cut file is drawn from profile, score and engrave, never from build, so a custom build can drift from what gets cut; verify compares its volume with the profile (sheetSolidMatch). Change the profile, not the solid.",
+  sheetsOnly: "A process profile checks 3D-printed parts (bed fit, min wall); sheet parts get the laser checks automatically. Remove verify.process, or keep it only when the forge also has printed parts. There is no \"laser\" profile.",
+};
+
+export const SHEET_RULES = [
+  {
+    // Skipped when `build` is missing: no-buildable-parts owns that case, and its hint
+    // already points at sheetPart(), so one cause never gives two blocking errors.
+    id: "sheet-invalid",
+    run: ({ part }) => partEntries(part)
+      .filter(([, sp]) => isPlainObject(sp) && sp.sheet !== undefined && typeof sp.build === "function")
+      .flatMap(([name, sp]) => {
+        const reason = sheetDeclarationProblem(sp.sheet);
+        return reason ? [err("sheet-invalid", `sub-part "${name}" has a malformed \`sheet\` declaration: ${reason}`,
+          HINTS.invalid, `parts.${name}.sheet`, SHEET_DOC_ID)] : [];
+      }),
+  },
+  {
+    id: "sheet-thickness-invalid",
+    run: ({ part, p, d, deriveError }) => (deriveError ? [] : judgedSheets(part).flatMap(([name, sp]) => {
+      const t = thicknessAt(sp.sheet, p, d);
+      if ("threw" in t) {
+        return [err("sheet-thickness-invalid", `sub-part "${name}": sheet thickness threw at the defaults: ${t.threw}`,
+          HINTS.thickness, `parts.${name}.sheet.thickness`, SHEET_DOC_ID)];
+      }
+      return validThickness(t.value) ? [] : [err("sheet-thickness-invalid",
+        `sub-part "${name}": sheet thickness is ${show(t.value)} at the defaults — it must be a finite number above 0 (mm)`,
+        HINTS.thickness, `parts.${name}.sheet.thickness`, SHEET_DOC_ID)];
+    })),
+  },
+  {
+    // A pose function that throws, or returns nothing, is left to the build rules:
+    // the generated build resolves the pose, so build-throws already names it.
+    id: "sheet-pose-invalid",
+    run: ({ part, p, d, deriveError }) => (deriveError ? [] : judgedSheets(part).flatMap(([name, sp]) => {
+      const raw = sp.sheet.pose;
+      if (raw == null) return [];
+      let pose;
+      try { pose = typeof raw === "function" ? raw(p, d) : raw; } catch { return []; }
+      if (pose == null) return [];
+      const reason = validatePose(pose);
+      return reason ? [err("sheet-pose-invalid", `sub-part "${name}": sheet pose is invalid at the defaults — ${reason}`,
+        HINTS.pose, `parts.${name}.sheet.pose`, SHEET_DOC_ID)] : [];
+    })),
+  },
+  {
+    id: "sheet-thickness-literal",
+    run: ({ part, p, d, deriveError }) => (deriveError ? [] : judgedSheets(part).flatMap(([name, sp]) => {
+      const t = thicknessAt(sp.sheet, p, d);
+      if ("threw" in t || !validThickness(t.value)) return [];   // sheet-thickness-invalid's
+      if (typeof sp.sheet.thickness === "function") {
+        const read = thicknessReads(sp.sheet.thickness, p, d);
+        if (read === null || read.size > 0) return [];
+      }
+      return [warn("sheet-thickness-literal", `sub-part "${name}": sheet thickness is a fixed number (${fmtMm(t.value)} mm)`,
+        HINTS.literal, `parts.${name}.sheet.thickness`, SHEET_DOC_ID)];
+    })),
+  },
+  {
+    id: "sheet-kerf-control",
+    run: ({ part }) => {
+      if (!partEntries(part).some(([, sp]) => isSheetPart(sp))) return [];
+      return collectDescriptors(part)
+        .filter(({ d: c, container }) => !container && c && [c.key, c.label].some((v) => typeof v === "string" && /kerf/i.test(v)))
+        .map(({ d: c, path }) => warn("sheet-kerf-control", `control "${c.key ?? c.label}" looks like a kerf setting`,
+          HINTS.kerf, path, SHEET_DOC_ID));
+    },
+  },
+  {
+    id: "sheet-custom-build",
+    run: ({ part }) => judgedSheets(part)
+      .filter(([, sp]) => sp.build !== sp.sheet.generatedBuild)
+      .map(([name]) => warn("sheet-custom-build", `sub-part "${name}" replaces the build sheetPart generated`,
+        HINTS.customBuild, `parts.${name}.build`, SHEET_DOC_ID)),
+  },
+  {
+    // A process id ("laser") is verify-unknown-process's error, with a sheet hint of
+    // its own — not also this warning.
+    id: "verify-process-sheets-only",
+    run: ({ part }) => {
+      const process = part?.verify?.process;
+      if (!process) return [];
+      if (typeof process === "string" && PROCESS_IDS.includes(process)) return [];
+      const exportable = partEntries(part).filter(([, sp]) => isPlainObject(sp) && sp.exportable !== false);
+      if (exportable.length === 0 || !exportable.every(([, sp]) => isSheetPart(sp))) return [];
+      const named = typeof process === "string" ? `"${process}"` : "an inline profile";
+      return [warn("verify-process-sheets-only", `\`verify.process\` is ${named}, but every exportable part is a sheet part`,
+        HINTS.sheetsOnly, "verify.process", SHEET_DOC_ID)];
+    },
+  },
+  ...PROCESS_LINT_RULES,
+];

package/src/framework/lint/rules-verify.js

@@ -7,6 +7,8 @@ import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
 import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
 import { parseAssertion } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
+import { PROCESS_IDS } from "../process/registry.js";
+import { SHEET_DOC_ID } from "../sheet/constants.js";
 
 // Resolve `expect` to a plain object. The function form (p, d) => ({…}) is invoked
 // once with the probe's params so per-preset topology can be linted like any other.
@@ -157,6 +159,14 @@ function checkProcessSpec(spec, path, valid, seen, depth = 0) {
   if (depth > 50) return []; // pathological chain — bail rather than hang
   if (typeof spec === "string") {
     if (valid.includes(spec)) return [];
+    // A manufacturing-process id ("laser") is not a DFM profile: sheet parts get their
+    // checks from sheetPart(), and verify.process is for printing.
+    if (PROCESS_IDS.includes(spec)) {
+      return [err("verify-unknown-process",
+        `\`${path}\` names "${spec}", which is not a known DFM profile`,
+        `Laser-cut parts need no profile: build them with \`sheetPart()\` and the laser checks apply automatically (see "Sheet parts" in the authoring guide). verify.process is for 3D-printed parts — use one of: ${valid.join(", ")}.`,
+        path, SHEET_DOC_ID)];
+    }
     const hint = suggest(spec, valid);
     return [err("verify-unknown-process",
       `\`${path}\` names "${spec}", which is not a known DFM profile`,

package/src/framework/oracle/gates.js

@@ -61,6 +61,19 @@ export function partGatesMinWall(part, { process, expanded } = {}) {
   }
 }
 
+// Whether a verify of this part fits a process profile's print BED — the only reader of
+// measure()'s print-pose sizes in a view holding a sheet part. `process` is verify's own
+// override, else the part's `verify.process`. Unresolvable → true: measure the sizes
+// and let verify report the bad profile.
+export function partHasBed(part, { process } = {}) {
+  try {
+    const spec = process ?? part?.verify?.process;
+    return !!(spec && resolveProfile(spec)?.bed);
+  } catch {
+    return true;
+  }
+}
+
 // The wall bands a measurement of `params` must track, per sub-part, from the part's
 // own `verify.expect` — resolved for exactly these params (a function expect may
 // change the band per case). Range form only: the membership window needs both ends.

package/src/framework/oracle/measure.js

@@ -1,12 +1,17 @@
 import { buildView } from "./build.js";
 import { cachedBVH } from "./bvh.js";
 import { assemblyOverlaps } from "../assembly.js";
-import { resolveParams } from "../part-model.js";
+import { resolveParams, buildPosed } from "../part-model.js";
+import { probeSubPartPose } from "../pose-probe-core.js";
+import { composePose } from "../geometry/pose.js";
+import { isSheetPart, sheetMeta, SHEET_CHECK_BUDGET_MS, MARK_DEPTH } from "../sheet/constants.js";
+import { resolveSheet } from "../sheet/resolve.js";
+import { processFor } from "../process/registry.js";
 import { meshGaps, pairKey, CONTACT_EPS, GAP_THRESHOLD } from "./gaps.js";
 import { bounds, meshArea, meshCentroid } from "./mesh.js";
 import { minWall, DIAGNOSTIC_SAMPLES } from "./min-wall.js";
 import { overhang } from "./overhang.js";
-import { partGatesMinWall, partOverhangAngle, partWallBands } from "./gates.js";
+import { partGatesMinWall, partHasBed, partOverhangAngle, partWallBands } from "./gates.js";
 import { summarizeContours } from "./shape-probe.js";
 
 const size = ({ min, max }) => [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
@@ -107,6 +112,98 @@ function evaluateProbes(kernel, part, params) {
   } finally { kernel.endSubPart?.(); }
 }
 
+// ── sheet parts ──────────────────────────────────────────────────────────────
+// A sub-part made with sheetPart() (partforge/geometry) is recognised by its
+// plain-data `sheet` declaration alone (isSheetPart) — never by identity: in
+// partforge-cloud's part worker the part's partforge/geometry and this oracle are
+// separate module instances. Its checks are 2-D: its process's facts() reads the
+// resolved profile, score and engrave through Shape2D methods. The 3-D parts are
+// here — where a finding sits in the assembly, and a custom build's volume drift.
+
+// A column-major mat4 (geometry/pose.js composePose) applied to one point.
+const transformPoint = (m, [x, y, z]) => [
+  m[0] * x + m[4] * y + m[8] * z + m[12],
+  m[1] * x + m[5] * y + m[9] * z + m[13],
+  m[2] * x + m[6] * y + m[10] * z + m[14],
+];
+
+// One sheet row's facts, within `budget.left` ms of 2-D work, which it spends (see
+// measure()). A 2-D location is lifted through the sub-part's DISPLAY pose, as the geometry-free
+// probe records it, at mid-thickness; a pose the probe cannot trust (a place() that
+// queries geometry) leaves `at` null and keeps the 2-D reading. Null for a process
+// id no descriptor answers to (lint's sheet-invalid reports that) is still a sheet —
+// measure and verify ask the same question, isSheetPart — with nothing to check it by:
+// unknownProcessFacts.
+function sheetRowFacts(kernel, part, name, view, { p, d }, budget, volume) {
+  const sp = part.parts[name];
+  const proc = processFor(sp);
+  if (!proc) return unknownProcessFacts(kernel, sp, p, d);
+  const resolved = resolveSheet(kernel, sp, p, d);
+  const start = budget.now();
+  const f = proc.facts(resolved, { deadline: start + budget.left, now: budget.now });
+  budget.left -= budget.now() - start;
+  const probe = probeSubPartPose(sp, { view, purpose: "display", p, d });
+  const m = probe.trusted ? composePose(probe.pose) : null;
+  const lift = (uv) => (m && uv ? transformPoint(m, [uv[0], uv[1], f.thickness / 2]) : null);
+  const expected = f.area * f.thickness - MARK_DEPTH * (f.marksArea ?? 0);
+  return {
+    ...f,
+    at: { bridge: lift(f.at2d.bridge), gap: lift(f.at2d.gap), marks: lift(f.at2d.marks) },
+    solidMatchPct: f.customBuild && f.marksArea != null && expected > 1e-9
+      ? (100 * Math.abs(volume - expected)) / expected
+      : null,
+  };
+}
+
+// A sheet whose process no descriptor answers to: what can be read without one (the
+// cut layer's size, area and pieces, when the declaration resolves at all), and no
+// reading — `evaluated` false.
+function unknownProcessFacts(kernel, sp, p, d) {
+  const meta = sheetMeta(sp, p, d);
+  let flat = [0, 0], area = 0, pieces = 0;
+  try {
+    const { profile } = resolveSheet(kernel, sp, p, d);
+    pieces = profile.toContours().length;
+    if (pieces) {
+      const { min, max } = profile.boundingBox();
+      flat = [max[0] - min[0], max[1] - min[1]];
+      area = profile.area();
+    }
+  } catch { /* a declaration that does not resolve: sizes stay zero */ }
+  return {
+    process: sp.sheet.process, material: meta?.material ?? null, thickness: meta?.thickness ?? null, group: meta?.group ?? null,
+    flat, area, pieces, customBuild: sp.build !== sp.sheet.generatedBuild,
+    marksArea: null, bridge: null, bridgeCapped: false, gap: null, gapCapped: false, marksOutside: null, solidMatchPct: null,
+    at2d: { bridge: null, gap: null, marks: null }, at: { bridge: null, gap: null, marks: null },
+    readErrors: { bridge: null, gap: null, marks: null, marksArea: null },
+    evaluated: false,
+  };
+}
+
+// The size of every PRINTED sub-part in its print (export) pose — what verify fits the
+// process profile's bed to in a view holding a sheet part: laser-cut stock never meets
+// a print bed, and a printed part is routinely displayed in an assembly pose that is
+// not how it prints. Its own cache round, like evaluateProbes: export-pose geometry
+// must not evict the view's. One part at a time: an export pose that does not build
+// costs that part its size ({ error }, which verify reports), never the report.
+function printPoseBboxes(kernel, part, view, built, { p, d }) {
+  kernel.beginSubPart?.(`oracle:print:${view}`);
+  try {
+    const out = {};
+    for (const { name } of built) {
+      const sp = part.parts[name];
+      if (sp?.exportable === false || isSheetPart(sp)) continue;
+      try {
+        const { min, max } = buildPosed(kernel, part, name, { purpose: "export", view, p, d }).boundingBox();
+        out[name] = { size: [max[0] - min[0], max[1] - min[1], max[2] - min[2]] };
+      } catch (e) {
+        out[name] = { error: String(e?.message || e).slice(0, 200) };
+      }
+    }
+    return out;
+  } finally { kernel.endSubPart?.(); }
+}
+
 // Headless geometric report for one view of a part (Manifold-only). Reads exact
 // solid facts (volume/genus/emptiness) and mesh facts (bbox/area/triangles), plus
 // the assembly overlap check plus pair gap distances (near misses are reported,
@@ -155,12 +252,29 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // taken against the wrong threshold is worse than none.
   const overhangAngle = opts.overhang !== undefined ? opts.overhang : partOverhangAngle(part);
   const subBounds = [];
+  // Sheet parts: a view holding one sizes each printed sub-part in its print pose
+  // (verify fits the bed per part there), and every sheet row gets its 2-D facts under
+  // ONE budget for the whole call, charged for 2-D work alone: each sheet's facts() is
+  // timed and the next is given what is left, so neither a slow build nor a printed
+  // row's min-wall rays between two sheets spend it (the verdict used to depend on
+  // declaration order). A view without a sheet part measures exactly as it always has.
+  const sheetView = built.some(({ name }) => isSheetPart(part.parts[name]));
+  const sheetParams = sheetView ? resolveParams(part, params) : null;
+  // The print-pose sizes are read by one check, the process bed (verify passes whether
+  // its profile has one; alone, measure asks the part's own profile), and each costs a
+  // second build of the part — so they are built only for a bed.
+  const measuredPrintBboxes = sheetView && (opts.printBboxes ?? partHasBed(part));
+  const printBboxes = measuredPrintBboxes ? printPoseBboxes(kernel, part, view, built, sheetParams) : null;
+  // The clock the budget runs on is Date.now, or a test's own (opts.now).
+  const sheetBudget = { left: opts.sheetBudgetMs ?? SHEET_CHECK_BUDGET_MS, now: opts.now ?? Date.now };
   const subparts = built.map(({ name, solid, mesh }) => {
+    const sheet = isSheetPart(part.parts[name]);
     const b = bounds(mesh.positions);
     subBounds.push(b);
     // Resolved lazily and only when asked for: without min-wall, a single-sub-part
-    // view (no meshGaps) must still build no index at all.
-    const mw = opts.minWall
+    // view (no meshGaps) must still build no index at all. A sheet part casts none:
+    // min wall is a print rule, and its laser checks read the 2-D profile instead.
+    const mw = opts.minWall && !sheet
       ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples, band: wallBands[name] ?? null })
       : null;
     // One pass over the triangles, no index — cheap enough for every lap. The bed
@@ -169,7 +283,8 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // slab, a placeholder) is not judged. Judged in the DISPLAY pose, which is
     // what measure builds; a part whose export pose differs (a lid that prints
     // flat beside its base) is a known gap, stated in the authoring docs.
-    const printed = part.parts[name]?.exportable !== false;
+    // A sheet part is laser-cut, never printed: no overhang reading for it either.
+    const printed = part.parts[name]?.exportable !== false && !sheet;
     const oh = overhangAngle != null && printed ? overhang(mesh, { maxAngle: overhangAngle, bedZ: b.min[2] }) : null;
     const vol = solid.volume();
     // Deviation-from-reference: only for a sub-part that declares `reference:
@@ -223,6 +338,12 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       overhangArea: oh ? oh.area : null,
       overhangAngle: oh?.worstAngle ?? null,
       overhangAt: oh?.at ?? null,
+      // The process's 2-D facts on a sheet part (sheetRowFacts), null on every other.
+      sheet: sheet
+        ? sheetRowFacts(kernel, part, name, view, sheetParams, sheetBudget, vol)
+        : null,
+      ...(printBboxes?.[name]?.size ? { printBbox: printBboxes[name].size } : {}),
+      ...(printBboxes?.[name]?.error ? { printBboxError: printBboxes[name].error } : {}),
     };
   });
 
@@ -289,6 +410,9 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // Companion stamp to measuredMinWall, and read the same way: whether the pass
     // ran, said by the pass itself rather than claimed by whoever holds the result.
     measuredGaps,
+    // In a view holding a sheet part: whether the print-pose sizes were built (verify
+    // reuses a seed for a bed only when they were). Absent everywhere else.
+    ...(sheetView ? { measuredPrintBboxes } : {}),
     subparts,
     aggregate,
     overlaps,

package/src/framework/oracle/verify.js

@@ -6,6 +6,10 @@ import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "../param-deps.js";
 import { byteAwareReplacer } from "../geometry/solid-hash.js";
 import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
+import { processById } from "../process/registry.js";
+import { SHEET_DOC_ID, SHEET_CHECKS_NOTICE, SHEET_READ_ERROR_HINT } from "../sheet/constants.js";
+// Re-exported for the callers that read them from here; their one home is sheet/constants.js.
+export { SHEET_CHECKS_NOTICE, SHEET_READ_ERROR_HINT } from "../sheet/constants.js";
 
 // Re-exported for backwards compatibility: the registries moved to framework/ so
 // the linter can read the metric vocabulary without importing a geometry kernel.
@@ -160,13 +164,95 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
   if (note) out.note = note;
   if (!pass) {
     out.hint = partHint ?? reg.hint;
-    if (reg.pattern) out.pattern = reg.pattern;
+    // `pattern` names an ERROR-PATTERNS.md entry; a sheet metric names the guide
+    // section instead (`doc: "sheet-parts"`), which rides the same field.
+    const pattern = reg.pattern ?? reg.doc;
+    if (pattern) out.pattern = pattern;
     const loc = reg.locate?.(factsObj);
     if (loc) out.location = loc;
   }
   return out;
 }
 
+// ── sheet parts ──────────────────────────────────────────────────────────────
+// A view holding a sheet part (sheetPart(), partforge/geometry — measure() stamps
+// its row with `sheet`) is judged per part: the process profile's bed fits each
+// PRINTED sub-part in its print pose (measure()'s `printBbox`), since laser-cut stock
+// never meets a print bed; a sheet part gets only what the part declared for it, plus
+// its process's own checks VOLUNTEERED. A volunteered check is a fact the oracle
+// offers, exactly like an undeclared near miss: it warns when it fails and never
+// counts toward `declared`/`evaluated` (isDeclared, in verify() below), so it can
+// never make verify.ok true on its own — without that, a sheet-only part with no
+// verify block would jump from "no expectations declared" to a pass.
+const PRINT_POSE_NOTE = "measured in the print (export) pose";
+
+// SHEET_CHECKS_NOTICE (sheet/constants.js) stands in for a sheet's budget-gated
+// volunteered checks when its 2-D budget ran out (measure()'s `sheet.evaluated` false):
+// one warning, never `unevaluated` — a check nobody declared must not withhold a verdict.
+
+// A DECLARED sheet check the budget withheld: `unevaluated`, as a quick lap's is, so it
+// withholds verify.ok — and it says how to get a verdict. Either the budget ran out
+// before this check, or the profile was priced too complex to start the checks at all
+// (process/laser/descriptor.js); the hint covers both, as the notice's does.
+const SHEET_BUDGET_HINT = "The 2-D sheet checks did not fit their time budget — it ran out before this check, or the profile was too complex to start them — so this check has no verdict and verify.ok is withheld. What they spend time on is edges, curved ones most: round holes crowded close to each other or to an edge, and corners rounded tighter than about the sheet thickness, cost the most.";
+
+// The print checks: measure() casts no rays and runs no overhang pass on a sheet part.
+// Declared on one, each is a skip — declared, never evaluated, so a sheet-only forge
+// that declares only these has no verdict rather than a vacuous pass.
+const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea"]);
+const PRINT_ONLY_HINT = "minWall, wall and overhangArea are print checks, and a sheet part is cut, not printed: nothing measures them here. For a laser part declare sheetBridge (the narrowest web or finger) or sheetGap (the narrowest hole or slot) instead.";
+
+// A sheet reading the geometry engine could not take (SheetFacts.readErrors): a
+// volunteered check warns with the reason; a declared one warns with it too, and is
+// `unevaluated`, so it withholds verify.ok exactly as a budget-withheld one does. As a bare
+// skip it counted neither way, and one other declared check that passed made verify.ok true
+// over a check that was never taken — the rule at the top of this file, a declared gate
+// fails loudly and never skips.
+// On a valid profile a read error is the checker's own limit, so the hint
+// (SHEET_READ_ERROR_HINT, sheet/constants.js — the kit's README repeats it, and it stays
+// one text) never blames the contour first.
+
+// One sheet row: the declared expectations, then the process's checks the part did
+// not declare, volunteered.
+function sheetRowChecks(s, declaredExp) {
+  const out = [];
+  const proc = processById(s.sheet.process);
+  const outOfTime = s.sheet.evaluated === false;
+  const budgeted = (metric) => SUBPART_METRICS[metric]?.budgeted === true;
+  const unread = (c, metric) => (c.actual == null ? SUBPART_METRICS[metric]?.readError?.(s) ?? null : null);
+  const readFailure = (c, why) => ({ ...c, message: `not measured — ${why}`, hint: SHEET_READ_ERROR_HINT, pattern: SHEET_DOC_ID });
+  for (const [metric, expr] of Object.entries(declaredExp)) {
+    const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
+    if (PRINT_ONLY.has(metric)) {
+      out.push({ scope: c.scope, subpart: c.subpart, metric, kind: c.kind, expr: c.expr, actual: null, status: "skip", pass: null,
+        message: "not measured on a sheet part", hint: PRINT_ONLY_HINT, pattern: SHEET_DOC_ID });
+    } else if (!proc && c.actual == null) {
+      // A sheet naming no registered process (lint's sheet-invalid): nothing reads it.
+      out.push({ ...c, status: "skip", pass: null, message: `not measured: no "${s.sheet.process}" process`,
+        hint: "This sheet part names a process partforge does not know, so no sheet check reads it; lint's sheet-invalid says which. Use sheetPart() with a known process.", pattern: SHEET_DOC_ID });
+    } else if (outOfTime && budgeted(metric) && c.actual == null) {
+      out.push({ ...c, status: "skip", pass: null, unevaluated: true, message: "not evaluated (2-D check budget)",
+        hint: SHEET_BUDGET_HINT, pattern: SHEET_DOC_ID });
+    } else {
+      const why = unread(c, metric);
+      out.push(why ? readFailure({ ...c, status: "warn", pass: null, unevaluated: true }, why) : c);
+    }
+  }
+  let noticed = false;
+  for (const [metric, expr] of Object.entries(proc?.checks(s.sheet) ?? {})) {
+    if (Object.hasOwn(declaredExp, metric)) continue;
+    if (outOfTime && budgeted(metric)) {
+      if (!noticed) out.push({ scope: "subpart", subpart: s.name, ...SHEET_CHECKS_NOTICE });
+      noticed = true;
+      continue;
+    }
+    const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
+    const why = unread(c, metric);
+    out.push({ ...(why ? readFailure({ ...c, status: "warn", pass: null }, why) : c), volunteered: true });
+  }
+  return out;
+}
+
 // Pure policy: profile rules + per-part expect → checks for one case's facts.
 // `overhang` is the angle the part opted into (dfm-profiles.js overhangAngleFor),
 // or null/undefined: only then does the profile's overhang rule apply, as a
@@ -176,8 +262,12 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
   // contacts/clearance are per-pair, not scalar view metrics — peel them off
   // before the registry loop and hand them to pairGapChecks.
   const { contacts, clearance, ...viewScalarExp } = expect?._view ?? {};
+  // No sheet part in the view: every line below runs exactly as it did before sheet
+  // parts existed (test/verify-golden.test.js). With one, the bed moves from the view
+  // to each printed sub-part — see the sheet-parts block above.
+  const anySheet = facts.subparts.some((s) => s.sheet);
   const viewExp = {
-    ...(profile?.bed ? { bbox: `<=[${profile.bed.join(",")}]` } : {}),
+    ...(profile?.bed && !anySheet ? { bbox: `<=[${profile.bed.join(",")}]` } : {}),
     ...viewScalarExp,
   };
   for (const [metric, expr] of Object.entries(viewExp)) checks.push(check("view", null, metric, expr, VIEW_METRICS, facts));
@@ -193,6 +283,16 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
   // is withheld rather than read as "unavailable" — which would count as answered.
   const overhangSkipped = overhang != null && (facts.measuredOverhang ?? null) === null;
   for (const s of facts.subparts) {
+    if (s.sheet) { checks.push(...sheetRowChecks(s, expect?.[s.name] ?? {})); continue; }
+    if (anySheet && profile?.bed && s.printBbox) {
+      checks.push({ ...check("subpart", s.name, "bbox", `<=[${profile.bed.join(",")}]`, SUBPART_METRICS, { ...s, bbox: s.printBbox }),
+        note: PRINT_POSE_NOTE });
+    } else if (anySheet && profile?.bed && s.printBboxError) {
+      checks.push({ scope: "subpart", subpart: s.name, metric: "bbox", kind: "gate", expr: `<=[${profile.bed.join(",")}]`,
+        actual: null, status: "skip", pass: null, unevaluated: true, note: PRINT_POSE_NOTE,
+        message: `not measured: its print (export) pose did not build — ${s.printBboxError}`,
+        hint: "This printed part's place() failed for purpose \"export\", so its print size — and its STL/3MF export — is unavailable. Fix place() for the export pose; the bed check then runs." });
+    }
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
@@ -299,7 +399,12 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // changes the angle therefore re-measures rather than reusing the inspect
   // job's seed, which was taken against the part's own profile.
   const overhangMatches = (seed?.result?.measuredOverhang ?? null) === (overhangAngle ?? null);
-  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && seed.result.view === view) {
+  // The print-pose half (views holding a sheet part): a seed measured without the print
+  // sizes cannot answer a bed, so it is admitted only when this run needs no bed.
+  const needPrintBboxes = profile?.bed != null;
+  const printBboxesMatch = !needPrintBboxes || seed?.result?.measuredPrintBboxes !== false;
+  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && printBboxesMatch
+    && seed.result.view === view) {
     memo.set(signature({ ...part.defaults, ...(seed.params ?? {}) }), seed.result);
   }
 
@@ -310,7 +415,8 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     // `probes: false` — no gate reads probe values, so re-running their booleans
     // for every case buys nothing. (A seed measured WITH probes is a superset in
     // the same way a min-wall seed is: the extra key is simply never read here.)
-    memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall, probes: false, overhang: overhangAngle }));
+    memo.set(key, measureFn(kernel, part, view, params,
+      { minWall: needMinWall, probes: false, overhang: overhangAngle, printBboxes: needPrintBboxes }));
     return memo.get(key);
   };
 
@@ -352,7 +458,9 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // deliberately NOT pushed into any case's check list — it is about the part,
   // not about `defaults`. A quick lap that withheld gates explains itself through
   // `unevaluated` and gets no notice.
-  const isDeclared = (c) => c.scope !== "case" && c.metric !== "nearMiss";
+  // Volunteered checks (a sheet part's process checks, and the budget notice standing
+  // in for them) are facts the oracle offers, like an undeclared near miss.
+  const isDeclared = (c) => c.scope !== "case" && c.metric !== "nearMiss" && !c.volunteered;
   const all = caseResults.flatMap((c) => c.checks.map((ch) => ({ case: c.name, ...ch })));
   let declared = 0, evaluated = 0;
   for (const c of all) {