partforge 0.110.0 → 0.111.1

package/bin/cli.js

@@ -222,11 +222,17 @@ const commands = {
       };
       if (flags.out) writeOut();
       let vok = true;
-      if ((part.verify || flags.process) && !flags["no-verify"]) {
+      // Always, not only when the part has a `verify` block: a part with none is
+      // the most vacuous case of all, and the "nothing verified" verdict below
+      // exists to say so rather than let a clean exit read as verified.
+      if (!flags["no-verify"]) {
         const v = verify(kernel, part, { process: flags.process, view });
         if (!flags.json) printVerify(v);
         report.verify = v;
-        vok = v.ok;
+        // Tri-state: `null` is a withheld verdict (nothing declared, or a check
+        // that could not run), not a failure — the notice prints; the exit code
+        // reports only what actually failed.
+        vok = v.ok !== false;
         if (flags.out) writeOut();
       }
       if (flags.out) console.log(`\nwrote ${flags.out}`);
@@ -542,8 +548,21 @@ function printVerify(v) {
       }
     }
   }
+  // Part-level notices live only in `warnings` (they are about the part, not a
+  // case), so they print here, after the cases.
+  for (const n of v.warnings.filter((c) => c.scope === "part")) {
+    console.log(`  part`);
+    console.log(`    ⚠ ${n.metric}  (${n.message})`);
+    if (n.hint) console.log(`        hint: ${n.hint}`);
+  }
   const f = v.failures.length, w = v.warnings.length;
-  console.log(`  result: ${f ? `${f} gate failure(s)` : "all gates passed"}${w ? `, ${w} warning(s)` : ""}`);
+  // One switch on the tri-state verdict, so the line and `ok` cannot disagree.
+  const verdict = v.ok === false ? `${f} gate failure(s)`
+    : v.ok === true ? "all gates passed"
+    : v.unevaluated?.length ? `verdict withheld (${v.unevaluated.length} check(s) not evaluated)`
+    : v.declared ? "nothing verified (every declared check skipped)"
+    : "nothing verified (no expectations declared)";
+  console.log(`  result: ${verdict}${w ? `, ${w} warning(s)` : ""}`);
 }
 
 function printLint(r) {

package/docs/AUTHORING-PARTS.md

@@ -2860,6 +2860,7 @@ probe runs).
 
 **Verify block** — `verify-unknown-metric`, `verify-unknown-subpart`,
 `verify-bad-expr`, `verify-bad-pair-check`, `verify-unknown-process`,
+`verify-unknown-orientation`,
 `verify-expect-throws` (all errors). Note `_view` also accepts the pair-wise
 `contacts` / `clearance` keys, which are not scalar view metrics; they are
 validated by `verify-bad-pair-check`, matching `verify.js`'s own handling.
@@ -2993,11 +2994,13 @@ carries:
 - `hint` — one self-contained corrective sentence (always present),
 - `pattern` — a stable [ERROR-PATTERNS.md](ERROR-PATTERNS.md) entry ID when one
   applies (follow it with `ERROR-PATTERNS.md#<id>`),
-- `note` — an optional caveat about *how* the value was measured, attached
-  whatever the verdict. Today only `minWall` sets one, when the reading came
-  from a sample rather than every triangle (see below),
+- `note` — an optional caveat about *how* the value was measured, or a companion
+  reading, attached whatever the verdict. `minWall` sets one when the reading came
+  from a sample rather than every triangle (see below); `overhangArea` sets one
+  naming the steepest unsupported face's angle,
 - `location` — `[x, y, z]` in mm where the metric has one: `minWall` (thinnest
-  sample point) and `overlaps` (the center of the first offending intersection's
+  sample point), `overhangArea` (the largest unsupported face's centroid) and
+  `overlaps` (the center of the first offending intersection's
   *bounding box* — a nearby indicator, not an exact point: when a pair overlaps in
   more than one place the bbox center can fall in the empty space between regions)
   and the pair checks `contact` / `clearance` / `nearMiss` (the midpoint between
@@ -3010,6 +3013,11 @@ exists, e.g. the OCCT backend or min-wall measurement turned off, matching
 per triangle, which is unbounded work on a dense mesh, so past a sample budget
 it casts from a spread, deterministic subset instead — `minWallSampled` (boolean)
 and `minWallSamples` (`{ sampled, total }` or `null`) say whether that happened.
+A part that opted into the overhang check (see the `verify` block) also carries
+`overhangArea` (mm² of unsupported downward-facing surface, `null` when not
+checked or on an `exportable: false` sub-part), `overhangAngle` (the steepest such
+face, degrees from vertical) and `overhangAt` (that face's centroid); the report's
+`measuredOverhang` stamps the angle the pass ran against, or `null`.
 **The budget depends on whether the reading is checked against anything**: a part
 that declares a min-wall gate — a `verify.process` profile, or an `expect`
 mentioning `minWall` — gets 50,000, because a gate's verdict rides on it; a part
@@ -3099,7 +3107,9 @@ A part can declare how it should be checked, co-located with its schema, so
 ```js
 verify: {
   process: "fdm-pla",            // a DFM profile: fdm-pla | fdm-petg | resin, or an
-                                  // inline { bed:[x,y,z], minWall, clearance } object
+                                  // inline { bed:[x,y,z], minWall, clearance, overhang } object
+  orientation: "print",          // optional; ONLY with this is overhang checked — it says the
+                                  // part is laid out for its bed (Z up, bed at the lowest Z)
   cases: ["defaults", "M3"],     // optional; default = defaults + every preset
   expect: {                      // design intent, by sub-part name (+ "_view")
     spacer: { holes: 1, bbox: "<=[60,60,60]", volume: "0.4..0.6cm3" },
@@ -3110,10 +3120,30 @@ verify: {
 }
 ```
 
-**What the profile gives you:** a hard **bed-fit** gate (the view bbox must fit `bed`)
-and a **min-wall** warning. **What `expect` gives you:** per-sub-part assertions on the
-facts `measure` already reports — `holes` (through-bores / genus), `volume`,
-`surfaceArea`, `triangleCount`, `bbox`, `watertight`, `minWall`, `boundsMin` / `boundsMax`
+**What the profile gives you:** a hard **bed-fit** gate (the view bbox must fit `bed`),
+a **min-wall** warning, and — only for a part that also declares
+`orientation: "print"` — an **overhang** warning: `overhangArea` is the mm² of
+downward-facing surface steeper than the profile's `overhang` angle (45° from vertical
+on the FDM profiles; resin carries none, since it prints on supports), measured per
+sub-part with the bed at that sub-part's own lowest Z, and warned past 1 mm². The
+opt-in is deliberate: a profile says what a process can print, the orientation key
+says this part is laid out for it, and a part still being shaped, or one bound for a
+different process, should not be nagged about its underside. Writing your own
+`overhangArea` expectation is the other way in — it arms the measurement by itself,
+against the profile's angle or 45° when the profile names none, so a declared
+expectation is never answered "unavailable". Two bands next to the bed are never
+counted: the footprint itself, and faces whose centroid sits within 1 mm of the bed
+(the lower curl of a bottom-edge fillet or chamfer, which prints fine). A bridge (a
+flat underside spanning two supports) and the ceiling of a horizontal bore are
+reported as overhangs — the mesh alone cannot tell a bridge from a ceiling — which
+is why this is a warning and never a gate. Two more limits, stated: it is judged in
+the DISPLAY pose, so a sub-part whose `place` differs for export (a lid that prints
+flat beside its base) is measured as displayed, and `exportable: false` sub-parts
+are skipped. Switch it off under an FDM profile with an inline
+`{ base: "fdm-pla", overhang: null }`. **What `expect` gives you:** per-sub-part
+assertions on the facts `measure` already reports — `holes` (through-bores / genus),
+`volume`, `surfaceArea`, `triangleCount`, `bbox`, `watertight`, `minWall`,
+`overhangArea`, `boundsMin` / `boundsMax`
 (the axis-aligned `{min,max}` corner positions — where the geometry sits, vs
 `bbox` which is only its size) and `centerOfMass` (`[x,y,z]`, the volume-weighted
 centroid; `null` for a degenerate/zero-volume sub-part); and `_view` assertions `bbox`,
@@ -3150,9 +3180,25 @@ verify: { expect: {
 
 **Gates vs. warnings:** exact facts are **gates** (a failure sets a non-zero exit code);
 `minWall` is computed (a ray/shot wall-thickness measurement) and reported as a
-**warning** — it flags walls below the profile's minimum but never fails the build.
-`holes`/`watertight` are Manifold-only, so those assertions **skip** on OCCT parts
-rather than fail.
+**warning** — it flags walls below the profile's minimum but never fails the build —
+and so is `overhangArea` (see above). `holes`/`watertight` are Manifold-only, so those
+assertions **skip** on OCCT parts rather than fail.
+
+**A verify block that declares nothing verifies nothing.** `verify.ok` is tri-state:
+`true` when every declared check passed, `false` on any gate failure, and `null` when
+no verdict can be given — a quick lap that could not measure a gate, or a part with
+**no declared expectations** at all (no `verify` block, an empty `expect`, no profile).
+That last case used to read as `ok: true` with zero checks, which every reader took as
+"verified". It now comes back `ok: null` with `evaluated: 0` and a `no expectations
+declared` warning whose hint says what to pin; the CLI runs verify on every part, block
+or no block, prints *nothing verified* and exits 0 (a withheld verdict is not a
+failure). The same `null` covers a part that declared checks none of which could be
+answered — every one SKIPPED (a `ref*` metric on a sub-part with no `reference`,
+`holes` on the OCCT backend, a pair on a disabled sub-part) — with a `no expectation
+could be evaluated` warning instead; `declared` and `evaluated` on the report tell
+the two apart. A single answerable expectation — or a process profile, which brings
+the bed-fit gate — is enough for a verdict. Treat `null` as "not verified", never as
+a pass.
 
 **Per-case expectations.** Checks run across defaults **and every preset**, so a
 static `expect` breaks the moment a preset legitimately changes an asserted fact —

package/docs/KERNEL-CONTRACT.md

@@ -914,8 +914,8 @@ The recurring constraint: every op here is implementable on **both** a mesh-CSG
 and a B-rep kernel (see `docs/geometry-backend-strategy.md` for why that dual-backend
 property is worth protecting — OCCT booleans are ~75–1400× slower). Generation *safety*
 comes not from a restricted DSL but from the verify loop (`measure`/`verify` gates:
-`bbox`, `volume`, `holes`, `watertight`, overlaps — plus `minWall` *warnings*, which
-report but never fail) — a generator gets machine-checkable
+`bbox`, `volume`, `holes`, `watertight`, overlaps — plus `minWall` and `overhangArea`
+*warnings*, which report but never fail) — a generator gets machine-checkable
 pass/fail feedback per part, which a syntax could never provide.
 
 ## Conformance checklist for a new backend or host

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.110.0",
+  "version": "0.111.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/annotate/annotate-mode.js

@@ -84,7 +84,15 @@ export function createAnnotateMode(viewer, { stage, getContext, onSend, createCa
   let hoverProbe = null; // hand tool: what's under the pointer right now (no gesture)
   const modeListeners = new Set();
   const toolListeners = new Set();
-  const notifyMode = () => { for (const cb of [...modeListeners]) cb(); };
+  // Every listener hears every transition: the host application registers its
+  // relay AFTER mount.js's own listeners, so a throw in one of ours must not
+  // end the loop before the host is told — and must never escape setEnabled,
+  // which send() calls after the ink is already discarded.
+  const notifyMode = () => {
+    for (const cb of [...modeListeners]) {
+      try { cb(); } catch (err) { console.error("mode listener failed", err); }
+    }
+  };
   const notifyTool = () => { for (const cb of [...toolListeners]) cb(); };
 
   const rectOf = () => canvas.element.getBoundingClientRect();

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/measure/measure-mode.js

@@ -54,7 +54,15 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
   const pinListeners = new Set();
   const notifyPins = () => { for (const cb of [...pinListeners]) cb(); };
   const modeListeners = new Set();
-  const notifyMode = () => { for (const cb of [...modeListeners]) cb(); };
+  // Every listener hears every transition: the host application registers its
+  // relay AFTER mount.js's own listeners, so a throw in one of ours must not
+  // end the loop before the host is told — and must never escape setEnabled,
+  // which send() calls after the ink is already discarded.
+  const notifyMode = () => {
+    for (const cb of [...modeListeners]) {
+      try { cb(); } catch (err) { console.error("mode listener failed", err); }
+    }
+  };
 
   let enabled = false;
   let units = "mm";            // display only; values stay mm internally

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/selection/hover.js

@@ -11,8 +11,14 @@ export function attachHoverLabels(
   viewer,
   { part, schedule = (cb) => requestAnimationFrame(cb), tooltip } = {},
 ) {
-  // Hover is a mouse idiom — skip entirely on touch-only devices.
-  if (globalThis.matchMedia && !matchMedia("(hover: hover)").matches) return { detach: () => {} };
+  // Hover is a mouse idiom — skip entirely on touch-only devices. The stub
+  // still answers the WHOLE interface: mount.js calls setSuppressed from the
+  // measure and annotate mode-change listeners without asking which device it
+  // is on, and a missing method there threw inside notifyMode on every phone —
+  // aborting the listener loop before the host application's own relay ran.
+  if (globalThis.matchMedia && !matchMedia("(hover: hover)").matches) {
+    return { setSuppressed: () => {}, detach: () => {} };
+  }
 
   const ownsTooltip = !tooltip;
   const tooltipPresenter = tooltip ?? createTooltipPresenter();

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";

package/types/oracle.d.ts

@@ -12,7 +12,7 @@ export {
   type MeasureReport, type SubPartFacts, type AggregateFacts, type BuiltSubPart,
   type VerifyReport, type VerifyCaseResult, type VerifyCheck, type CheckStatus,
   // mesh facts, gaps, BVH, min wall
-  meshVolume, bboxSize, bounds, meshArea, assemblyGaps, meshGaps, buildBVH, meshTriangles, minWall,
+  meshVolume, bboxSize, bounds, meshArea, assemblyGaps, meshGaps, buildBVH, meshTriangles, minWall, overhang,
   type Gap, type BVH,
   // mesh file parsers (the import pipeline's own readers)
   parseStl, parse3MF,

package/types/part.d.ts

@@ -408,6 +408,13 @@ export interface DfmProfile {
   bed?: [number, number, number];
   /** Minimum wall in mm — a warning, never a gate. */
   minWall?: number;
+  /**
+   * Steepest unsupported face the process prints cleanly, in degrees from
+   * vertical (45 on the FDM profiles; absent on resin). Checked only for a part
+   * that also declares `verify.orientation: "print"`; `null` switches it off
+   * under a named base. A warning, never a gate.
+   */
+  overhang?: number | null;
   /** Carried for a future gap check; not enforced yet. */
   clearance?: number;
   /** Inherit from a named profile and override the rest. */
@@ -441,6 +448,12 @@ export interface SubPartExpectations {
   boundsMin?: Expectation;
   boundsMax?: Expectation;
   minWall?: Expectation;
+  /**
+   * Unsupported downward-facing surface in mm² (faces steeper than the profile's
+   * `overhang` angle, bed at the sub-part's own lowest Z). Measured only under
+   * `verify.orientation: "print"`; a warning, never a gate.
+   */
+  overhangArea?: Expectation;
   /** Symmetric-difference volume vs. the sub-part's declared `reference` import. */
   refXorVolume?: Expectation;
   /** Percent volume delta vs. the sub-part's declared `reference` import. */
@@ -476,6 +489,13 @@ export interface ExpectMap {
 export interface VerifyBlock<P = ResolvedParams, D = Derived> {
   /** A named DFM profile or an inline one. */
   process?: DfmProfileName | DfmProfile;
+  /**
+   * `"print"` declares the part is laid out for its bed — Z up, each sub-part's
+   * bed at its own lowest Z — which is the only way the profile's `overhang`
+   * check is armed. Omit it while a part is still being shaped or is bound for
+   * another process.
+   */
+  orientation?: "print";
   /** Which cases to check; default is `"defaults"` plus every preset name. */
   cases?: string[];
   /**

package/types/testing.d.ts

@@ -250,6 +250,17 @@ export function minWall(
   totalTriangles: number;
 } | null;
 
+/**
+ * Unsupported downward-facing surface (oracle/overhang.js): the mm² of faces
+ * steeper than `maxAngle` from vertical, excluding the footprint on the bed
+ * (`bedZ`, else the mesh's lowest Z) and a near-bed band. One pass, no index;
+ * `null` only for an empty mesh. Bridges and bore ceilings count.
+ */
+export function overhang(
+  mesh: Mesh,
+  opts?: { maxAngle?: number; bedZ?: number; bedEps?: number; bedBand?: number },
+): { area: number; worstAngle: number | null; at: Point3 | null } | null;
+
 // --- measure ----------------------------------------------------------------
 
 export interface SubPartFacts {
@@ -272,6 +283,16 @@ export interface SubPartFacts {
   minWallAt: number[] | null;
   minWallSampled: boolean;
   minWallSamples: { sampled: number; total: number } | null;
+  /**
+   * Unsupported downward-facing area in mm² (oracle/overhang.js), `null` when the
+   * part is not laid out for a bed (`verify.orientation: "print"` under a
+   * profile with an `overhang` angle). Bridges and bore ceilings count.
+   */
+  overhangArea: number | null;
+  /** Steepest offending face, degrees from vertical; `null` when none. */
+  overhangAngle: number | null;
+  /** Centroid of the largest offending face; `null` when none. */
+  overhangAt: number[] | null;
 }
 
 export interface AggregateFacts {
@@ -289,6 +310,8 @@ export interface MeasureReport {
   view: string;
   /** Whether this run cast min-wall rays at all. */
   measuredMinWall: boolean;
+  /** The overhang angle every sub-part's `overhangArea` was measured against, `null` when the pass did not run. */
+  measuredOverhang: number | null;
   subparts: SubPartFacts[];
   aggregate: AggregateFacts;
   overlaps: Overlap[];
@@ -308,6 +331,12 @@ export function measure(
   params?: ResolvedParams,
   opts?: {
     minWall?: boolean;
+    /**
+     * The overhang angle to measure against (degrees from vertical), or `null`
+     * for "not checked". Omitted, measure derives it from the part's own
+     * `verify` block the way verify does.
+     */
+    overhang?: number | null;
     gapThreshold?: number;
     /**
      * A build of this view the caller already has, measured instead of building a
@@ -323,7 +352,8 @@ export function measure(
 export type CheckStatus = "pass" | "fail" | "warn" | "skip";
 
 export interface VerifyCheck {
-  scope: "view" | "subpart";
+  /** `"part"` is the vacuous-verify notice; `"case"` the quick-lap "not measured" marker. */
+  scope: "view" | "subpart" | "part" | "case";
   /** The sub-part name, `"a×b"` for a pair check, or `null` for a scalar view metric. */
   subpart: string | null;
   metric: string;
@@ -339,7 +369,7 @@ export interface VerifyCheck {
   hint?: string;
   /** A stable ERROR-PATTERNS.md entry id. */
   pattern?: string;
-  /** A caveat about HOW the value was measured — today only `minWall` sets one. */
+  /** A measurement caveat or companion reading — `minWall` (sampling) and `overhangArea` (the steepest angle) set one. */
   note?: string;
   /** `[x, y, z]` in mm, for the metrics that have one. */
   location?: number[] | null;
@@ -353,13 +383,25 @@ export interface VerifyCaseResult {
 }
 
 export interface VerifyReport {
-  /** True when no check has status `"fail"`. */
-  ok: boolean;
+  /**
+   * Tri-state: `true` when every declared check passed, `false` on any gate
+   * failure, `null` when no verdict can be given — a quick lap that could not
+   * measure a gate, or a part that declared no expectations at all (`declared`
+   * is 0 and `warnings` carries a `no expectations declared` notice). Never read
+   * `null` as a pass.
+   */
+  ok: boolean | null;
   view: string;
   cases: VerifyCaseResult[];
   /** Every failing check, flattened, each tagged with its `case`. */
   failures: Array<VerifyCheck & { case: string }>;
   warnings: Array<VerifyCheck & { case: string }>;
+  /** Checks a quick lap could not evaluate. */
+  unevaluated: Array<VerifyCheck & { case: string }>;
+  /** Check instances the part or its profile declared, across cases (near-miss notices excluded). */
+  declared: number;
+  /** Of `declared`, how many were actually answered — a skipped or unevaluated check is not. Zero withholds `ok`. */
+  evaluated: number;
 }
 
 /**