partforge 0.109.1 → 0.111.0

package/src/framework/geometry/occt-backend.js

@@ -16,6 +16,7 @@
 //     Ops that need the real B-rep (booleans, fillet/chamfer/shell, exports,
 //     volume, boundingBox) materialize the pending pose through replicad first.
 import { assertNoCoincidentBoolean } from "./occt-coincidence.js";
+import { checkBooleanResult } from "./boolean-gate.js";
 import { toEdgeFinder } from "./edge-selector.js";
 import { toFaceFinder } from "./face-selector.js";
 import { addSugar } from "./solid-sugar.js";
@@ -128,6 +129,66 @@ export function createOcctKernel(replicad) {
   // see occt-repair.js for the policies and why they differ per op.
   const { validChamfer, safeOp } = createOcctRepair(measureVolume, recordWarning);
 
+  // Boolean result gate (boolean-gate.js): the coincidence guard above refuses the
+  // one degenerate CONSTRUCTION it can recognise before a boolean runs; this judges
+  // the RESULT afterwards, by volume, and throws on the impossible — a union
+  // smaller than an input, a cut that grew, a negative volume, and the documented
+  // silent failure where OCCT hands back one operand instead of the union.
+  // `judge(op, shapes, run)` owns the ordering: operand volumes are read BEFORE
+  // `run` (replicad consumes what it fuses/cuts, so a fused tool measured
+  // afterwards would be a deleted shape), the result's after; both are memoized
+  // per replicad shape, since a judged result is the next op's operand. A
+  // one-operand call runs unjudged and unmeasured (the gate has nothing to
+  // compare). The probes run only on the signatures the inequalities cannot
+  // decide: an enclosure test off bounding boxes first — a padded B-spline box
+  // can only make enclosure HARDER to prove, the safe direction — then one
+  // intersect on clones, freed at once. That intersect goes through the
+  // coincidence guard like every other boolean here, because it runs on exactly
+  // the operand pair that just misbehaved: a refused pair answers "nothing
+  // inside", which on the equal-volume signature is the refusal the gate was
+  // about to make anyway rather than a grind the WASM build cannot abort. A
+  // refusal is remembered by cache key so a live edit does not re-pay the failing
+  // boolean and its probe on every rebuild, and the refused shape is freed.
+  const volumes = new WeakMap();
+  const volumeOf = (s) => {
+    let v = volumes.get(s);
+    if (v === undefined) { v = measureVolume(s); volumes.set(s, v); }
+    return v;
+  };
+  const BOX_SLACK = 1e-3; // mm — an enclosure test, not a measurement
+  const encloses = (a, b) => {
+    const [amin, amax] = a.boundingBox.bounds, [bmin, bmax] = b.boundingBox.bounds;
+    return [0, 1, 2].every((k) => bmin[k] >= amin[k] - BOX_SLACK && bmax[k] <= amax[k] + BOX_SLACK);
+  };
+  const judge = (op, shapes, run, label = op) => {
+    if (shapes.length < 2) return run();
+    const operandVolumes = shapes.map(volumeOf);
+    const result = run();
+    const err = checkBooleanResult(op, operandVolumes, volumeOf(result), {
+      encloses: (i, j) => encloses(shapes[i], shapes[j]),
+      overlap: (i, j) => {
+        try { guardBoolean("intersect", [shapes[i], shapes[j]]); }
+        catch (e) { if (e?.code === "COINCIDENT_BOOLEAN") return 0; throw e; }
+        let x;
+        try { x = shapes[i].clone().intersect(shapes[j].clone()); return measureVolume(x); }
+        finally { x?.delete?.(); }
+      },
+    }, label);
+    if (err) { result.delete?.(); throw err; }
+    return result;
+  };
+  const refusals = new Map();
+  const judgedCache = (key, make) => {
+    const remembered = refusals.get(key);
+    if (remembered) throw remembered;
+    return cached(key, () => {
+      try { return make(); } catch (e) {
+        if (e?.code === "BOOLEAN_RESULT_INVALID") refusals.set(key, e);
+        throw e;
+      }
+    });
+  };
+
   // name -> { shape, digest } | { error, digest } — imported geometry the framework
   // registers pre-build via `_registerImport` (kernel-lifetime, untracked by the
   // solid cache: imports are the framework's own memo, keyed by name+digest).
@@ -228,26 +289,32 @@ export function createOcctKernel(replicad) {
       },
       cut: (t) => {
         const key = h("cut", hash, t._hash);
-        return cached(key, () => {
+        return judgedCache(key, () => {
           const a = mat(), b = t._mat();
           guardBoolean("cut", [a._s, b._s]);
-          return wrap(a._s.clone().cut(b._s.clone()), [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
+          const result = judge("cut", [a._s, b._s], () => a._s.clone().cut(b._s.clone()));
+          return wrap(result, [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
         });
       },
       cutAll: (tools) => {
         const key = h("cutAll", hash, tools.map((t) => t._hash));
-        return cached(key, () => {
+        return judgedCache(key, () => {
           const a = mat(), bs = tools.map((t) => t._mat());
           if (bs.length === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          const toolShapes = bs.map((b) => b._s);
           // All pairs, tools included: the cut below first fuses the tools
           // together, so tool-to-tool contact hangs exactly like target-to-tool
           // (the measured case WAS two tools — a bore and its thread).
-          guardBoolean("cutAll", [a._s, ...bs.map((b) => b._s)]);
-          const fusedTools = bs
-            .slice(1)
-            .reduce((acc, b) => acc.fuse(b._s.clone()), bs[0]._s.clone());
+          guardBoolean("cutAll", [a._s, ...toolShapes]);
+          // The tool fuse is a union in its own right — the bore + thread case
+          // fails HERE (the thread dropped, the cut then honestly removes a plain
+          // bore), so it is judged as one before the cut is.
+          const fusedTools = judge("union", toolShapes,
+            () => bs.slice(1).reduce((acc, b) => acc.fuse(b._s.clone()), bs[0]._s.clone()),
+            "cutAll (tools)");
+          const result = judge("cutAll", [a._s, ...toolShapes], () => a._s.clone().cut(fusedTools));
           return wrap(
-            a._s.clone().cut(fusedTools),
+            result,
             [...cloneLabels(a._labels), ...bs.flatMap((b) => cloneLabels(b._labels))],
             key,
           );
@@ -255,18 +322,20 @@ export function createOcctKernel(replicad) {
       },
       intersect: (t) => {
         const key = h("intersect", hash, t._hash);
-        return cached(key, () => {
+        return judgedCache(key, () => {
           const a = mat(), b = t._mat();
           guardBoolean("intersect", [a._s, b._s]);
-          return wrap(a._s.clone().intersect(b._s.clone()), [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
+          const result = judge("intersect", [a._s, b._s], () => a._s.clone().intersect(b._s.clone()));
+          return wrap(result, [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
         });
       },
       union: (t) => {
         const key = h("union", [hash, t._hash]);
-        return cached(key, () => {
+        return judgedCache(key, () => {
           const a = mat(), b = t._mat();
           guardBoolean("union", [a._s, b._s]);
-          return wrap(a._s.clone().fuse(b._s.clone()), [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
+          const result = judge("union", [a._s, b._s], () => a._s.clone().fuse(b._s.clone()));
+          return wrap(result, [...cloneLabels(a._labels), ...cloneLabels(b._labels)], key);
         });
       },
       clone: () => wrap(shape.clone(), cloneLabels(labels), hash, pose, baseHash),
@@ -343,7 +412,7 @@ export function createOcctKernel(replicad) {
           return wrap(safeOp(a._s.clone(), (sh) => sh.shell(thickness, toFaceFinder(openFaces)), `shell(${thickness})`), cloneLabels(a._labels), key);
         });
       },
-      volume: () => measureVolume(mat()._s),
+      volume: () => volumeOf(mat()._s), // shares the gate's memo — a judged result is already measured
       // Same default as toSTL: an export is an export, so a .3mf must not ship a
       // coarser tessellation than the .stl of the same solid would.
       toIndexedMesh: ({ quality = "print" } = {}) => {
@@ -643,11 +712,11 @@ export function createOcctKernel(replicad) {
     sphere: (r) => cached(h("sphere", r), () => wrap(makeSphere(r), [], h("sphere", r))),
     union: (solids) => {
       const key = h("union", solids.map((s) => s._hash));
-      return cached(key, () => {
+      return judgedCache(key, () => {
         const ms = solids.map((s) => s._mat());
         guardBoolean("union", ms.map((m) => m._s));
         return wrap(
-          ms.map((m) => m._s.clone()).reduce((a, b) => a.fuse(b)),
+          judge("union", ms.map((m) => m._s), () => ms.map((m) => m._s.clone()).reduce((a, b) => a.fuse(b))),
           ms.flatMap((m) => cloneLabels(m._labels)),
           key,
         );
@@ -661,10 +730,15 @@ export function createOcctKernel(replicad) {
     // Same cache key as union — the geometry is identical either way.
     _trustedUnion: (solids) => {
       const key = h("union", solids.map((s) => s._hash));
-      return cached(key, () => {
+      return judgedCache(key, () => {
         const ms = solids.map((s) => s._mat());
+        // Trusted skips the PRE-check only; the result is judged like any union —
+        // the volume gate is precisely what proves the trusted composition worked.
+        // Labelled for what it is: the author never wrote this union, so a refusal
+        // here means the framework's own audited composition broke on this kernel.
         return wrap(
-          ms.map((m) => m._s.clone()).reduce((a, b) => a.fuse(b)),
+          judge("union", ms.map((m) => m._s), () => ms.map((m) => m._s.clone()).reduce((a, b) => a.fuse(b)),
+            "k.tappedBore's bore ∪ thread union (the framework's own composition — report this)"),
           ms.flatMap((m) => cloneLabels(m._labels)),
           key,
         );

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

@@ -4,7 +4,7 @@
 // Catching them statically removes both the wasted boot and the stdout caveat.
 import { err } from "./finding.js";
 import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
-import { PROFILES } from "../oracle/dfm-profiles.js";
+import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
 import { parseAssertion } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
 
@@ -285,4 +285,20 @@ export const VERIFY_RULES = [
       return checkProcessSpec(process, "verify.process", valid, new Set());
     },
   },
+  {
+    // dfm-profiles.js overhangAngleFor throws on an orientation outside
+    // ORIENTATIONS — the overhang opt-in's one legal value — with the same
+    // mid-run loudness as an unknown profile name, so it gets the same rule.
+    id: "verify-unknown-orientation",
+    run: ({ part }) => {
+      const orientation = part?.verify?.orientation;
+      if (orientation == null) return [];
+      if (typeof orientation === "string" && ORIENTATIONS.includes(orientation)) return [];
+      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.`,
+        "verify.orientation")];
+    },
+  },
 ];

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

@@ -1,9 +1,13 @@
-// Reusable design-for-manufacturing process profiles. `bed` is the build volume
-// [x,y,z] in mm (a hard bbox-fit gate); `minWall` mm (a warn); `clearance` mm is
-// carried for a future gap check (not enforced yet).
+// 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); `clearance` mm is carried for a future gap check
+// (not enforced yet).
 export const PROFILES = {
-  "fdm-pla": { bed: [220, 220, 250], minWall: 1.2, clearance: 0.2 },
-  "fdm-petg": { bed: [220, 220, 250], minWall: 1.5, clearance: 0.3 },
+  "fdm-pla": { bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45 },
+  "fdm-petg": { bed: [220, 220, 250], minWall: 1.5, clearance: 0.3, overhang: 45 },
   "resin": { bed: [120, 68, 160], minWall: 0.6, clearance: 0.1 },
 };
 
@@ -21,3 +25,39 @@ export function resolveProfile(spec) {
   }
   throw new Error(`invalid process profile: ${JSON.stringify(spec)}`);
 }
+
+// The one legal `verify.orientation` value today. Z is up everywhere in partforge
+// and the bed is a sub-part's own lowest Z, so "print" is a declaration, not a
+// choice of axis.
+export const ORIENTATIONS = ["print"];
+
+// The angle an author's own `overhangArea` expectation is measured against when
+// the profile names none (a resin part, or no profile at all): FDM's usual 45.
+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;
+//   - 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,
+//     so a declared expectation is never answered "unavailable".
+// Throws on an orientation value outside ORIENTATIONS — verify's callers want that
+// loud, like an unknown profile name, and lint's `verify-unknown-orientation`
+// catches it before a kernel boots; gates.js wraps this total for measure().
+export function overhangAngleFor(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).overhang : undefined;
+  const angle = typeof fromProfile === "number" && Number.isFinite(fromProfile) ? fromProfile : null;
+  if (orientation === "print" && 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;
+}

package/src/framework/oracle/gates.js

@@ -10,7 +10,7 @@
 // `expect` function throws, is reported as GATED — the 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 } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
 import { expandCases } from "./cases.js";
 import { resolveParams } from "../part-model.js";
 
@@ -38,6 +38,15 @@ export function expandExpectations(part) {
   return expanded;
 }
 
+// The overhang angle a part is checked against, or null when it is not checked
+// (dfm-profiles.js overhangAngleFor holds the rule). Total, like the rest of this
+// file: a malformed orientation or profile answers null here and raises from
+// verify, where a reader can act on it. measure() asks so the fact is computed
+// for exactly the parts that will be judged on it.
+export function partOverhangAngle(part, { process, expanded } = {}) {
+  try { return overhangAngleFor(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

@@ -5,7 +5,8 @@ import { resolveParams } from "../part-model.js";
 import { meshGaps, pairKey, CONTACT_EPS, GAP_THRESHOLD } from "./gaps.js";
 import { bounds, meshArea, meshCentroid } from "./mesh.js";
 import { minWall, DIAGNOSTIC_SAMPLES } from "./min-wall.js";
-import { partGatesMinWall } from "./gates.js";
+import { overhang } from "./overhang.js";
+import { partGatesMinWall, partOverhangAngle } from "./gates.js";
 
 const size = ({ min, max }) => [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
 const unionBounds = (list) => list.reduce(
@@ -123,6 +124,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // inward ray per sampled triangle plus the BVH those rays need — and on an
   // ungated part it buys a fact nobody checks, at full price, on every agent edit.
   const minWallSamples = partGatesMinWall(part) ? undefined : DIAGNOSTIC_SAMPLES;
+  // 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
+  // "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
+  // taken against the wrong threshold is worse than none.
+  const overhangAngle = opts.overhang !== undefined ? opts.overhang : partOverhangAngle(part);
   const subBounds = [];
   const subparts = built.map(({ name, solid, mesh }) => {
     const b = bounds(mesh.positions);
@@ -130,6 +139,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // Resolved lazily and only when asked for: without min-wall, a single-sub-part
     // view (no meshGaps) must still build no index at all.
     const mw = opts.minWall ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples }) : null;
+    // One pass over the triangles, no index — cheap enough for every lap. The bed
+    // is this sub-part's own lowest Z, already in hand from bounds(). A sub-part
+    // that is never printed (`exportable: false` — a reference ghost, a probe
+    // slab, a placeholder) is not judged. Judged in the DISPLAY pose, which is
+    // what measure builds; a part whose export pose differs (a lid that prints
+    // flat beside its base) is a known gap, stated in the authoring docs.
+    const printed = part.parts[name]?.exportable !== false;
+    const oh = overhangAngle != null && printed ? overhang(mesh, { maxAngle: overhangAngle, bedZ: b.min[2] }) : null;
     const vol = solid.volume();
     // Deviation-from-reference: only for a sub-part that declares `reference:
     // "<import name>"` (Task 12 — the gate that holds a parametric rebuild to
@@ -172,6 +189,11 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       // `measuredMinWall` false is "never looked".
       minWallSampled: mw?.sampled ?? false,
       minWallSamples: mw ? { sampled: mw.sampledTriangles, total: mw.totalTriangles } : null,
+      // Unsupported downward-facing area in mm² (overhang.js), null when the part
+      // is not laid out for a bed: bridges and bore ceilings count, by design.
+      overhangArea: oh ? oh.area : null,
+      overhangAngle: oh?.worstAngle ?? null,
+      overhangAt: oh?.at ?? null,
     };
   });
 
@@ -231,6 +253,10 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // nothing measured it, which reads identically to "no reading available";
     // verify's seeding rule turns on exactly this distinction (see verify.js).
     measuredMinWall: !!opts.minWall,
+    // The overhang angle every sub-part's `overhangArea` was measured against,
+    // or null when the pass did not run — read by verify's seed gate, never a
+    // caller's claim.
+    measuredOverhang: overhangAngle ?? null,
     // 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/overhang.js

@@ -0,0 +1,111 @@
+// src/framework/oracle/overhang.js
+// Unsupported downward-facing surface, for a part oriented for a print bed.
+//
+// One pass over the triangles, pure, no BVH and no rays — cheap enough to run on
+// the quick lap alongside bbox and volume, and deliberately NOT sampled the way
+// min-wall.js is: a sampled minimum degrades to an honest upper bound, but a
+// sampled AREA is an estimate that would flicker either side of the warning
+// floor between identical laps. Measured at ~13 ms on a 400k-triangle soup before
+// the prefilter below, under `meshArea`'s own cost.
+//
+// A face is an overhang when its outward normal points down more steeply than
+// the process allows: the angle is measured FROM VERTICAL, so a wall reads 0°,
+// a 45° chamfer 45°, a ceiling 90°, and a face counts when its angle exceeds
+// `maxAngle` (FDM's usual 45) by more than ANGLE_EPS — a chamfer authored AT the
+// angle must not warn, and float32 positions perturb a computed normal by ~1e-6,
+// which is a thousandth of a degree, not the nanodegree a sine-space epsilon
+// would allow (measured: a 45° underside fired on 32 of 40 Z-rotations before
+// the tolerance moved into angle space).
+//
+// Two bands of faces are excluded, both against the bed — the MESH's own lowest
+// Z rather than z = 0, so an assembly's sub-parts are each judged as printed
+// separately on their own base:
+//   - the footprint: faces with every vertex within `bedEps` of the bed. The
+//     slack scales with the part (0.1% of its height, floored at 10 µm) because a
+//     single boolean-noise vertex a few microns low, or a 0.001° tilt, would
+//     otherwise lift the entire bottom face off the bed and report it as a 90°
+//     ceiling (measured on a 60×60×5 plate: 3600 mm² of false overhang either way).
+//   - the near-bed band: faces whose centroid sits within `bedBand` (1 mm) of the
+//     bed. That is the lower curl of a bottom-edge fillet or chamfer — a 20×20×5
+//     plate with r=1 fillets carried 58 mm² of "overhang" there, and every FDM
+//     printer lays those first layers down fine. A real ceiling under 1 mm of
+//     clearance is missed by the same rule; that gap is not printable anyway.
+//
+// Known limit, stated rather than hidden: a bridge (a flat underside spanning two
+// supports) is geometrically a ceiling, and the mesh alone cannot tell the two
+// apart, so it is reported as an overhang. That is why this fact backs a WARNING
+// and never a gate. Likewise the ceiling of a horizontal bore counts, which is
+// usually what a print-minded author wants told.
+//
+// Works on both mesh forms the oracle sees (Manifold's 9-floats-per-triangle soup
+// and OCCT's indexed vertices), same as min-wall.js.
+
+const DEG = 180 / Math.PI;
+// Angle-space tolerance on the threshold (degrees): well above float32 normal
+// noise (~1e-3°), far below any angle an author would distinguish.
+const ANGLE_EPS = 0.01;
+// A face too small to have a trustworthy normal contributes its (negligible) area
+// but never the reported worst angle — a float32 sliver's normal is round-off, and
+// one such sliver used to report a 90° ceiling on a part with none.
+const MIN_ANGLE_AREA = 1e-6; // mm²
+
+/**
+ * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, triangles: number }} mesh
+ * @param {{ maxAngle?: number, bedZ?: number, bedEps?: number, bedBand?: number }} [opts]
+ *   `maxAngle` in degrees from vertical (default 45); `bedZ` the bed height if the
+ *   caller already knows the mesh's lowest Z (else scanned); `bedEps` the footprint
+ *   slack (default 0.1% of the mesh height, floored at 0.01 mm); `bedBand` the
+ *   near-bed band (default 1 mm)
+ * @returns {{ area: number, worstAngle: number|null, at: number[]|null }|null}
+ *   `area` in mm² of every offending face, `worstAngle` the steepest one found,
+ *   `at` the centroid of the largest offending triangle (a place to point at);
+ *   null for an empty mesh.
+ */
+export function overhang(mesh, { maxAngle = 45, 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;
+    }
+  }
+  const bed = bedZ ?? minZ;
+  const eps = bedEps ?? Math.max(0.01, 1e-3 * (maxZ - minZ));
+  const bandTop = bed + bedBand;
+
+  // Prefilter in sine space, generously: only faces that might exceed the angle
+  // pay for the asin. The exact comparison is in degrees.
+  const nearLimit = Math.sin(Math.max(0, maxAngle - 1) / DEG);
+  let area = 0, worst = -1, largest = 0, 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];
+    if (az - bed <= eps && bz - bed <= eps && cz - bed <= eps) continue;     // the footprint
+    if ((az + bz + cz) / 3 <= bandTop) continue;                              // the near-bed band
+    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
+    const len = Math.hypot(nx, ny, nz);
+    if (len < 1e-9) continue;                                                 // degenerate: no normal
+    const down = -nz / len;
+    if (down <= nearLimit) continue;
+    const angle = Math.asin(Math.min(1, down)) * DEG;
+    if (angle <= maxAngle + ANGLE_EPS) continue;
+    const triArea = len / 2;
+    area += triArea;
+    if (triArea >= MIN_ANGLE_AREA && angle > worst) worst = angle;
+    if (triArea > largest) {
+      largest = triArea;
+      at = [(positions[a] + positions[b] + positions[c]) / 3,
+            (positions[a + 1] + positions[b + 1] + positions[c + 1]) / 3,
+            (az + bz + cz) / 3];
+    }
+  }
+  return { area, worstAngle: worst < 0 ? null : worst, at };
+}

package/src/framework/oracle/verify.js

@@ -1,7 +1,7 @@
 import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
 import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
-import { resolveProfile } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "../param-deps.js";
 import { byteAwareReplacer } from "../geometry/solid-hash.js";
@@ -153,7 +153,10 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
 }
 
 // Pure policy: profile rules + per-part expect → checks for one case's facts.
-export function evaluateCase(facts, { profile, expect, subPartNames }) {
+// `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.
+export function evaluateCase(facts, { profile, expect, subPartNames, overhang = null }) {
   const checks = [];
   // contacts/clearance are per-pair, not scalar view metrics — peel them off
   // before the registry loop and hand them to pairGapChecks.
@@ -170,9 +173,14 @@ export function evaluateCase(facts, { profile, expect, subPartNames }) {
   // rays were cast and all missed, wrong when they were never cast. The stamp is
   // what tells those apart, and it is measure()'s own, never a caller's claim.
   const minWallSkipped = facts.measuredMinWall === false;
+  // Same shape for overhang: the rule is armed but these facts were measured
+  // without the pass (a quick lap reusing a seed that had no angle), so the check
+  // is withheld rather than read as "unavailable" — which would count as answered.
+  const overhangSkipped = overhang != null && (facts.measuredOverhang ?? null) === null;
   for (const s of facts.subparts) {
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
+      ...(overhang != null ? { overhangArea: "<=1" } : {}),
       ...(expect?.[s.name] ?? {}),
     };
     for (const [metric, expr] of Object.entries(merged)) {
@@ -182,6 +190,11 @@ export function evaluateCase(facts, { profile, expect, subPartNames }) {
           hint: "re-run this check without `quick` to measure min wall" });
         continue;
       }
+      if (overhangSkipped && metric === "overhangArea" && c.actual == null) {
+        checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
+          hint: "re-run this check without `quick` to measure overhang" });
+        continue;
+      }
       checks.push(c);
     }
   }
@@ -208,6 +221,8 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // budget by it) and must not derive it separately — see there.
   const expanded = expandExpectations(part);
   const needMinWall = partGatesMinWall(part, { process, expanded });
+  // Throws on a bad `verify.orientation`, the same loudness as a bad profile name.
+  const overhangAngle = overhangAngleFor(part, process, { expanded });
   const readKeys = subPartReadKeys(part, view, part.defaults);
   // byteAwareReplacer on the RELEVANT_ALL branch too: an unattributable derive()
   // still might read a byte-valued image param, and this memo key gates whether
@@ -263,7 +278,13 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // a min-wall-less seed is reused, and the min-wall gate it cannot answer becomes
   // `unevaluated` instead of being re-measured. The rule exists to stop a coarse
   // reading standing in for a gate's verdict, and a withheld verdict does that too.
-  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && seed.result.view === view) {
+  // The overhang half of the same rule: a seed is admitted only when it was
+  // measured against the angle THIS run needs (both null when neither checks) —
+  // `measuredOverhang` is stamped by measure() itself. A `process` override that
+  // changes the angle therefore re-measures rather than reusing the inspect
+  // job's seed, which was taken against the part's own profile.
+  const overhangMatches = (seed?.result?.measuredOverhang ?? null) === (overhangAngle ?? null);
+  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && seed.result.view === view) {
     memo.set(signature({ ...part.defaults, ...(seed.params ?? {}) }), seed.result);
   }
 
@@ -274,7 +295,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     // `probes: false` — no gate reads probe values, so re-running their booleans
     // for every case buys nothing. (A seed measured WITH probes is a superset in
     // the same way a min-wall seed is: the extra key is simply never read here.)
-    memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall, probes: false }));
+    memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall, probes: false, overhang: overhangAngle }));
     return memo.get(key);
   };
 
@@ -291,19 +312,63 @@ 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 }) : notMeasured(name) };
+    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, overhang: overhangAngle }) : 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
+  // (the CLI's exit code, the cloud agent's "verify passes" stop rule) took that
+  // as verified. Nothing was. Two counts, and the difference between them is a
+  // second thing this used to hide:
+  //   `declared`  — checks the part or its profile asked for, as produced: the
+  //                 undeclared near-miss warnings are facts the oracle volunteers
+  //                 and the quick-lap "not measured" marker stands for a case,
+  //                 so neither counts;
+  //   `evaluated` — the declared checks that were actually answered. A check
+  //                 that SKIPPED (a `ref*` metric on a sub-part with no
+  //                 reference, `holes` on the OCCT backend, a pair on a disabled
+  //                 sub-part) was declared, but it verified nothing.
+  // Zero evaluated withholds the verdict — the same `null` a quick lap uses for
+  // "could not check", because that is what it is. Whether anything was DECLARED
+  // is decided from the declaration itself (`profile`, the expanded `expect`
+  // maps, an armed overhang angle), never from the produced checks: on a quick
+  // lap whose seed matches no case there are no checks at all, and counting
+  // those would print "no expectations declared" at a part that declares plenty.
+  // The notice rides `warnings`, the channel every host already shows, and is
+  // deliberately NOT pushed into any case's check list — it is about the part,
+  // not about `defaults`. A quick lap that withheld gates explains itself through
+  // `unevaluated` and gets no notice.
+  const isDeclared = (c) => c.scope !== "case" && c.metric !== "nearMiss";
   const all = caseResults.flatMap((c) => c.checks.map((ch) => ({ case: c.name, ...ch })));
+  let declared = 0, evaluated = 0;
+  for (const c of all) {
+    if (!isDeclared(c)) continue;
+    declared++;
+    if (c.status !== "skip" && !c.unevaluated) evaluated++;
+  }
+  const declaresAnything = profile != null || overhangAngle != 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");
+  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,
+      message: declaresAnything ? "no expectation could be evaluated" : "no expectations declared",
+      hint: declaresAnything
+        ? "every declared check skipped — see the skip reasons above (a metric this backend cannot read, a reference the sub-part does not declare, a disabled sub-part) and declare something this run can answer"
+        : "nothing was verified — pin the dimensions and features the part is meant to have in verify.expect (and a process profile for bed fit and min wall), so every edit re-checks them" });
+  }
   return {
     // Tri-state, and the order matters: a real failure is still a failure even on a
-    // lap that skipped other gates, so `false` outranks the withheld `null`.
-    ok: failures.length ? false : unevaluated.length ? null : true,
+    // lap that skipped other gates, so `false` outranks the withheld `null`; and a
+    // part on which nothing was evaluated has no verdict to give.
+    ok: failures.length ? false : unevaluated.length || evaluated === 0 ? null : true,
     view,
     cases: caseResults,
     failures,
-    warnings: all.filter((c) => c.status === "warn"),
+    warnings,
     unevaluated,
+    declared,
+    evaluated,
   };
 }

package/src/framework/verify-metrics.js

@@ -46,6 +46,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",
+    locate: (s) => s.overhangAt,
+    note: (s) => (s.overhangAngle != null ? `steepest unsupported face ${s.overhangAngle.toFixed(1)}° from vertical` : null) },
   // `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/oracle.js

@@ -21,6 +21,7 @@ export { measure } from "./framework/oracle/measure.js";
 export { verify } from "./framework/oracle/verify.js";
 export { buildBVH, meshTriangles } from "./framework/oracle/bvh.js";
 export { minWall } from "./framework/oracle/min-wall.js";
+export { overhang } from "./framework/oracle/overhang.js";
 // Mesh file parsers — the import pipeline's own readers, browser-safe pure
 // functions; the oracle package's corpus tests read real files through them.
 export { parseStl } from "./framework/geometry/stl-parse.js";