partforge 0.163.0 → 0.164.0

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

@@ -7,7 +7,7 @@ import { SUBPART_METRICS, VIEW_METRICS, BOUNDS_FORM, teachableMetrics, sidesSpec
 import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
 import { parseAssertion, bareVectorHint } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
-import { PROCESS_IDS } from "../process/registry.js";
+import { PRINT_PROCESSES, PROCESS_IDS, printProcessFor } 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
@@ -410,8 +410,41 @@ export const VERIFY_RULES = [
       const hint = safeSuggest(orientation, ORIENTATIONS);
       return [err("verify-unknown-orientation",
         `\`verify.orientation\` is ${describe(orientation)}, which is not a known orientation`,
-        `Use ${ORIENTATIONS.map((o) => `"${o}"`).join(", ")}${hint ? ` — did you mean "${hint}"?` : ""} (declares the part is laid out for its print bed, arming the profile's overhang check), or omit the key.`,
+        `Use ${ORIENTATIONS.map((o) => `"${o}"`).join(", ")}${hint ? ` — did you mean "${hint}"?` : ""} (declares that \`build()\` is the print pose: Z up, bed at the lowest Z), or omit the key.`,
         "verify.orientation")];
     },
   },
+  {
+    // `verify.accept` lists cost ids the user accepted. verify() reads it but
+    // never validates it, so a typo would be silently ignored without this rule.
+    // A process that does not resolve is verify-unknown-process's finding, not ours.
+    id: "verify-unknown-accept",
+    run: ({ part }) => {
+      const verify = part?.verify;
+      if (verify?.accept == null) return [];
+      if (!Array.isArray(verify.accept)) {
+        return [err("verify-unknown-accept",
+          `\`verify.accept\` is ${describe(verify.accept)}, not a list of cost ids`,
+          "Write `accept` as an array of cost ids, e.g. `accept: [\"supports\"]`, or omit the key.",
+          "verify.accept")];
+      }
+      // With no print process resolved, a cost can still fire (an authored expectation,
+      // an inline profile with no base), so check against every print process's ids.
+      const proc = printProcessFor(verify.process);
+      const known = proc ? Object.keys(proc.costs) : [...new Set(PRINT_PROCESSES.flatMap((d) => Object.keys(d.costs)))];
+      const out = [];
+      verify.accept.forEach((id, i) => {
+        if (typeof id === "string" && known.includes(id)) return;
+        out.push(err("verify-unknown-accept",
+          `\`verify.accept[${i}]\` is ${describe(id)}, which is not a cost ${proc ? "this process" : "any print process"} defines`,
+          !proc
+            ? `No print process is declared; the cost ids any print process knows are: ${known.join(", ")}.`
+            : known.length
+              ? `Known cost ids for this process: ${known.join(", ")}.`
+              : "This process defines no acceptable costs; remove the entry.",
+          `verify.accept[${i}]`));
+      });
+      return out;
+    },
+  },
 ];

package/src/framework/oracle/bed-contact.js

@@ -65,6 +65,59 @@ export const HOVER_FLOOR = 1;
 // The footprint slack never exceeds this (mm): well under a first layer, and under the
 // smallest hover worth reporting, so a tall piece is judged the way a short one is.
 export const MAX_BED_EPS = 0.05;
+// The silhouette raster (the footprint's denominator): the finest cell pitch (mm), and
+// the most cells along the longer side — so a large piece costs a 512×512 bitmap at most.
+const SILHOUETTE_MIN_PITCH = 0.25;
+const SILHOUETTE_CELLS = 512;
+
+// Mark one downward triangle's xy shadow on the silhouette grid: every cell whose centre
+// lies inside it. Each grid row is filled as one span — the x-range where the row's
+// centre line crosses the triangle — so the work is the cells the triangle covers plus
+// one intersection per row, never its whole bounding rectangle (a fine fan of slivers
+// over the same floor used to rescan that rectangle once per sliver). A triangle too
+// thin to contain any centre (a wall thinner than a cell) marks the cells along its
+// outline instead (sampled at half a pitch), so it is never dropped between centres.
+// Marking edge cells for EVERY triangle was tried and over-covered a 1 mm tube wall by
+// a third; centre sampling is unbiased along an edge.
+function shadow(P, a, b, c, minX, minY, pitch, gx, gy, grid, mark) {
+  const ax = P[a], ay = P[a + 1], bx = P[b], by = P[b + 1], cx = P[c], cy = P[c + 1];
+  const area2 = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+  let hit = false;
+  if (area2 !== 0) {
+    const j0 = Math.max(0, Math.floor((Math.min(ay, by, cy) - minY) / pitch));
+    const j1 = Math.min(gy - 1, Math.floor((Math.max(ay, by, cy) - minY) / pitch));
+    for (let j = j0; j <= j1; j++) {
+      const y = minY + (j + 0.5) * pitch;
+      // Where this row's centre line enters and leaves the triangle: the extreme x of its
+      // crossings with the three edges (an edge lying on the line contributes both ends).
+      let lo = Infinity, hi = -Infinity;
+      const cross = (x0, y0, x1, y1) => {
+        if (!((y0 <= y && y <= y1) || (y1 <= y && y <= y0))) return;
+        if (y0 === y1) { lo = Math.min(lo, x0, x1); hi = Math.max(hi, x0, x1); return; }
+        const x = x0 + ((y - y0) * (x1 - x0)) / (y1 - y0);
+        if (x < lo) lo = x;
+        if (x > hi) hi = x;
+      };
+      cross(ax, ay, bx, by); cross(bx, by, cx, cy); cross(cx, cy, ax, ay);
+      if (lo > hi) continue;
+      const i0 = Math.max(0, Math.ceil((lo - minX) / pitch - 0.5));
+      const i1 = Math.min(gx - 1, Math.floor((hi - minX) / pitch - 0.5));
+      for (let i = i0; i <= i1; i++) grid[j * gx + i] = 1;
+      if (i1 >= i0) hit = true;
+    }
+  }
+  if (hit) return;
+  // The fallback samples the triangle shrunk by half toward its centroid, not its own
+  // edges: a fan sliver of a disc's bottom then marks cells inside the disc, never the
+  // cells its rim crosses (which over-covered a Ø5 pin by a tenth).
+  const gxc = (ax + bx + cx) / 3, gyc = (ay + by + cy) / 3;
+  const h = ([x, y]) => [(x + gxc) / 2, (y + gyc) / 2];
+  const [pa, pb, pc] = [h([ax, ay]), h([bx, by]), h([cx, cy])];
+  for (const [x0, y0, x1, y1] of [[...pa, ...pb], [...pb, ...pc], [...pc, ...pa]]) {
+    const steps = Math.ceil(Math.hypot(x1 - x0, y1 - y0) / (pitch / 2)) + 1;
+    for (let t = 0; t <= steps; t++) mark(x0 + ((x1 - x0) * t) / steps, y0 + ((y1 - y0) * t) / steps);
+  }
+}
 
 /**
  * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, triangles: number }} mesh
@@ -73,38 +126,64 @@ export const MAX_BED_EPS = 0.05;
  *   scanned); `bedEps` the footprint slack (default 0.1% of the mesh height, floored at
  *   0.01 mm and capped at MAX_BED_EPS); `bedBand` the height above the bed within which a flat face hovers
  *   (default 1 mm)
- * @returns {{ pct: number, contactArea: number, hoverArea: number, gap: number|null, at: number[]|null }|null}
+ * @returns {{ pct: number, contactArea: number, hoverArea: number, downArea: number, gap: number|null, at: number[]|null, base: number[], lowestAt: number[] }|null}
  *   `pct` 0..100, the share of the near-bed flat underside on the bed; the two areas in
  *   mm²; `gap` how far above the bed the largest hovering face sits, and `at` its
- *   centroid (null when nothing hovers past the floor); null for an empty mesh.
+ *   centroid (null when nothing hovers past the floor); `downArea` the piece's
+ *   silhouette on the bed (mm²): the UNION of every downward-facing triangle's shadow,
+ *   rasterized (a closed mesh's silhouette is exactly that union, since every point of
+ *   it has a bottom-most face, which faces down), and
+ *   `lowestAt` the mesh's lowest vertex — measure.js's footprint cost, the contact area
+ *   over `downArea`, catches what `pct` cannot: a piece with almost no flat underside
+ *   at all (a sphere-tipped rod on its end) hovers nothing and reads 100. `base`, the
+ *   mesh's [dx, dy] extent, is reported but no longer divided by: a tube on its rim, a
+ *   frame or a diagonal bar fills little of its bounding box yet stands on all of its
+ *   underside. Null for an empty mesh.
  */
 export function bedContact(mesh, { bedZ, bedEps, bedBand = 1 } = {}) {
   const { positions, indices } = mesh;
   const n = indices ? indices.length : positions.length / 3;
   if (n < 3) return null;
 
-  let minZ = Infinity, maxZ = -Infinity;
-  if (bedZ === undefined || bedEps === undefined) {
-    for (let i = 2; i < positions.length; i += 3) {
-      const z = positions[i];
-      if (z < minZ) minZ = z;
-      if (z > maxZ) maxZ = z;
-    }
+  // One scan for the extents: the bed (lowest Z) and the slack's height when the caller
+  // did not hand them in, and always the posed base (its xy extent, reported) and the
+  // lowest vertex (where the footprint cost is located).
+  let minZ = Infinity, maxZ = -Infinity, minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, low = 0;
+  for (let i = 0; i + 2 < positions.length; i += 3) {
+    const x = positions[i], y = positions[i + 1], z = positions[i + 2];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    if (z < minZ) { minZ = z; low = i; }
+    if (z > maxZ) maxZ = z;
   }
+  const base = [maxX - minX, maxY - minY];
+  const lowestAt = [positions[low], positions[low + 1], positions[low + 2]];
   const bed = bedZ ?? minZ;
   const eps = bedEps ?? Math.min(MAX_BED_EPS, Math.max(0.01, 1e-3 * (maxZ - minZ)));
   const bandTop = bed + bedBand;
+  // The silhouette raster: an xy grid over the base, at most ~512 cells a side.
+  const pitch = Math.max(SILHOUETTE_MIN_PITCH, Math.max(base[0], base[1]) / SILHOUETTE_CELLS);
+  const gx = Math.max(1, Math.ceil(base[0] / pitch) + 1), gy = Math.max(1, Math.ceil(base[1] / pitch) + 1);
+  const grid = new Uint8Array(gx * gy);
+  const mark = (x, y) => {
+    const i = Math.min(gx - 1, Math.max(0, Math.floor((x - minX) / pitch)));
+    const j = Math.min(gy - 1, Math.max(0, Math.floor((y - minY) / pitch)));
+    grid[j * gx + i] = 1;
+  };
 
   let contactArea = 0, hoverArea = 0, largest = 0, gap = null, at = null;
   for (let i = 0; i < n; i += 3) {
     const a = (indices ? indices[i] : i) * 3, b = (indices ? indices[i + 1] : i + 1) * 3, c = (indices ? indices[i + 2] : i + 2) * 3;
     const az = positions[a + 2], bz = positions[b + 2], cz = positions[c + 2];
     const cenZ = (az + bz + cz) / 3;
-    if (cenZ > bandTop) continue;                                             // above the band: not the underside
     const ux = positions[b] - positions[a], uy = positions[b + 1] - positions[a + 1], uz = bz - az;
     const vx = positions[c] - positions[a], vy = positions[c + 1] - positions[a + 1], vz = cz - az;
     const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
     if (nz >= 0) continue;                                                    // not facing down
+    shadow(positions, a, b, c, minX, minY, pitch, gx, gy, grid, mark);        // its shadow joins the silhouette
+    if (cenZ > bandTop) continue;                                             // above the band: not the underside
     const len = Math.hypot(nx, ny, nz);
     if (len < 1e-9) continue;                                                 // degenerate: no normal
     const triArea = len / 2;
@@ -122,6 +201,9 @@ export function bedContact(mesh, { bedZ, bedEps, bedBand = 1 } = {}) {
             cenZ];
     }
   }
-  if (hoverArea < HOVER_FLOOR) return { pct: 100, contactArea, hoverArea, gap: null, at: null };
-  return { pct: (100 * contactArea) / (contactArea + hoverArea), contactArea, hoverArea, gap, at };
+  let cells = 0;
+  for (let i = 0; i < grid.length; i++) cells += grid[i];
+  const downArea = cells * pitch * pitch;
+  if (hoverArea < HOVER_FLOOR) return { pct: 100, contactArea, hoverArea, downArea, gap: null, at: null, base, lowestAt };
+  return { pct: (100 * contactArea) / (contactArea + hoverArea), contactArea, hoverArea, downArea, gap, at, base, lowestAt };
 }

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,