partforge 0.163.1 → 0.164.0

package/src/framework/oracle/dfm-profiles.js

@@ -1,41 +1,7 @@
-// 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 warn, armed only by the part — 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.
-export const PROFILES = {
-  "fdm-pla": {
-    bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45, bedContact: 50,
-    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,
-    fits: { press: -0.1, push: 0.05, slip: 0.3, moving: 0.4, printInPlace: 0.5 },
-    holeUndersize: 0.3, bridge: 10,
-  },
-  "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,
-  },
-};
+// The profiles live on the print process descriptors (process/fdm, process/resin);
+// PROFILES is the registry's merged map, re-exported so every import keeps working.
+import { PRINT_PROFILES as PROFILES } from "../process/registry.js";
+export { PROFILES };
 
 export function resolveProfile(spec) {
   if (typeof spec === "string") {
@@ -62,11 +28,11 @@ export const ORIENTATIONS = ["print"];
 export const DEFAULT_OVERHANG_ANGLE = 45;
 
 // Which overhang angle a part is checked against, or null when it is not checked.
-// Two ways in, both explicit — a profile alone never arms it, because the cloud
-// agent writes `process: "fdm-pla"` by habit and a part still being shaped should
-// not be nagged about its underside:
-//   - `verify.orientation: "print"` (the part is laid out for its bed) under a
-//     profile carrying `overhang`; a profile without one (resin) checks nothing;
+// Two ways in:
+//   - the print process alone: a profile carrying `overhang` arms it (a profile
+//     without one, resin, checks nothing). The reading is a COST, not a warning, so a
+//     part still being shaped is told what supports would cost, never nagged;
+//     `verify.orientation` no longer takes part in the decision;
 //   - an `overhangArea` expectation the author wrote themselves, in any case's
 //     `expect` (`expanded`, from gates.js's expandExpectations) — measured against
 //     the profile's angle, or DEFAULT_OVERHANG_ANGLE when the profile has none,
@@ -82,10 +48,10 @@ export function overhangAngleFor(part, process, { expanded = [] } = {}) {
   const spec = process ?? part?.verify?.process;
   const fromProfile = spec ? resolveProfile(spec).overhang : undefined;
   const angle = typeof fromProfile === "number" && Number.isFinite(fromProfile) ? fromProfile : null;
-  if (orientation === "print" && angle != null) return angle;
+  if (angle != null) return angle;
   const asserted = expanded.some(({ expect }) =>
     Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "overhangArea" in o));
-  return asserted ? (angle ?? DEFAULT_OVERHANG_ANGLE) : null;
+  return asserted ? DEFAULT_OVERHANG_ANGLE : null;
 }
 
 // The `bedContactPct` floor an author's own expectation or `orientation: "print"` arms
@@ -93,12 +59,11 @@ export function overhangAngleFor(part, process, { expanded = [] } = {}) {
 export const DEFAULT_BED_CONTACT = 50;
 
 // The least share of a printed piece's near-bed flat underside that must touch the bed
-// (oracle/bed-contact.js), or null when it is not checked. Unlike overhangAngleFor, the
-// PROFILE ALONE arms it: an overhang is a design choice a part still being shaped may
-// not have made yet, but a flat underside hovering a fraction of a millimetre above the
-// piece's lowest point is a defect in whatever orientation the piece is exported —
-// every exporter and slicer lays it on that lowest point — so a part carrying an FDM
-// profile is checked from its first build. Three ways in:
+// (oracle/bed-contact.js), or null when it is not checked. Like overhangAngleFor the
+// PROFILE ALONE arms it, but as a GATE, not a cost: a flat underside hovering a fraction
+// of a millimetre above the piece's lowest point is a defect in whatever orientation the
+// piece is exported — every exporter and slicer lays it on that lowest point — so a part
+// carrying an FDM profile is checked from its first build. Three ways in:
 //   - a profile carrying `bedContact` (the FDM profiles; resin carries none);
 //   - `verify.orientation: "print"` with NO profile. A named profile decides alone:
 //     resin prints on supports, so orientation must not arm it there (overhangAngleFor's
@@ -118,3 +83,29 @@ export function bedContactFor(part, process, { expanded = [] } = {}) {
     Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "bedContactPct" in o));
   return asserted ? DEFAULT_BED_CONTACT : null;
 }
+
+// The `footprintPct` floor an author's own expectation arms the measurement against
+// when the profile names none (a resin part, or no profile at all).
+export const DEFAULT_FOOTPRINT = 10;
+
+// The least share of a printed piece's silhouette on the bed that must actually touch
+// it (the footprint, read by bed contact's pass — measure.js `footprintPct`), or null when it
+// is not checked. A COST, like overhang: a piece standing on a point, a line or a curl
+// prints with a brim or a raft, which the user may well choose. Two ways in:
+//   - a profile carrying `footprint` (the FDM profiles; resin carries none, since it
+//     prints on supports), and `{ base: "fdm-pla", footprint: null }` stays off;
+//   - a `footprintPct` expectation the author wrote themselves, in any case's `expect`.
+// `verify.orientation` takes no part (overhangAngleFor's rule), but an invalid value
+// still throws, as it does there.
+export function footprintFor(part, process, { expanded = [] } = {}) {
+  const orientation = part?.verify?.orientation;
+  if (orientation != null && !ORIENTATIONS.includes(orientation)) {
+    throw new Error(`unknown verify.orientation: ${JSON.stringify(orientation)} (known: ${ORIENTATIONS.join(", ")})`);
+  }
+  const spec = process ?? part?.verify?.process;
+  const fromProfile = spec ? resolveProfile(spec).footprint : undefined;
+  if (typeof fromProfile === "number" && Number.isFinite(fromProfile)) return fromProfile;
+  const asserted = expanded.some(({ expect }) =>
+    Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "footprintPct" in o));
+  return asserted ? DEFAULT_FOOTPRINT : null;
+}

package/src/framework/oracle/gates.js

@@ -12,7 +12,7 @@
 // conservative direction, since that is the full-resolution behaviour every part
 // had before budgets existed. The real error surfaces from verify, which is where
 // a reader can act on it.
-import { resolveProfile, overhangAngleFor, bedContactFor } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor, bedContactFor, footprintFor } from "./dfm-profiles.js";
 import { expandCases } from "./cases.js";
 import { resolveParams } from "../part-model.js";
 import { parseAssertion } from "./assert-dsl.js";
@@ -56,6 +56,12 @@ export function partBedContact(part, { process, expanded } = {}) {
   try { return bedContactFor(part, process, { expanded: expanded ?? expandExpectations(part) }); } catch { return null; }
 }
 
+// The footprint floor a part is checked against, or null when not checked
+// (dfm-profiles.js footprintFor holds the rule). Total, like partBedContact.
+export function partFootprint(part, { process, expanded } = {}) {
+  try { return footprintFor(part, process, { expanded: expanded ?? expandExpectations(part) }); } catch { return null; }
+}
+
 export function partGatesMinWall(part, { process, expanded } = {}) {
   try {
     const spec = process ?? part?.verify?.process;

package/src/framework/oracle/measure.js

@@ -14,7 +14,7 @@ import { bounds, meshArea, meshCentroid } from "./mesh.js";
 import { minWall, DIAGNOSTIC_SAMPLES } from "./min-wall.js";
 import { overhang } from "./overhang.js";
 import { bedContact } from "./bed-contact.js";
-import { partBedContact, partGatesMinWall, partHasBed, partOverhangAngle, partWallBands } from "./gates.js";
+import { partBedContact, partFootprint, 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]];
@@ -133,15 +133,15 @@ const transformPoint = (m, [x, y, z]) => [
 // Bed contact read off the piece's real EXPORT build, for a sub-part whose print pose
 // the probes could not read (a place() that queries its solid): judging the display
 // mesh there would pass a bad print orientation or fail a good one. One extra build,
-// in its own cache round like printPoseBboxes, only for such a piece. `at` is withheld:
-// with the pose unreadable there is no honest way back to display coordinates. An
-// export pose that does not build answers `{ error }`, which verify reports as
-// unevaluated rather than guessing.
+// in its own cache round like printPoseBboxes, only for such a piece. `at` and
+// `lowestAt` are withheld: with the pose unreadable there is no honest way back to
+// display coordinates. An export pose that does not build answers `{ error }`, which
+// verify reports as unevaluated rather than guessing.
 function exportPoseBedContact(kernel, part, name, view, { p, d }) {
   kernel.beginSubPart?.(`oracle:print:${view}`);
   try {
     const out = bedContact(buildPosed(kernel, part, name, { purpose: "export", view, p, d }).toMesh());
-    return out ? { ...out, at: null } : out;
+    return out ? { ...out, at: null, lowestAt: null } : out;
   } catch (e) {
     return { error: String(e?.message || e).slice(0, 200) };
   } finally { kernel.endSubPart?.(); }
@@ -153,8 +153,9 @@ function exportPoseBedContact(kernel, part, name, view, { p, d }) {
 // box) is not how it prints: judging its underside there flagged the wrong faces and
 // missed the real ones. The display mesh is carried into the export pose by a rigid
 // matrix — no second build, and one copy shared by both readings — and the bed is that
-// pose's own lowest Z; each `at` comes back in display coordinates, where every other
-// finding of this view sits. An unreadable or identical pose measures as shown.
+// pose's own lowest Z; each `at` (and bed contact's `lowestAt`) comes back in display
+// coordinates, where every other finding of this view sits. An unreadable or identical
+// pose measures as shown.
 // `m` is displayToPrintMatrix's answer, resolved by the caller: the measure memo
 // keys on it, since the pose comes from place() and is not part of the solid's hash.
 function printPoseUnderside(mesh, m, { maxAngle, bed, displayBedZ }) {
@@ -163,7 +164,15 @@ function printPoseUnderside(mesh, m, { maxAngle, bed, displayBedZ }) {
     posed = { positions: Float32Array.from(mesh.positions), indices: mesh.indices };
     transformPositions(posed.positions, m);
   }
-  const back = (out) => (m && out?.at ? { ...out, at: transformPoint(invertRigid(m), out.at) } : out);
+  const back = (out) => {
+    if (!m || !out) return out;
+    const inv = invertRigid(m);
+    return {
+      ...out,
+      ...(out.at ? { at: transformPoint(inv, out.at) } : {}),
+      ...(out.lowestAt ? { lowestAt: transformPoint(inv, out.lowestAt) } : {}),
+    };
+  };
   return {
     oh: maxAngle != null ? back(posed ? overhang(posed, { maxAngle }) : overhang(mesh, { maxAngle, bedZ: displayBedZ })) : null,
     bc: bed ? back(posed ? bedContact(posed) : bedContact(mesh, { bedZ: displayBedZ })) : null,
@@ -293,9 +302,10 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // Declared wall bands, per sub-part, for exactly these params (Task 5). Resolved
   // once per measure; a bad declaration throws here, which is a measure error.
   const wallBands = opts.minWall ? partWallBands(part, params, reads) : {};
-  // Overhang is measured only for a part that opted in (dfm-profiles.js
-  // overhangAngleFor) — everything else reads null. verify hands the angle it
-  // resolved in (a `process` override changes it); `null` there is an explicit
+  // Overhang is measured for a part whose print process arms it (dfm-profiles.js
+  // overhangAngleFor: a profile carrying `overhang`, or the author's own
+  // `overhangArea` expectation) — everything else reads null. verify hands the angle
+  // it resolved in (a `process` override changes it); `null` there is an explicit
   // "not checked", not a fallback. The angle used is stamped on the result as
   // `measuredOverhang`, and verify refuses a seed whose stamp disagrees with the
   // angle it needs — the min-wall superset rule's counterpart, since a reading
@@ -304,8 +314,11 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // Bed contact is measured for a part whose profile (or orientation, or its own
   // expectation) arms it — dfm-profiles.js bedContactFor. Unlike overhang the reading
   // does not depend on the threshold, so the stamp is a boolean: `measuredBedContact`.
-  // verify passes its own answer (a `process` override can arm or disarm it).
-  const bedArmed = (opts.bedContact !== undefined ? opts.bedContact : partBedContact(part)) != null;
+  // verify passes its own answer (a `process` override can arm or disarm it). The same
+  // pass reads the footprint cost (dfm-profiles.js footprintFor), so a part whose
+  // footprint alone is checked arms it too — here and in verify — and one stamp, and
+  // one memo-key bit, covers both readings.
+  const bedArmed = (opts.bedContact !== undefined ? opts.bedContact : (partBedContact(part) ?? partFootprint(part))) != null;
   const underside = overhangAngle != null || bedArmed;
   const subBounds = [];
   // Sheet parts: a view holding one sizes each printed sub-part in its print pose
@@ -341,7 +354,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     const printMatrix = printPose?.matrix ?? null;
     // A pose the probes could not read is not the identity: bed contact then reads the
     // export build itself (exportPoseBedContact). Overhang keeps its display-pose
-    // fallback — a warning, and unchanged here.
+    // fallback — a cost, and unchanged here.
     const exportBed = bedArmed && printPose && !printPose.trusted;
     // Memo key = the inputs this sub-part's facts actually depend on, besides its
     // own geometry hash: whether min-wall ran, at what sample budget and against
@@ -447,6 +460,16 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       bedHoverArea: bc ? bc.hoverArea : null,
       bedHoverGap: bc?.gap ?? null,
       bedHoverAt: bc?.at ?? null,
+      // The footprint (same pass): the share of the piece's silhouette on the bed that
+      // actually touches it, in percent (clamped at 100: the silhouette is a
+      // raster, a cell or so off along its edges) — near 0 for a
+      // piece standing on a point, a line or a curl, which bedContactPct passes since
+      // nothing flat hovers, and near 100 for anything that stands on its whole
+      // underside, however little of its bounding box that fills (a tube on its rim, a
+      // frame, a diagonal bar). Null when not measured or the silhouette is empty. Located at
+      // the piece's lowest point, in display coordinates.
+      footprintPct: bc && bc.downArea > 0 ? Math.min(100, (100 * bc.contactArea) / bc.downArea) : null,
+      footprintAt: bc?.lowestAt ?? null,
       ...(exportBc?.error ? { bedContactError: exportBc.error } : {}),
       // The process's 2-D facts on a sheet part (sheetRowFacts), null on every other.
       sheet: sheet
@@ -537,6 +560,8 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     measuredOverhang: overhangAngle ?? null,
     // Whether the bed-contact pass ran — the same kind of stamp, read by the same gate.
     measuredBedContact: bedArmed,
+    // The footprint is read by the same pass, so the same stamp.
+    measuredFootprint: bedArmed,
     // 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,

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