partforge 0.163.0 → 0.164.0

package/src/framework/oracle/verify.js

@@ -2,7 +2,7 @@ import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
 import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { heldCheck } from "./held.js";
-import { resolveProfile, overhangAngleFor, bedContactFor } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor, bedContactFor, footprintFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { relevanceHash } from "../param-deps.js";
 import { SUBPART_METRICS, VIEW_METRICS, sidesSpecError } from "../verify-metrics.js";
@@ -121,12 +121,13 @@ function pairGapChecks(facts, { contacts, clearance }, subPartNames) {
   return checks;
 }
 
-function check(scope, subpart, metric, spec, registry, factsObj) {
+function check(scope, subpart, metric, spec, registry, factsObj, accept = []) {
   const reg = registry[metric];
   if (!reg) throw new Error(`unknown ${scope} metric "${metric}"${subpart ? ` on sub-part "${subpart}"` : ""}`);
   const { expr, hint: partHint } = normalizeExpectation(spec);
   const actual = reg.extract(factsObj);
-  const base = { scope, subpart, metric, kind: reg.kind, expr: String(expr) };
+  const base = { scope, subpart, metric, kind: reg.kind, expr: String(expr),
+    ...(reg.kind === "cost" ? { accepted: accept.includes(reg.costId) } : {}) };
   if (actual === null || actual === undefined) {
     if (reg.manifoldOnly) return { ...base, actual, status: "skip", pass: null, message: "n/a (OCCT backend)" };
     if (metric === "minWall") {
@@ -156,7 +157,7 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
     return { ...base, actual, status: "skip", pass: null, message: "unavailable" };
   }
   const { pass, message } = evaluateAssertion(parseAssertion(expr), actual);
-  const status = pass ? "pass" : reg.kind === "warn" ? "warn" : "fail";
+  const status = pass ? "pass" : reg.kind === "warn" ? "warn" : reg.kind === "cost" ? "cost" : "fail";
   const out = { ...base, actual, status, pass, message };
   // A measurement caveat rides along whatever the verdict — a min-wall reading
   // taken from a sample still passed, but the reader should know it was a sample.
@@ -178,14 +179,14 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
 // (`bounds: { min, max }` → `bounds.min`, `bounds.max`), each judged by `check()` against
 // its side's own registry entry. A malformed compound value throws, as a malformed
 // expression does.
-function checksFor(scope, subpart, metric, spec, registry, factsObj) {
+function checksFor(scope, subpart, metric, spec, registry, factsObj, accept = []) {
   const reg = registry[metric];
-  if (!reg?.sides) return [check(scope, subpart, metric, spec, registry, factsObj)];
+  if (!reg?.sides) return [check(scope, subpart, metric, spec, registry, factsObj, accept)];
   const bad = sidesSpecError(metric, reg, spec);
   if (bad) throw new Error(`${scope === "view" ? "_view" : subpart}: ${bad}`);
   return Object.entries(spec).map(([side, sideSpec]) => {
     const name = `${metric}.${side}`;
-    return check(scope, subpart, name, sideSpec, { [name]: reg.sides[side] }, factsObj);
+    return check(scope, subpart, name, sideSpec, { [name]: reg.sides[side] }, factsObj, accept);
   });
 }
 
@@ -214,8 +215,8 @@ const SHEET_BUDGET_HINT = "The 2-D sheet checks did not fit their time budget
 // 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", "bedContactPct"]);
-const PRINT_ONLY_HINT = "minWall, wall, overhangArea and bedContactPct 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.";
+const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea", "bedContactPct", "footprintPct"]);
+const PRINT_ONLY_HINT = "minWall, wall, overhangArea, bedContactPct and footprintPct 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
@@ -268,12 +269,16 @@ function sheetRowChecks(s, declaredExp) {
 }
 
 // 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
-// 1 mm² warning floor — a chamfer sitting exactly on the angle sheds slivers.
+// `overhang` is the angle the part's process arms (dfm-profiles.js overhangAngleFor),
+// or null/undefined: only then does the profile's overhang rule apply, as a 1 mm²
+// cost — a chamfer sitting exactly on the angle sheds slivers.
 // `bedContact` is the floor the part is checked against (dfm-profiles.js bedContactFor),
 // or null/undefined: only then does every PRINTED sub-part get `bedContactPct >= floor`.
-export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null }) {
+// `footprint` the same for the footprint cost (dfm-profiles.js footprintFor):
+// `footprintPct >= floor` on every printed sub-part.
+// `accept` the cost ids the user accepted (`verify.accept`), stamped on each cost the
+// process volunteered (never on one the author wrote in `expect`).
+export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null, footprint = null, accept = [] }) {
   const checks = [];
   // contacts/clearance/held are pair-derived, not scalar view metrics — peel
   // them off before the registry loop. held.js explains the exportable bound.
@@ -301,6 +306,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
   // is withheld rather than read as "unavailable" — which would count as answered.
   const overhangSkipped = overhang != null && (facts.measuredOverhang ?? null) === null;
   const bedContactSkipped = bedContact != null && facts.measuredBedContact !== true;
+  const footprintSkipped = footprint != null && facts.measuredFootprint !== true;
   // A piece that is never printed (`exportable: false`) is not judged for bed contact;
   // the floor is applied to the rest. Without the vocabulary, every row is printed.
   const printedNames = exportableNames ? new Set(exportableNames) : null;
@@ -319,9 +325,14 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
       ...(bedContact != null && (!printedNames || printedNames.has(s.name)) ? { bedContactPct: `>=${bedContact}` } : {}),
+      ...(footprint != null && (!printedNames || printedNames.has(s.name)) ? { footprintPct: `>=${footprint}` } : {}),
       ...(expect?.[s.name] ?? {}),
     };
-    for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s)) {
+    // `accept` covers only the process's own default check: a cost metric the author
+    // wrote in `expect` is the user's own limit and keeps its meaning, never accepted.
+    const authored = expect?.[s.name] ?? {};
+    const acceptFor = (metric) => (Object.hasOwn(authored, metric) ? [] : accept);
+    for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s, acceptFor(metric))) {
       if (minWallSkipped && (metric === "minWall" || metric === "wall") && c.actual == null) {
         checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
           hint: `re-run this check without \`quick\` to measure ${metric === "wall" ? "the wall band" : "min wall"}` });
@@ -332,10 +343,11 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
           hint: "re-run this check without `quick` to measure overhang" });
         continue;
       }
-      if (metric === "bedContactPct" && c.actual == null && s.bedContactError) {
+      // The footprint is read by bed contact's pass, so it is withheld the same ways.
+      if ((metric === "bedContactPct" || metric === "footprintPct") && c.actual == null && s.bedContactError) {
         checks.push({ ...c, status: "skip", pass: null, unevaluated: true,
           message: `not measured: its print (export) pose did not build — ${s.bedContactError}`,
-          hint: "bed contact is read in the print pose, and this piece's could not be posed by its place() alone, so its export build was read instead — and that build failed. Fix the export pose; the check then runs." });
+          hint: `${metric === "footprintPct" ? "the footprint" : "bed contact"} is read in the print pose, and this piece's could not be posed by its place() alone, so its export build was read instead — and that build failed. Fix the export pose; the check then runs.` });
         continue;
       }
       if (bedContactSkipped && metric === "bedContactPct" && c.actual == null) {
@@ -343,6 +355,11 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
           hint: "re-run this check without `quick` to measure bed contact" });
         continue;
       }
+      if (footprintSkipped && metric === "footprintPct" && c.actual == null) {
+        checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
+          hint: "re-run this check without `quick` to measure the footprint" });
+        continue;
+      }
       checks.push(c);
     }
   }
@@ -372,6 +389,8 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // Throws on a bad `verify.orientation`, the same loudness as a bad profile name.
   const overhangAngle = overhangAngleFor(part, process, { expanded });
   const bedContactFloor = bedContactFor(part, process, { expanded });
+  const footprintFloor = footprintFor(part, process, { expanded });
+  const accept = Array.isArray(part?.verify?.accept) ? part.verify.accept : [];
   // Reuse rule (spec §4): case B may reuse a measurement taken at params A when
   // B agrees with A on every param that measurement READ (recorded by measure()
   // itself). Sound for the same reason the mesh cache is: a deterministic build
@@ -437,7 +456,10 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   const overhangMatches = (seed?.result?.measuredOverhang ?? null) === (overhangAngle ?? null);
   // Bed contact's half: a seed that skipped the pass cannot answer an armed gate. The
   // reverse (a seed that ran it, for a run that does not need it) is a free superset.
-  const bedContactMatches = bedContactFloor == null || seed?.result?.measuredBedContact === true;
+  // The footprint cost rides the same pass, so either floor needs it.
+  // measure() reads `bedContact` only as "run the pass", so either floor arms it.
+  const armsBedPass = bedContactFloor ?? footprintFloor;
+  const bedContactMatches = armsBedPass == null || seed?.result?.measuredBedContact === true;
   // 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;
@@ -456,7 +478,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     // 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.)
     const result = measureFn(kernel, part, view, params,
-      { minWall: needMinWall, probes: false, overhang: overhangAngle, bedContact: bedContactFloor, printBboxes: needPrintBboxes });
+      { minWall: needMinWall, probes: false, overhang: overhangAngle, bedContact: armsBedPass, printBboxes: needPrintBboxes });
     entries.push({ params: fp, result });
     return result;
   };
@@ -477,7 +499,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   }];
   const caseResults = expanded.map(({ name, params, expect }) => {
     const facts = measureCase(params);
-    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle, bedContact: bedContactFloor }) : notMeasured(name) };
+    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle, bedContact: bedContactFloor, footprint: footprintFloor, accept }) : notMeasured(name) };
   });
   // VACUOUS VERIFY. A part that declares nothing — no profile, an empty or absent
   // `expect` — used to come back `ok: true` with zero checks, and every reader
@@ -512,11 +534,12 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     declared++;
     if (c.status !== "skip" && !c.unevaluated) evaluated++;
   }
-  const declaresAnything = profile != null || overhangAngle != null || bedContactFloor != null
+  const declaresAnything = profile != null || overhangAngle != null || bedContactFloor != null || footprintFloor != null
     || expanded.some(({ expect }) => Object.values(expect ?? {}).some((o) => o && typeof o === "object" && Object.keys(o).length > 0));
   const failures = all.filter((c) => c.status === "fail");
   const unevaluated = all.filter((c) => c.unevaluated);
   const warnings = all.filter((c) => c.status === "warn");
+  const costs = all.filter((c) => c.status === "cost");
   if (evaluated === 0 && unevaluated.length === 0) {
     warnings.push({ case: null, scope: "part", subpart: null, metric: "expectations", kind: "warn", expr: "evaluated",
       actual: 0, status: "warn", pass: null,
@@ -534,6 +557,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     cases: caseResults,
     failures,
     warnings,
+    costs,
     unevaluated,
     declared,
     evaluated,

package/src/framework/process/fdm/descriptor.js

@@ -0,0 +1,48 @@
+// Reusable design-for-manufacturing process profiles — a manufacturing technique
+// as DATA: which checks apply and at what thresholds. `bed` is the build volume
+// [x,y,z] in mm (a hard bbox-fit gate); `minWall` mm (a warn); `overhang` is the
+// steepest unsupported face the process prints cleanly, in degrees from vertical
+// (a cost — supports — armed by the profile alone, see overhangAngleFor; resin
+// prints on supports, so it carries none); `bedContact` is the least share (%) of a printed
+// piece's near-bed flat underside that must rest on the bed (a GATE, armed by the
+// profile alone — see bedContactFor; resin prints on supports, so it carries none);
+// `clearance` mm is carried for a future gap check (not enforced yet).
+//
+// `fits`, `holeUndersize` and `bridge` are the numbers an author (or the cloud
+// agent) copies into derive() for a mating feature; nothing in this repo reads
+// them yet. They are guide defaults from the FDM design guides, not measurements:
+// a calibrated printer overrides them through an inline `{ base, fits: {...} }`
+// profile, which REPLACES the fits table whole. `fits` are diametral offsets in
+// mm (negative = interference): press (a pin that never comes out), push (a cap
+// pressed on by hand), slip (a lid that lifts off), moving (a hinge pin or axle),
+// printInPlace (parts printed already assembled). `holeUndersize` is added to a
+// horizontal bore's diameter, since the top of a printed arch sags inward.
+// `bridge` is the longest flat span the process prints unsupported; resin prints
+// on supports, so it carries none.
+//
+// `footprint` is the percent of a printed piece's posed base area resting on the
+// bed below which the footprint cost fires.
+//
+// Import-free, like every process descriptor: lint and the oracle read it through
+// process/registry.js.
+export const FDM = {
+  id: "fdm",
+  label: "FDM 3D printing",
+  stock: "filament",
+  docId: "printed-parts",
+  profiles: {
+    "fdm-pla": {
+      bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45, bedContact: 50, footprint: 10,
+      fits: { press: -0.1, push: 0.05, slip: 0.25, moving: 0.35, printInPlace: 0.45 },
+      holeUndersize: 0.25, bridge: 10,
+    },
+    "fdm-petg": {
+      bed: [220, 220, 250], minWall: 1.5, clearance: 0.3, overhang: 45, bedContact: 50, footprint: 10,
+      fits: { press: -0.1, push: 0.05, slip: 0.3, moving: 0.4, printInPlace: 0.5 },
+      holeUndersize: 0.3, bridge: 10,
+    },
+  },
+  costs: { supports: "overhangArea", footprint: "footprintPct" },
+  metrics: {},
+  lintRules: [],
+};

package/src/framework/process/registry.js

@@ -7,6 +7,8 @@
 import { isSheetPart } from "../sheet/constants.js";
 import { LASER } from "./laser/descriptor.js";
 import { ROUTER } from "./cnc-router/descriptor.js";
+import { FDM } from "./fdm/descriptor.js";
+import { RESIN } from "./resin/descriptor.js";
 
 export const PROCESSES = [LASER, ROUTER];
 export const PROCESS_IDS = PROCESSES.map((d) => d.id);
@@ -23,3 +25,31 @@ export const SHEET_METRICS = Object.assign({}, ...PROCESSES.map((d) => d.metrics
 
 // Every process's own lint rules; lint/rules-sheet.js appends them to SHEET_RULES.
 export const PROCESS_LINT_RULES = PROCESSES.flatMap((d) => d.lintRules);
+
+// Print processes are their own list: PROCESSES stays the SHEET list (exporters,
+// destinations, SHEET_METRICS and sheet/part.js's PROCESS_IDS check all read it), so
+// fdm and resin never pass as a sheet part's process.
+export const PRINT_PROCESSES = [FDM, RESIN];
+export const PRINT_PROCESS_IDS = PRINT_PROCESSES.map((d) => d.id);
+export const ALL_PROCESSES = [...PROCESSES, ...PRINT_PROCESSES];
+
+export const printProcessById = (id) => PRINT_PROCESSES.find((d) => d.id === id) ?? null;
+
+// The DFM profiles of every print process as one map, keyed by profile id.
+export const PRINT_PROFILES = Object.freeze(Object.assign({}, ...PRINT_PROCESSES.map((d) => d.profiles)));
+
+// The print process owning a profile spec: a profile id, or an inline object whose
+// `base` (recursively) names one. Anything else is null.
+export function printProcessFor(spec) {
+  let id = spec;
+  // A cyclic inline profile (`p.base = p`) is malformed, not a loop to follow: lint calls
+  // this on user-authored parts, and a hang there takes the editor with it.
+  const seen = new Set();
+  while (id && typeof id === "object") {
+    if (seen.has(id)) return null;
+    seen.add(id);
+    id = id.base;
+  }
+  if (typeof id !== "string") return null;
+  return PRINT_PROCESSES.find((d) => Object.hasOwn(d.profiles, id)) ?? null;
+}

package/src/framework/process/resin/descriptor.js

@@ -0,0 +1,19 @@
+// Resin printing as DATA: see process/fdm/descriptor.js for what each profile field
+// means. Resin prints on supports, so it carries no overhang, bedContact, footprint
+// or bridge, and no costs. Import-free, like every process descriptor.
+export const RESIN = {
+  id: "resin",
+  label: "Resin 3D printing",
+  stock: "resin",
+  docId: "printed-parts",
+  profiles: {
+    "resin": {
+      bed: [120, 68, 160], minWall: 0.6, clearance: 0.1,
+      fits: { press: -0.05, push: 0.05, slip: 0.1, moving: 0.15, printInPlace: 0.2 },
+      holeUndersize: 0.05,
+    },
+  },
+  costs: {},
+  metrics: {},
+  lintRules: [],
+};

package/src/framework/verify-metrics.js

@@ -100,12 +100,14 @@ export const SUBPART_METRICS = {
         ? `no reading from the ${sampled} of ${total} triangles sampled — not a clean bill of health; a thin spot may exist between samples`
         : `sampled ${sampled} of ${total} triangles — an upper bound; a thinner spot may exist between samples`;
     } },
-  // Unsupported downward-facing area (oracle/overhang.js), in mm². Measured only
-  // for a part that declares `verify.orientation: "print"` under a profile with
-  // an `overhang` angle; elsewhere `extract` returns null and check() skips it.
-  // A warning, never a gate: a bridge reads as a ceiling and cannot be told apart.
-  overhangArea: { kind: "warn", extract: (s) => s.overhangArea,
-    hint: "unsupported downward-facing surface at the reported location — reorient the part so the face is vertical or on the bed, chamfer it to the process's overhang angle, split it into a bridged or supported feature, or accept supports",
+  // Unsupported downward-facing area (oracle/overhang.js), in mm². Measured for a
+  // part whose print process carries an `overhang` angle (the process alone arms it)
+  // or that asserts it; elsewhere `extract` returns null and check() skips it.
+  // A cost, never a gate or a warning: needing supports is a design choice with a
+  // price (a bridge reads as a ceiling and cannot be told apart), so it is listed
+  // under `costs` and the user may accept it (`verify.accept: ["supports"]`).
+  overhangArea: { kind: "cost", costId: "supports", extract: (s) => s.overhangArea,
+    hint: "unsupported downward-facing surface at the reported location — reorient the part so the face is vertical or on the bed, chamfer it to the process's overhang angle, split it into a bridged or supported feature; when the user chooses supports instead, record it with verify.accept: [\"supports\"]",
     locate: (s) => s.overhangAt,
     note: (s) => (s.overhangAngle != null ? `steepest unsupported face ${s.overhangAngle.toFixed(1)}° from vertical` : null) },
   // How much of a printed piece's near-bed flat underside rests on the bed
@@ -121,6 +123,15 @@ export const SUBPART_METRICS = {
     note: (s) => (s.bedHoverGap != null
       ? `${s.bedHoverArea.toFixed(1)} mm² of flat underside sits ${s.bedHoverGap.toFixed(2)} mm above the bed; ${s.bedContactArea.toFixed(1)} mm² touches it`
       : null) },
+  // The footprint (measure.js, from bed contact's pass): the flat contact area over the
+  // piece's silhouette on the bed, in percent. Measured where bed contact is, plus where the
+  // profile carries `footprint` or the author declares it. A COST, like overhangArea: a
+  // piece on a point or a line prints with a brim or a raft, which the user may choose
+  // (`accept: ["footprint"]`); bedContactPct passes such a piece, since nothing hovers.
+  footprintPct: { kind: "cost", costId: "footprint", extract: (s) => s.footprintPct,
+    hint: "the share of this piece's silhouette on the bed (its outline in the print pose) that actually touches it is small — it stands on a point, a line or a curve, which reads near zero, so the first layer has almost nothing to hold on to and the piece can tip or pull loose. Lay it on its flat face, add a flat foot or pad at its lowest point, or print it with a brim (accept: [\"footprint\"] records that choice)",
+    pattern: "piece-stands-on-nothing",
+    locate: (s) => s.footprintAt },
   // `s.deviation` (measure.js) exists only for a sub-part declaring `reference:
   // "<import name>"`; on every other sub-part `extract` returns null, which
   // `check()` already reports as status "skip" rather than a fail — the

package/src/framework/worker.js

@@ -15,6 +15,7 @@ import { handle } from "./jobs.js";
 export { coreStatus, onCoreFallback, CORE_FALLBACK_REASONS } from "./core/core-status.js";
 import { lintPart } from "../lint.js";
 import { cachedVectorDocs } from "./vectors.js";
+import { describeKernelThrow } from "./kernel-error.js";
 
 async function manifoldKernels() {
   const [{ default: Module }, { createManifoldKernel }] = await Promise.all([
@@ -109,10 +110,11 @@ export function runWorker(part, opts = {}) {
         // escaping rejection would kill the pump: this job AND everything queued behind
         // it would be dropped with no reply at all, leaving the host waiting on a message
         // that never comes until its own timeout fires.
+        let kernel = null;
         try {
           // A generate superseded while it sat in the queue never builds at all.
           if (job.epoch !== null && job.epoch !== epoch) continue;
-          const kernel = await kernelFor(job.data);
+          kernel = await kernelFor(job.data);
           // handle() declares each message's transferables (the big binary buffers).
           const post = (m, transfer = []) => postMessage(m, transfer);
           if (job.epoch === null) { await handle(kernel, job.part, job.data, post, { importMeshes, jobs: opts.jobs }); continue; }
@@ -125,11 +127,14 @@ export function runWorker(part, opts = {}) {
           const gated = (m, transfer = []) =>
             (m.type === "meshes" && isStale() ? post({ type: "superseded" }) : post(m, transfer));
           await handle(kernel, job.part, job.data, gated, { isStale, importMeshes, jobs: opts.jobs });
-        } catch (err) {
+        } catch (thrown) {
           // Same shape jobs.js posts for a failed build, so hosts need no new branch.
           // Carry the job's jobId when it has one (capture/export are correlated by it):
           // a boot failure hitting kernelFor here must reach the right controller, or a
           // correlated caller (captureView, exportParts) would hang instead of settling.
+          // A bare number (an uncaught C++ exception out of the kernel) is given
+          // words here too, exactly as jobs.js does for a build.
+          const err = describeKernelThrow(thrown, { evidence: kernel?._throwEvidence?.(thrown) });
           const jobId = job.data?.jobId;
           postMessage({ type: "error", message: String(err?.message || err), ...(jobId != null ? { jobId } : {}) });
         }

package/types/part.d.ts

@@ -484,9 +484,9 @@ export interface DfmProfile {
   minWall?: number;
   /**
    * Steepest unsupported face the process prints cleanly, in degrees from
-   * vertical (45 on the FDM profiles; absent on resin). Checked only for a part
-   * that also declares `verify.orientation: "print"`; `null` switches it off
-   * under a named base. A warning, never a gate.
+   * vertical (45 on the FDM profiles; absent on resin). The print process alone
+   * arms the check; `null` switches it off under a named base. Reported as a
+   * cost (needing supports), never a failure.
    */
   overhang?: number | null;
   /**
@@ -495,6 +495,8 @@ export interface DfmProfile {
    * profile alone; `null` switches it off under a named base.
    */
   bedContact?: number | null;
+  /** Percent of a printed piece's posed base area resting on the bed below which the footprint cost fires. */
+  footprint?: number | null;
   /** Carried for a future gap check; not enforced yet. */
   clearance?: number;
   /**
@@ -562,8 +564,8 @@ export interface SubPartExpectations {
   wall?: Expectation;
   /**
    * Unsupported downward-facing surface in mm² (faces steeper than the profile's
-   * `overhang` angle, bed at the sub-part's own lowest Z). Measured only under
-   * `verify.orientation: "print"`; a warning, never a gate.
+   * `overhang` angle, bed at the sub-part's own lowest Z). Armed by the print
+   * process alone; reported as a cost (`verify.costs`), never a failure.
    */
   overhangArea?: Expectation;
   /**
@@ -572,6 +574,13 @@ export interface SubPartExpectations {
    * Under an FDM profile every printed sub-part gets `>=50` by default; a gate.
    */
   bedContactPct?: Expectation;
+  /**
+   * Share (0–100) of the sub-part's posed base area (its xy extent in the print pose)
+   * whose flat underside touches the bed — near 0 for a piece standing on a point, a
+   * line or a curl. Under an FDM profile every printed sub-part gets `>=5`; reported as
+   * a cost (`verify.costs`), never a failure; `accept: ["footprint"]` records a brim.
+   */
+  footprintPct?: Expectation;
   /** Symmetric-difference volume vs. the sub-part's declared `reference` import. */
   refXorVolume?: Expectation;
   /** Percent volume delta vs. the sub-part's declared `reference` import. */
@@ -640,12 +649,17 @@ export interface VerifyBlock<P = ResolvedParams, D = Derived> {
   /** A named DFM profile or an inline one. */
   process?: DfmProfileName | DfmProfile;
   /**
-   * `"print"` declares the part is laid out for its bed — Z up, each sub-part's
-   * bed at its own lowest Z — which is the only way the profile's `overhang`
-   * check is armed. Omit it while a part is still being shaped or is bound for
-   * another process.
+   * `"print"` declares that `build()` is the print pose — Z up, each sub-part's
+   * bed at its own lowest Z. It does not arm any check; the print process does.
    */
   orientation?: "print";
+  /**
+   * Costs the user accepted, by id. An accepted cost is still measured and
+   * reported (`accepted: true`), but no longer raised as something to fix. Only the
+   * process's own default check is marked accepted: a limit you wrote in `expect`
+   * (`overhangArea: "<=500"`) keeps its meaning and is never marked accepted.
+   */
+  accept?: ("supports" | "footprint")[];
   /** Which cases to check; default is `"defaults"` plus every preset name. */
   cases?: string[];
   /**

package/types/testing.d.ts

@@ -433,6 +433,14 @@ export interface SubPartFacts {
   bedHoverGap: number | null;
   /** Centroid of the largest hovering face; `null` when nothing hovers. */
   bedHoverAt: number[] | null;
+  /**
+   * Share (0–100) of the piece's silhouette on the bed (its outline seen from below, in
+   * the print pose) that actually touches it — the footprint cost's reading, from the
+   * bed-contact pass; `null` when that pass did not run or the silhouette is empty.
+   */
+  footprintPct: number | null;
+  /** The piece's lowest point, in display coordinates; `null` when not checked. */
+  footprintAt: number[] | null;
   /**
    * Present only when bed contact had to be read off the piece's export build (its
    * print pose could not be read from place() alone) and that build failed.
@@ -521,6 +529,8 @@ export interface MeasureReport {
   measuredOverhang: number | null;
   /** Whether the bed-contact pass ran (the part is checked for it). */
   measuredBedContact: boolean;
+  /** Whether the footprint was read — the same pass, so always `measuredBedContact`. */
+  measuredFootprint: boolean;
   /**
    * Present only in a view holding a sheet part: whether the printed sub-parts' print
    * (export) poses were built for `printBbox`.
@@ -595,7 +605,7 @@ export function measure(
 
 // --- verify -----------------------------------------------------------------
 
-export type CheckStatus = "pass" | "fail" | "warn" | "skip";
+export type CheckStatus = "pass" | "fail" | "warn" | "cost" | "skip";
 
 export interface VerifyCheck {
   /** `"part"` is the vacuous-verify notice; `"case"` the quick-lap "not measured" marker. */
@@ -603,8 +613,10 @@ export interface VerifyCheck {
   /** The sub-part name, `"a×b"` for a pair check, or `null` for a scalar view metric. */
   subpart: string | null;
   metric: string;
-  /** `gate` failures set a non-zero exit code; `warn` never blocks. */
-  kind: "gate" | "warn";
+  /** `gate` failures set a non-zero exit code; `warn` never blocks; `cost` is a design choice with a price. */
+  kind: "gate" | "warn" | "cost";
+  /** On a `cost` check: whether the user listed its id in `verify.accept`. */
+  accepted?: boolean;
   /** The asserted expression, stringified. */
   expr: string;
   actual: unknown;
@@ -651,6 +663,8 @@ export interface VerifyReport {
   /** Every failing check, flattened, each tagged with its `case`. */
   failures: Array<VerifyCheck & { case: string }>;
   warnings: Array<VerifyCheck & { case: string }>;
+  /** Design choices with a price (supports, footprint); never failures. Accepted ones are flagged. */
+  costs: Array<VerifyCheck & { case: string }>;
   /** Checks a quick lap could not evaluate. */
   unevaluated: Array<VerifyCheck & { case: string }>;
   /** Check instances the part or its profile declared, across cases (near-miss notices excluded). */