partforge 0.162.0 → 0.163.1

package/docs/AUTHORING-PARTS.md

@@ -4193,6 +4193,12 @@ A part that opted into the overhang check (see the `verify` block) also carries
 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`.
+A part checked for bed contact (an FDM profile, see the `verify` block) carries
+`bedContactPct` (0–100, the share of the near-bed flat underside on the bed; `null`
+when not checked or on an `exportable: false` sub-part), `bedContactArea` and
+`bedHoverArea` (mm² touching and hovering), `bedHoverGap` (how far above the bed the
+largest hovering face sits, `null` when nothing hovers) and `bedHoverAt` (its
+centroid); the report's `measuredBedContact` says whether the pass ran.
 A sub-part that declares `wall` (see the `verify` section below) also carries
 `wall` — `{ value, location, band, members }` or `null`: the declared band's
 worst member, located, with the band it was measured against and how many rays
@@ -4297,7 +4303,7 @@ 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 { base, bed:[x,y,z], minWall, overhang, fits, holeUndersize, bridge } object
+                                  // inline { base, bed:[x,y,z], minWall, overhang, bedContact, fits, holeUndersize, bridge } 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
@@ -4335,6 +4341,40 @@ flat beside its base) is measured as displayed, and `exportable: false` sub-part
 are skipped. Switch it off under an FDM profile with an inline
 `{ base: "fdm-pla", overhang: null }`.
 
+**Bed contact — a GATE, armed by the FDM profile alone.** Every exporter and slicer
+lays a printed piece on its lowest point. When that point is something small — a
+horizontal knuckle or pin whose cylinder dips under the plate, lettering embossed on
+the underside, a boss — the piece rests on it and its big
+flat underside prints a fraction of a millimetre in mid-air: the first layer goes
+down onto nothing, strings, and the print fails or leaves a ruined bottom. So every
+printed sub-part of a part under `fdm-pla` or `fdm-petg` is checked in its print
+(export) pose: `bedContactPct` is the share of its near-bed FLAT underside (faces
+within 2° of level, within 1 mm of its lowest point — the band the overhang check
+leaves alone) that actually touches the bed; a face hovers only when it is level (within
+0.1°, as a plane you made horizontal is) and every one of its corners is clear of the
+bed, so a cylinder, sphere or dome resting on the bed is never read as hovering, and it must be at least
+the profile's `bedContact` (50%). A plate flat on the bed reads 100; a lever resting
+on a knuckle 0.25 mm lower reads about 1. Slanted faces — the curl of a bottom fillet
+or chamfer, the sides of a cylinder — never count, and hovering area under 1 mm² is
+read as noise. A flat bottom tilted off level is not caught (it is not level, the same
+signature as a curved surface's lowest facets). The failure is located on the largest hovering face and
+its note says how far up it sits and how much area hovers versus touches. The fix is
+almost always to trim the piece flat at the bed plane — cut away everything below
+z = 0 in its print pose — or to raise or shorten the lower feature so the flat face
+is the lowest; size a print-in-place knuckle so its cylinder is tangent to the bed
+(diameter = 2 × its centre height) and give it a support block down to z = 0. Unlike
+overhang, no orientation key is needed: an overhang is a design choice a part still
+being shaped may not have made, but a hovering underside is a defect in whatever
+orientation the piece exports. Resin prints on supports, so `resin` never checks it
+unless you ask: your own `bedContactPct` expectation arms it under any profile, and
+`orientation: "print"` arms it on a part with no profile at all (both against 50%). A
+named profile otherwise decides alone. A recess meant to clear the
+bed — a shallow pocket inside a foot ring — hovers by design and is reported; such a
+pocket is a long bridge laid in the first layers and rarely prints well, so the
+default stands, and a part that means it declares a lower `bedContactPct` (or
+`{ base: "fdm-pla", bedContact: null }` to switch it off). `exportable: false`
+sub-parts are not judged.
+
 **What the profile tells you.** Three more fields carry the numbers a mating
 feature needs. Nothing checks them; they are the one place the value is spelled,
 so `derive()` copies it with a comment naming the fit (`// slip fit: fdm-pla 0.25`).
@@ -4359,7 +4399,7 @@ an inline `{ base: "fdm-pla", fits: { … } }` replaces the whole table.
 **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`, `wall` (a range — see below), `bounds` (the axis-aligned corner
+`overhangArea`, `bedContactPct`, `wall` (a range — see below), `bounds` (the axis-aligned corner
 positions, written in the same `{ min, max }` shape `measure` reports them — 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`,
@@ -4405,7 +4445,8 @@ 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 —
-and so is `overhangArea` (see above). `holes`/`watertight` are Manifold-only, so those
+and so is `overhangArea` (see above). `bedContactPct` is a **gate** even though the
+profile arms it (see above). `holes`/`watertight` are Manifold-only, so those
 assertions **skip** on OCCT parts rather than fail.
 
 **A wall that must stay one thickness: `wall`.** `minWall` answers "is anything too

package/docs/ERROR-PATTERNS.md

@@ -204,6 +204,12 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** The piece is placed by eye rather than against a mating datum — a lid a hair above its box, a bracket beside the wall it should bolt to, a pin whose bore it was never moved into — or it is held only by a reference ghost (`exportable: false`), which is never printed. On OCCT a sub-part fully inside another reads as not touching, since overlap detection is Manifold-only.
 - **Fix:** Seat the part on a mating face by deriving its position from the face it sits on in `derive()`, or add the fastener, boss or tab that holds it, then keep `verify.expect._view.held` so the next edit re-checks it. If the piece is meant to run free in a clearance bore (a hinge pin, a print-in-place link), the clearance is correct and `held` is the wrong check for that assembly — remove `held` and declare the pair under `clearance`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Self-verification (the `verify` block)".
 
+## piece-hovers-above-bed
+
+- **Symptom:** A `✗ … bedContactPct` failure from `verify` (e.g. `1.28 not >= 50`) with the note `… mm² of flat underside sits 0.25 mm above the bed`; or, in a slicer, a piece whose flat bottom is not on the bed and whose first layers string or spaghetti.
+- **Cause:** Something smaller than the piece's flat underside sits lower than it in the print pose — a horizontal knuckle or pin whose cylinder dips below the plate, a boss, or lettering embossed on the bottom — so exporters and slicers rest the piece on that feature and the flat face prints in mid-air.
+- **Fix:** Trim the piece flat at the bed plane (cut everything below z = 0 in its print pose), or raise or shorten the lower feature so the flat face is the lowest; size a print-in-place knuckle so its cylinder is tangent to the bed and give it a support block down to z = 0. A recess meant to clear the bed declares a lower `bedContactPct`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Self-verification (the `verify` block)".
+
 ## expect-static-across-presets
 
 - **Symptom:** A `verify` exact gate (`holes`, `volume`, …) fails on SOME presets only — e.g. `✗ planter holes 1  (0 != 1)` on two cases while defaults pass — and the preview looks right for every preset.
@@ -871,6 +877,12 @@ between the Manifold preview and the OCCT STEP export.
 - **Cause:** Peak WASM memory during the preview build exceeded what the phone allows a page (roughly 1–1.5 GB on iOS; a desktop tolerates several GB). The usual shape is hundreds of repeated small features unioned into one body: before partforge 0.116 every sphere was 6,728 triangles regardless of radius (the flat 116-segment preview count, squared), so a body with ~250 rivet spheres carried 1.7 M triangles of rivets into its booleans — measured 10 s and a 2.7 GB peak on a desktop for a 400k-triangle sub-part, against 4 s and 500 MB with the rivets as 12-triangle boxes. A boolean chain whose intermediates dwarf the result (a full-body skin intersected per groove) is the other shape.
 - **Fix:** Update partforge (0.116 sizes spheres by chord tolerance: that body builds in ~550 MB and 120k triangles unchanged; 0.117 extends the rule to lathe profile arcs — `torus`, `roundedCylinder`, revolved rounded profiles — and `roundedBox` corners, the other two shapes that spend the count squared). Then keep the preview build's peak down the same ways the export needs: build repeated detail as one union of instances rather than a chain of per-feature booleans, cut grooves from a thin local skin rather than the whole envelope, and drop feature counts the print cannot show ([Preview vs print quality](AUTHORING-PARTS.md#conventions--gotchas)). `partforge measure` reports triangle counts per sub-part; a single preview sub-part past ~200k triangles, or a whole view past ~400k, is the range where phones start to fail.
 
+## kernel-internal-error
+
+- **Symptom:** `the geometry kernel raised an internal error it could not describe` — from a build or a STEP import, naming the operation when known (`during STEP import of "frame" (17.1 MB)`) and, when the kernel's own heap could say, the C++ exception type (`C++ exception StdFail_NotDone`, `Standard_ConstructionError`, `std::bad_alloc`, …) and the heap size. Before partforge 0.163.1 the same failure was a bare number (`{"ok":false,"error":"154591824"}`), different on every attempt.
+- **Cause:** The OCCT kernel is a WASM build compiled without C++ exception catching, so an exception nothing inside it catches — the STEP reader's transfer refusing an entity, a construction with a zero-length direction, an allocation the heap could not grow for — reaches JavaScript as the exception's ADDRESS. The number is not a code and means nothing across runs. partforge now names the operation and reads the exception's type off the heap, but it cannot read OCCT's own message for it.
+- **Fix:** Act on the type. `std::bad_alloc` or `Standard_OutOfMemory` (the message then says "probably too large for the in-browser kernel") is memory: a STEP import needs roughly six times its file size of kernel heap (measured on OCCT-written files: 17 MB → 100 MiB, 42 MB → 248 MiB), so a file that exhausts the 2 GB wasm32 ceiling is hundreds of megabytes, or the browser refused to grow the heap — simplify the imported model or split it. Any other type on an import is the file itself: re-export it from the CAD tool as AP214/AP242 solids (no assembly-only or surface-only exports) and try the smaller file; the same type from a build is that operation refusing its input (a `Standard_ConstructionError` is usually a zero-length direction or a degenerate profile). Retrying the identical build fails the same way — it is not transient.
+
 # Hardware library
 
 Reserved for `hardware-*` patterns (issue #30). No entries yet.

package/docs/KERNEL-CONTRACT.md

@@ -1023,8 +1023,9 @@ 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` and `overhangArea`
-*warnings*, which report but never fail) — a generator gets machine-checkable
+`bbox`, `volume`, `holes`, `watertight`, overlaps and, under an FDM profile,
+`bedContactPct` — 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.162.0",
+  "version": "0.163.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/geometry/occt-backend.js

@@ -27,6 +27,7 @@ import { makeProfileWarner } from "./profile-warnings.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
+import { emscriptenThrowEvidence, labelImportFailure } from "../kernel-error.js";
 import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
 import { resolveSweepStations } from "./sweep.js";
 import { normalizeProfile } from "./profile.js";
@@ -199,6 +200,7 @@ export function createOcctKernel(replicad) {
   // registers pre-build via `_registerImport` (kernel-lifetime, untracked by the
   // solid cache: imports are the framework's own memo, keyed by name+digest).
   const imports = new Map();
+  const throwEvidence = (value) => emscriptenThrowEvidence(replicad.getOC?.(), value);
   // name -> { digest, width, height, data } — depth-map grids the framework
   // registers pre-build via `_registerImage` (ensureImages). Kernel-lifetime like
   // `imports` above, and plain data rather than OCCT objects, so there is nothing
@@ -815,11 +817,22 @@ export function createOcctKernel(replicad) {
       const prev = imports.get(name);
       if (!prev?.error && prev?.digest === digest) return; // error entries are always upgradable
       if (error) { imports.set(name, { error, digest }); return; }
-      imports.set(name, { shape: await importSTEP(new Blob([step])), digest });
+      // A STEP the reader refuses, or an OCCT exception out of its transfer,
+      // leaves here labelled with the import's name and size. The latter
+      // reaches JavaScript as a bare number from this exception-less build
+      // (kernel-error.js), and the heap is read for its C++ type BEFORE
+      // anything else runs on the kernel.
+      let shape;
+      try { shape = await importSTEP(new Blob([step])); }
+      catch (e) { throw labelImportFailure({ name, bytes: step?.byteLength, error: e, evidence: throwEvidence(e) }); }
+      imports.set(name, { shape, digest });
     },
     // Registration memo: undefined for an error entry, so a later registration with
     // the same digest can upgrade it rather than being treated as a no-op repeat.
     _importDigest: (name) => { const e = imports.get(name); return e?.error ? undefined : e?.digest; },
+    // What the kernel's heap can say about a value OCCT threw (kernel-error.js):
+    // the job loop asks this when a build throws something that is not an Error.
+    _throwEvidence: throwEvidence,
     // Depth-map grids, registered pre-build by the framework via `_registerImage`
     // (ensureImages). Unlike imports there is no per-format error entry: every
     // backend can consume a normalized grid, so registration never fails.

package/src/framework/jobs.js

@@ -10,6 +10,7 @@ import { fontsFor, resolveFonts, forgetFontSource } from "./fonts.js";
 import { normalizeOpentype, parseFont } from "./geometry/opentype-interop.js";
 import { imageControlAllows, imageSourceAllowed, isNoImageSource } from "./image-source.js";
 import { imagesFor, ensureImages } from "./images.js";
+import { describeKernelThrow } from "./kernel-error.js";
 import { ensureImports, resolveImports } from "./imports.js";
 import { safeName } from "./safe-name.js";
 import { vectorControlAllows, vectorSourceAllowed, isNoVectorSource } from "./vector-source.js";
@@ -651,7 +652,12 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     } else if (opts.jobs && Object.hasOwn(opts.jobs, msg.type)) {
       await opts.jobs[msg.type](kernel, part, msg, post, { isStale: opts.isStale });
     }
-  } catch (err) {
+  } catch (thrown) {
+    // A kernel compiled without exception catching throws a bare NUMBER for an
+    // uncaught C++ exception; describeKernelThrow turns that into a readable
+    // Error (with the C++ type when the kernel's heap can say) and returns a
+    // real Error untouched, `code` included.
+    const err = describeKernelThrow(thrown, { evidence: kernel._throwEvidence?.(thrown) });
     // `subparts` (generate jobs only) tells the reroute policy which sub-parts the
     // failed job covered, so only those latch to OCCT — not the whole part.
     if (err?.code === "NEEDS_IMPORT_MESH") post({ type: "needs-import-mesh", jobId: msg.jobId, subparts: msg.subparts });

package/src/framework/kernel-error.js

@@ -0,0 +1,161 @@
+// What to say when the geometry kernel throws something that is not an Error.
+//
+// replicad-opencascadejs's `replicad_single` build (the OCCT kernel worker.js
+// loads) is compiled WITHOUT C++ exception catching. An exception OCCT throws
+// that nothing inside the WASM catches — a Standard_Failure out of the STEP
+// reader, a std::bad_alloc when the heap cannot grow — leaves the module through
+// Emscripten's `___cxa_throw`, whose last line is `throw ptr`: JavaScript
+// receives the exception's ADDRESS, a bare number such as 154591824, different
+// on every run. Stringified as-is, that number was the whole error message a
+// part author (and partforge-cloud's agent, which read it as the part's fault
+// and retried blindly — cloud feedback #208) got for a failed build.
+//
+// This module is the ONE place such a value becomes a readable Error, used by
+// both the job loop's error post (jobs.js, worker.js) and the STEP import path
+// (occt-backend.js). It never invents a cause: the message says the kernel
+// raised an internal error it could not describe, names the operation when the
+// caller knows it, and adds only what the kernel's own heap can prove —
+// `emscriptenThrowEvidence` reads the thrown exception's C++ type name off the
+// heap through the Itanium ABI layout Emscripten's `ExceptionInfo` uses, and
+// says "too large for the in-browser kernel" only when that type IS an
+// out-of-memory type, or the heap has reached the wasm32 ceiling. Anything the
+// read cannot validate is dropped rather than guessed.
+
+// A thrown value the caller cannot read: a number (the Emscripten case above), or
+// an object with no non-empty string message (a bare WebAssembly.Exception, a
+// plain object). A real Error — anything with a message — is never opaque.
+export function isOpaqueThrow(err) {
+  if (typeof err === "number") return true;
+  if (err == null) return true;
+  if (typeof err === "string") return err.trim() === "";
+  return !(typeof err.message === "string" && err.message.trim() !== "");
+}
+
+// Emscripten's ExceptionInfo (replicad-opencascadejs 0.23): the thrown pointer
+// is the exception OBJECT; a 24-byte header sits before it, with the
+// std::type_info pointer at header + 4. A std::type_info (libc++abi, wasm32)
+// is { vtable*, const char* __type_name }, so the mangled class name is the
+// C string at *(typeInfo + 4). test/kernel-error-occt.test.js holds this
+// layout against the installed glue: a replicad-opencascadejs bump that moves
+// it fails there, and until it is re-pinned the read simply yields no type
+// name (a wrong read almost never parses as a mangled name — see below).
+const EXCEPTION_HEADER_BYTES = 24;
+const TYPE_OFFSET_IN_HEADER = 4;
+const NAME_OFFSET_IN_TYPE_INFO = 4;
+const MAX_MANGLED_NAME = 128;
+
+// getHeapMax() in the replicad_single glue: the wasm32 build's memory ceiling.
+export const WASM32_HEAP_CEILING_BYTES = 2 ** 31;
+// At or past this share of the ceiling, a throw with no readable type is still
+// called out of memory: nothing else grows a heap to the top of its range.
+const HEAP_CEILING_SHARE = 0.9;
+
+// C++ exception types that mean the kernel could not get memory.
+const OUT_OF_MEMORY_TYPES = new Set(["std::bad_alloc", "std::bad_array_new_length", "Standard_OutOfMemory"]);
+
+// Itanium-mangled class name → readable, for the shapes exception types take:
+// `St9bad_alloc` (std::bad_alloc), `16Standard_Failure`, `N3foo3BarE`
+// (foo::Bar). Every length prefix must match its identifier exactly and the
+// string must be consumed whole, which is what makes a misread (a pointer that
+// landed on arbitrary heap bytes) come back null instead of as a "type".
+export function demangleClassName(mangled) {
+  if (typeof mangled !== "string" || !/^[A-Za-z0-9_]{1,128}$/.test(mangled)) return null;
+  let i = 0;
+  const nested = mangled[0] === "N";
+  if (nested) i++;
+  const parts = [];
+  if (mangled.startsWith("St", i)) { parts.push("std"); i += 2; }
+  while (i < mangled.length && /[0-9]/.test(mangled[i])) {
+    let j = i;
+    while (j < mangled.length && /[0-9]/.test(mangled[j])) j++;
+    const len = Number(mangled.slice(i, j));
+    if (len < 1 || j + len > mangled.length) return null;
+    const ident = mangled.slice(j, j + len);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(ident)) return null;
+    parts.push(ident);
+    i = j + len;
+  }
+  if (nested ? mangled.slice(i) !== "E" : i !== mangled.length) return null;
+  if (parts.length === 0 || (parts.length === 1 && parts[0] === "std")) return null;
+  return parts.join("::");
+}
+
+function readCString(u8, ptr, cap) {
+  if (!Number.isInteger(ptr) || ptr <= 0 || ptr >= u8.length) return null;
+  let s = "";
+  for (let i = 0; i < cap && ptr + i < u8.length; i++) {
+    const c = u8[ptr + i];
+    if (c === 0) return s;
+    s += String.fromCharCode(c);
+  }
+  return null; // ran past the cap or the heap without a terminator
+}
+
+// What the kernel's heap can say about a thrown value: `{ heapBytes, typeName? }`.
+// `module` is the Emscripten module object (what `opencascade()` resolved to,
+// `replicad.getOC()`); the HEAP views are re-read from it on every call because
+// the glue replaces them whenever the memory grows. Returns `{}` for a module
+// without heap views, and never throws.
+export function emscriptenThrowEvidence(module, value) {
+  const evidence = {};
+  const u8 = module?.HEAPU8;
+  const u32 = module?.HEAPU32;
+  if (!(u8 instanceof Uint8Array) || !(u32 instanceof Uint32Array)) return evidence;
+  evidence.heapBytes = u8.length;
+  if (!Number.isInteger(value) || value <= EXCEPTION_HEADER_BYTES || value >= u8.length) return evidence;
+  const typeInfo = u32[(value - EXCEPTION_HEADER_BYTES + TYPE_OFFSET_IN_HEADER) >> 2];
+  if (!(typeInfo > 0 && typeInfo + NAME_OFFSET_IN_TYPE_INFO + 4 <= u8.length)) return evidence;
+  const namePtr = u32[(typeInfo + NAME_OFFSET_IN_TYPE_INFO) >> 2];
+  const typeName = demangleClassName(readCString(u8, namePtr, MAX_MANGLED_NAME));
+  if (typeName) evidence.typeName = typeName;
+  return evidence;
+}
+
+export function formatBytes(n) {
+  if (!Number.isFinite(n) || n < 0) return "unknown size";
+  if (n < 1e6) return `${Math.max(1, Math.round(n / 1e3))} KB`;
+  return `${(n / 1e6).toFixed(1)} MB`;
+}
+
+const describeRaw = (err) => {
+  if (typeof err === "number") return `the kernel reported only an exception address, ${err}`;
+  const ctor = err?.constructor?.name;
+  return `the kernel reported only an opaque ${ctor && ctor !== "Object" ? ctor : "value"}`;
+};
+
+// Turn a thrown value into an Error. A real Error (anything with a message) is
+// returned AS IS — same object, nothing rewritten — so a caller can branch on
+// its `code` exactly as before. `operation` names what was running ("STEP
+// import of "frame" (17.1 MB)"); `subject` is what the memory clause blames
+// ("the file" for an import, "the part" otherwise); `evidence` is
+// `emscriptenThrowEvidence`'s answer, or nothing.
+export function describeKernelThrow(err, { operation, subject = "the part", evidence = {} } = {}) {
+  if (!isOpaqueThrow(err)) return err;
+  const { typeName, heapBytes } = evidence ?? {};
+  let message = "the geometry kernel raised an internal error it could not describe";
+  if (operation) message += ` during ${operation}`;
+  const detail = [];
+  if (typeName) detail.push(`C++ exception ${typeName}`);
+  if (Number.isFinite(heapBytes)) detail.push(`kernel heap ${formatBytes(heapBytes)}`);
+  message += detail.length ? ` (${detail.join(", ")})` : ` (${describeRaw(err)})`;
+  const outOfMemory = typeName
+    ? OUT_OF_MEMORY_TYPES.has(typeName)
+    : Number.isFinite(heapBytes) && heapBytes >= WASM32_HEAP_CEILING_BYTES * HEAP_CEILING_SHARE;
+  if (outOfMemory) {
+    message += ` — the kernel ran out of memory, so ${subject} is probably too large for the in-browser kernel; retrying without reducing it will fail the same way`;
+  }
+  const out = new Error(message, { cause: err });
+  if (typeName) out.kernelExceptionType = typeName;
+  return out;
+}
+
+// The STEP import path's wrapper: whatever `importSTEP` threw, labelled with the
+// import's name and size. An opaque throw takes `describeKernelThrow` with the
+// import as its operation; a real Error (replicad's "Failed to load STEP file",
+// its "This shape has not type, it is null" for a file the reader parsed but
+// could not transfer) keeps its text behind the same label, `cause` attached.
+export function labelImportFailure({ name, bytes, error, evidence }) {
+  const operation = `STEP import of "${name}" (${formatBytes(bytes)})`;
+  if (isOpaqueThrow(error)) return describeKernelThrow(error, { operation, subject: "the file", evidence });
+  return new Error(`${operation} failed: ${error.message}`, { cause: error });
+}

package/src/framework/materials/print-frame.js

@@ -34,12 +34,26 @@ const isIdentity = (m) => m.every((v, i) => Math.abs(v - IDENTITY[i]) < 1e-12);
 // probes first: both poses are place(build), so E · D⁻¹ needs only place() to be
 // readable, and a build that queries its solid cannot make it untrusted. A place()
 // that only the full-scope probe reads falls back to printFrameMatrix's posed branch.
-export function displayToPrintMatrix(subPart, { view, p, d }) {
-  if (!placeOf(subPart)) return null;
+export function displayToPrintMatrix(subPart, opts) {
+  return displayToPrintPose(subPart, opts).matrix;
+}
+
+// displayToPrintMatrix with the one thing its null cannot say: whether the poses were
+// READ. `{ matrix, trusted }` — `matrix` as above, `trusted` false when neither probe
+// scope could read them (a place() that queries its solid), in which case `matrix` is
+// null for want of an answer, not because the piece prints as shown. The bed-contact
+// gate reads the difference: it must not judge a display mesh it could not pose.
+export function displayToPrintPose(subPart, { view, p, d }) {
+  if (!placeOf(subPart)) return { matrix: null, trusted: true };
   const disp = probeSubPartPose(subPart, { view, purpose: "display", p, d }, { scope: "place" });
   const exp = probeSubPartPose(subPart, { view, purpose: "export", p, d }, { scope: "place" });
-  const m = disp.trusted && exp.trusted
-    ? poseDelta(exp.pose, disp.pose)
-    : printFrameMatrix(subPart, { view, p, d, frame: "posed" });
-  return isIdentity(m) ? null : m;
+  if (disp.trusted && exp.trusted) {
+    const m = poseDelta(exp.pose, disp.pose);
+    return { matrix: isIdentity(m) ? null : m, trusted: true };
+  }
+  const fd = probeSubPartPose(subPart, { view, purpose: "display", p, d });
+  const fe = probeSubPartPose(subPart, { view, purpose: "export", p, d });
+  if (!fd.trusted || !fe.trusted || fd.baseHash !== fe.baseHash) return { matrix: null, trusted: false };
+  const m = poseDelta(fe.pose, fd.pose);
+  return { matrix: isIdentity(m) ? null : m, trusted: true };
 }

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

@@ -0,0 +1,127 @@
+// src/framework/oracle/bed-contact.js
+// How much of a printed piece's flat underside actually rests on the bed.
+//
+// The failure this exists for: a piece whose big flat bottom sits a fraction of a
+// millimetre ABOVE its lowest point, because something smaller pokes lower — a
+// horizontal knuckle or pin whose cylinder dips under the plate, lettering embossed
+// on the underside, a boss. Every exporter and slicer
+// lays a piece on its lowest point, so that small feature becomes the only thing on
+// the bed and the flat face prints in mid-air: the first layer is laid onto nothing,
+// strings and spaghettis, and what does print has a ruined bottom surface. Seen on a
+// real forge (a print-in-place toggle latch whose lever knuckle sat lower than the
+// lever body): the flat underside hovered 0.1-0.3 mm and the print failed. Every
+// other check passed it — overhang.js deliberately skips the first millimetre above
+// the bed (the near-bed band), so a hovering face is exactly what it cannot see.
+//
+// One pass over the triangles, pure, no BVH — the same cost class as overhang.js and
+// run beside it. Two areas, both of downward-facing FLAT faces (normal within FLAT_TOL
+// of straight down — so the lower curl of a bottom fillet or chamfer, and a cylinder's
+// side, count as neither):
+//   - contact: the footprint, flat faces with every vertex within `bedEps` of the bed. The
+//     slack starts as overhang.js's (0.1% of the mesh height, floored at 10 µm — boolean
+//     noise a few microns low must not lift a whole face off the bed) but is CAPPED at
+//     MAX_BED_EPS: overhang can let it grow with the part because it only excludes the
+//     footprint, whereas here it decides what counts as touching, and a 200 mm tall piece
+//     would otherwise call a face 0.15 mm up "on the bed" — the very gap this exists for;
+//   - hover: LEVEL faces (within LEVEL_TOL, a tenth of a degree) with EVERY vertex
+//     above the footprint slack and the centroid within `bedBand` (1 mm, overhang.js's
+//     near-bed band) of the bed — a face floating clear of the bed, as a plate over a
+//     lower knuckle or emboss is. Above the band a face is a ceiling, which is
+//     overhang.js's to judge. The two extra conditions are what keep a curved surface
+//     resting on the bed (a cylinder on its side, a sphere, a dome) from reading as
+//     hovering, since its lowest facets are near level too. A face that hovers because
+//     of a lower feature is a plane the author made horizontal, level to float
+//     precision; a curved surface's facet is level only where it contains the lowest
+//     point — where it touches the bed — and every facet clear of the bed is tilted by
+//     about one tessellation step or more (3.1° at the preview's 116 segments, 0.75° at
+//     the print tier's 480, geometry/circle-segs.js): a Ø120 cylinder's facets beside
+//     its lowest line are 1.55° off and touch the bed there, and a sphere's second ring
+//     around its pole is clear of the bed but just as tilted. Every vertex, besides,
+//     so a facet that does reach the bed is never hover, however it is tilted.
+// `pct` is the share of that near-bed flat underside which touches: 100 when nothing
+// hovers, near 0 for a plate resting on a knuckle. A hover total under HOVER_FLOOR is
+// noise and reads as 100.
+//
+// Known limit, stated rather than hidden: a recess meant to clear the bed (a foot ring
+// with a shallow pocket inside it) hovers by design, and is reported. A pocket that
+// shallow is a long bridge laid in the first layers and rarely prints well, so the
+// default threshold stands; a part that means it lowers its own `bedContactPct`. And
+// a flat bottom TILTED off level (one edge on the bed, the rest rising) is not caught:
+// it is not level, which is exactly the signature of curvature above, and telling the
+// two apart would need the mesh's connectivity.
+//
+// Works on both mesh forms the oracle sees (Manifold's soup, OCCT's indexed vertices).
+
+// A face counts as flat (contact) when its normal is within FLAT_TOL degrees of straight
+// down, and as level (hover) within LEVEL_TOL. LEVEL_TOL is far above float32 normal
+// noise (~1e-4°) and far below any tessellation step a curved surface is made of (see
+// the hover rule above).
+const FLAT_TOL = 2;
+const FLAT_COS = Math.cos((FLAT_TOL * Math.PI) / 180);
+const LEVEL_TOL = 0.1;
+const LEVEL_COS = Math.cos((LEVEL_TOL * Math.PI) / 180);
+// Hovering area below this, in mm², is noise and never reported.
+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;
+
+/**
+ * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, triangles: number }} mesh
+ * @param {{ bedZ?: number, bedEps?: number, bedBand?: number }} [opts]
+ *   `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 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}
+ *   `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.
+ */
+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;
+    }
+  }
+  const bed = bedZ ?? minZ;
+  const eps = bedEps ?? Math.min(MAX_BED_EPS, Math.max(0.01, 1e-3 * (maxZ - minZ)));
+  const bandTop = bed + bedBand;
+
+  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
+    const len = Math.hypot(nx, ny, nz);
+    if (len < 1e-9) continue;                                                 // degenerate: no normal
+    const triArea = len / 2;
+    if (-nz / len < FLAT_COS) continue;                                       // slanted: a fillet curl, a cylinder's side
+    const lowest = Math.min(az, bz, cz) - bed, highest = Math.max(az, bz, cz) - bed;
+    if (highest <= eps) { contactArea += triArea; continue; }                 // the footprint
+    if (lowest <= eps) continue;                                              // touching at an edge or vertex: neither
+    if (-nz / len < LEVEL_COS) continue;                                      // near level but tilted: a curved surface's facet
+    hoverArea += triArea;
+    if (triArea > largest) {
+      largest = triArea;
+      gap = cenZ - bed;
+      at = [(positions[a] + positions[b] + positions[c]) / 3,
+            (positions[a + 1] + positions[b + 1] + positions[c + 1]) / 3,
+            cenZ];
+    }
+  }
+  if (hoverArea < HOVER_FLOOR) return { pct: 100, contactArea, hoverArea, gap: null, at: null };
+  return { pct: (100 * contactArea) / (contactArea + hoverArea), contactArea, hoverArea, gap, at };
+}

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

@@ -3,8 +3,10 @@
 // [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).
+// 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
@@ -19,12 +21,12 @@
 // on supports, so it carries none.
 export const PROFILES = {
   "fdm-pla": {
-    bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45,
+    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,
+    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,
   },
@@ -85,3 +87,34 @@ export function overhangAngleFor(part, process, { expanded = [] } = {}) {
     Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "overhangArea" in o));
   return asserted ? (angle ?? DEFAULT_OVERHANG_ANGLE) : null;
 }
+
+// The `bedContactPct` floor an author's own expectation or `orientation: "print"` arms
+// the measurement against when the profile names none.
+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:
+//   - 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
+//     rule), and `{ base: "fdm-pla", bedContact: null }` must stay off;
+//   - a `bedContactPct` expectation the author wrote themselves, in any case's `expect`.
+// Throws on an orientation value outside ORIENTATIONS, as overhangAngleFor does.
+export function bedContactFor(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).bedContact : undefined;
+  if (typeof fromProfile === "number" && Number.isFinite(fromProfile)) return fromProfile;
+  if (orientation === "print" && !spec) return DEFAULT_BED_CONTACT;
+  const asserted = expanded.some(({ expect }) =>
+    Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "bedContactPct" in o));
+  return asserted ? DEFAULT_BED_CONTACT : 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 } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor, bedContactFor } from "./dfm-profiles.js";
 import { expandCases } from "./cases.js";
 import { resolveParams } from "../part-model.js";
 import { parseAssertion } from "./assert-dsl.js";
@@ -50,6 +50,12 @@ export function partOverhangAngle(part, { process, expanded } = {}) {
   try { return overhangAngleFor(part, process, { expanded: expanded ?? expandExpectations(part) }); } catch { return null; }
 }
 
+// The bed-contact floor a part is checked against, or null when it is not checked
+// (dfm-profiles.js bedContactFor holds the rule). Total, like partOverhangAngle.
+export function partBedContact(part, { process, expanded } = {}) {
+  try { return bedContactFor(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,7 @@ import { resolveParams, buildPosed } from "../part-model.js";
 import { newReadSink, expandReads } from "../read-recorder.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
 import { composePose, invertRigid, transformPositions } from "../geometry/pose.js";
-import { displayToPrintMatrix } from "../materials/print-frame.js";
+import { displayToPrintPose } from "../materials/print-frame.js";
 import { isSheetPart, sheetMeta, SHEET_CHECK_BUDGET_MS, MARK_DEPTH } from "../sheet/constants.js";
 import { resolveSheet } from "../sheet/resolve.js";
 import { processFor } from "../process/registry.js";
@@ -13,7 +13,8 @@ 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 { overhang } from "./overhang.js";
-import { partGatesMinWall, partHasBed, partOverhangAngle, partWallBands } from "./gates.js";
+import { bedContact } from "./bed-contact.js";
+import { partBedContact, 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]];
@@ -129,20 +130,44 @@ const transformPoint = (m, [x, y, z]) => [
   m[2] * x + m[6] * y + m[10] * z + m[14],
 ];
 
-// Overhang of one printed sub-part in its PRINT pose. measure builds the display pose,
-// and a piece shown assembled (a lid closed over its 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 the bed is
-// that pose's own lowest Z; `at` comes back in display coordinates, where every other
+// 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.
+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;
+  } catch (e) {
+    return { error: String(e?.message || e).slice(0, 200) };
+  } finally { kernel.endSubPart?.(); }
+}
+
+// The underside readings of one printed sub-part in its PRINT pose — overhang
+// (overhang.js) when `maxAngle` is set, bed contact (bed-contact.js) when `bed` is.
+// measure builds the display pose, and a piece shown assembled (a lid closed over its
+// 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.
 // `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 printPoseOverhang(mesh, m, { maxAngle, displayBedZ }) {
-  if (!m) return overhang(mesh, { maxAngle, bedZ: displayBedZ });
-  const positions = Float32Array.from(mesh.positions);
-  transformPositions(positions, m);
-  const out = overhang({ positions, indices: mesh.indices }, { maxAngle });
-  return out?.at ? { ...out, at: transformPoint(invertRigid(m), out.at) } : out;
+function printPoseUnderside(mesh, m, { maxAngle, bed, displayBedZ }) {
+  let posed = null;
+  if (m) {
+    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);
+  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,
+  };
 }
 
 // One sheet row's facts, within `budget.left` ms of 2-D work, which it spends (see
@@ -276,6 +301,12 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // 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);
+  // 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;
+  const underside = overhangAngle != null || bedArmed;
   const subBounds = [];
   // Sheet parts: a view holding one sizes each printed sub-part in its print pose
   // (verify fits the bed per part there), and every sheet row gets its 2-D facts under
@@ -288,7 +319,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // The overhang reading poses each piece for print (printPoseOverhang), which reads the
   // resolved params through place() — recorded into the same sink, since the reading
   // depends on them.
-  const poseParams = overhangAngle != null ? (sheetParams ?? resolveParams(part, params, undefined, reads)) : null;
+  const poseParams = underside ? (sheetParams ?? resolveParams(part, params, undefined, reads)) : null;
   // The print-pose sizes are read by one check, the process bed (verify passes whether
   // its profile has one; alone, measure asks the part's own profile), and each costs a
   // second build of the part — so they are built only for a bed.
@@ -304,9 +335,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // (printPoseOverhang) is read off place() with the resolved params — geometry-free,
     // so it is resolved here, ahead of the memo, which must key on it.
     const printed = part.parts[name]?.exportable !== false && !sheet;
-    const printMatrix = overhangAngle != null && printed && poseParams?.p
-      ? displayToPrintMatrix(part.parts[name], { view, p: poseParams.p, d: poseParams.d })
+    const printPose = underside && printed && poseParams?.p
+      ? displayToPrintPose(part.parts[name], { view, p: poseParams.p, d: poseParams.d })
       : null;
+    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.
+    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
     // which declared band, the overhang angle, and whether the sub-part is
@@ -320,10 +356,10 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // holds a sheet part (the budgeted 2-D pass and print-pose sizes are
     // call-scoped, not per-sub-part cacheable), and a solid with no `_hash`
     // (nothing to key reuse on).
-    const memoKey = opts.memo && !sheetView && !sheet && !part.parts[name]?.reference && solid?._hash
+    const memoKey = opts.memo && !sheetView && !sheet && !part.parts[name]?.reference && solid?._hash && !exportBed
       ? JSON.stringify({
         mw: !!opts.minWall, s: minWallSamples ?? null, band: wallBands[name] ?? null,
-        oh: overhangAngle ?? null, ex: printed,
+        oh: overhangAngle ?? null, bc: bedArmed, ex: printed,
         pm: printMatrix ? Array.from(printMatrix) : null,
       })
       : null;
@@ -342,12 +378,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     const mw = opts.minWall && !sheet
       ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples, band: wallBands[name] ?? null })
       : null;
-    // One pass over the triangles, no index — cheap enough for every lap. The bed
-    // is this sub-part's own lowest Z in its PRINT pose (printPoseOverhang); `printed`
+    // One pass over the triangles each, no index — cheap enough for every lap. The bed
+    // is this sub-part's own lowest Z in its PRINT pose (printPoseUnderside); `printed`
     // (above) says whether it is judged at all.
-    const oh = overhangAngle != null && printed
-      ? printPoseOverhang(mesh, printMatrix, { maxAngle: overhangAngle, displayBedZ: b.min[2] })
-      : null;
+    const { oh, bc: posedBc } = underside && printed
+      ? printPoseUnderside(mesh, printMatrix, { maxAngle: overhangAngle, bed: bedArmed && !exportBed, displayBedZ: b.min[2] })
+      : { oh: null, bc: null };
+    const exportBc = exportBed ? exportPoseBedContact(kernel, part, name, view, poseParams) : null;
+    const bc = exportBc?.error ? null : (exportBc ?? posedBc);
     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
@@ -400,6 +438,16 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       overhangArea: oh ? oh.area : null,
       overhangAngle: oh?.worstAngle ?? null,
       overhangAt: oh?.at ?? null,
+      // How much of the near-bed flat underside rests on the bed (bed-contact.js), in
+      // percent, null when the part does not check it: a piece whose flat bottom
+      // hovers above a lower knuckle, pin or emboss reads near 0. The two areas (mm²),
+      // and how far up the largest hovering face sits and where (display coordinates).
+      bedContactPct: bc ? bc.pct : null,
+      bedContactArea: bc ? bc.contactArea : null,
+      bedHoverArea: bc ? bc.hoverArea : null,
+      bedHoverGap: bc?.gap ?? null,
+      bedHoverAt: bc?.at ?? null,
+      ...(exportBc?.error ? { bedContactError: exportBc.error } : {}),
       // The process's 2-D facts on a sheet part (sheetRowFacts), null on every other.
       sheet: sheet
         ? sheetRowFacts(kernel, part, name, view, sheetParams, sheetBudget, vol)
@@ -487,6 +535,8 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // or null when the pass did not run — read by verify's seed gate, never a
     // caller's claim.
     measuredOverhang: overhangAngle ?? null,
+    // Whether the bed-contact pass ran — the same kind of stamp, read by the same gate.
+    measuredBedContact: bedArmed,
     // Companion stamp to measuredMinWall, and read the same way: whether the pass
     // ran, said by the pass itself rather than claimed by whoever holds the result.
     measuredGaps,

package/src/framework/oracle/verify.js

@@ -2,7 +2,7 @@ import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
 import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { heldCheck } from "./held.js";
-import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
+import { resolveProfile, overhangAngleFor, bedContactFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { relevanceHash } from "../param-deps.js";
 import { SUBPART_METRICS, VIEW_METRICS, sidesSpecError } from "../verify-metrics.js";
@@ -214,8 +214,8 @@ const SHEET_BUDGET_HINT = "The 2-D sheet checks did not fit their time budget
 // The print checks: measure() casts no rays and runs no overhang pass on a sheet part.
 // Declared on one, each is a skip — declared, never evaluated, so a sheet-only forge
 // that declares only these has no verdict rather than a vacuous pass.
-const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea"]);
-const PRINT_ONLY_HINT = "minWall, wall and overhangArea are print checks, and a sheet part is cut, not printed: nothing measures them here. For a laser part declare sheetBridge (the narrowest web or finger) or sheetGap (the narrowest hole or slot) instead.";
+const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea", "bedContactPct"]);
+const PRINT_ONLY_HINT = "minWall, wall, overhangArea and bedContactPct are print checks, and a sheet part is cut, not printed: nothing measures them here. For a laser part declare sheetBridge (the narrowest web or finger) or sheetGap (the narrowest hole or slot) instead.";
 
 // A sheet reading the geometry engine could not take (SheetFacts.readErrors): a
 // volunteered check warns with the reason; a declared one warns with it too, and is
@@ -271,7 +271,9 @@ function sheetRowChecks(s, declaredExp) {
 // `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, exportableNames, overhang = null }) {
+// `bedContact` is the floor the part is checked against (dfm-profiles.js bedContactFor),
+// or null/undefined: only then does every PRINTED sub-part get `bedContactPct >= floor`.
+export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null }) {
   const checks = [];
   // contacts/clearance/held are pair-derived, not scalar view metrics — peel
   // them off before the registry loop. held.js explains the exportable bound.
@@ -298,6 +300,10 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
   // 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;
+  const bedContactSkipped = bedContact != null && facts.measuredBedContact !== true;
+  // A piece that is never printed (`exportable: false`) is not judged for bed contact;
+  // the floor is applied to the rest. Without the vocabulary, every row is printed.
+  const printedNames = exportableNames ? new Set(exportableNames) : null;
   for (const s of facts.subparts) {
     if (s.sheet) { checks.push(...sheetRowChecks(s, expect?.[s.name] ?? {})); continue; }
     if (anySheet && profile?.bed && s.printBbox) {
@@ -312,6 +318,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
+      ...(bedContact != null && (!printedNames || printedNames.has(s.name)) ? { bedContactPct: `>=${bedContact}` } : {}),
       ...(expect?.[s.name] ?? {}),
     };
     for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s)) {
@@ -325,6 +332,17 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
           hint: "re-run this check without `quick` to measure overhang" });
         continue;
       }
+      if (metric === "bedContactPct" && c.actual == null && s.bedContactError) {
+        checks.push({ ...c, status: "skip", pass: null, unevaluated: true,
+          message: `not measured: its print (export) pose did not build — ${s.bedContactError}`,
+          hint: "bed contact is read in the print pose, and this piece's could not be posed by its place() alone, so its export build was read instead — and that build failed. Fix the export pose; the check then runs." });
+        continue;
+      }
+      if (bedContactSkipped && metric === "bedContactPct" && c.actual == null) {
+        checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
+          hint: "re-run this check without `quick` to measure bed contact" });
+        continue;
+      }
       checks.push(c);
     }
   }
@@ -353,6 +371,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   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 bedContactFloor = bedContactFor(part, process, { expanded });
   // Reuse rule (spec §4): case B may reuse a measurement taken at params A when
   // B agrees with A on every param that measurement READ (recorded by measure()
   // itself). Sound for the same reason the mesh cache is: a deterministic build
@@ -416,11 +435,14 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // 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);
+  // Bed contact's half: a seed that skipped the pass cannot answer an armed gate. The
+  // reverse (a seed that ran it, for a run that does not need it) is a free superset.
+  const bedContactMatches = bedContactFloor == null || seed?.result?.measuredBedContact === true;
   // The print-pose half (views holding a sheet part): a seed measured without the print
   // sizes cannot answer a bed, so it is admitted only when this run needs no bed.
   const needPrintBboxes = profile?.bed != null;
   const printBboxesMatch = !needPrintBboxes || seed?.result?.measuredPrintBboxes !== false;
-  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && printBboxesMatch
+  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && (quick || bedContactMatches) && printBboxesMatch
     && seed.result.view === view) {
     entries.push({ params: full(seed.params), result: seed.result });
   }
@@ -434,7 +456,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     // for every case buys nothing. (A seed measured WITH probes is a superset in
     // the same way a min-wall seed is: the extra key is simply never read here.)
     const result = measureFn(kernel, part, view, params,
-      { minWall: needMinWall, probes: false, overhang: overhangAngle, printBboxes: needPrintBboxes });
+      { minWall: needMinWall, probes: false, overhang: overhangAngle, bedContact: bedContactFloor, printBboxes: needPrintBboxes });
     entries.push({ params: fp, result });
     return result;
   };
@@ -455,7 +477,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   }];
   const caseResults = expanded.map(({ name, params, expect }) => {
     const facts = measureCase(params);
-    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle }) : notMeasured(name) };
+    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle, bedContact: bedContactFloor }) : 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
@@ -490,7 +512,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     declared++;
     if (c.status !== "skip" && !c.unevaluated) evaluated++;
   }
-  const declaresAnything = profile != null || overhangAngle != null
+  const declaresAnything = profile != null || overhangAngle != null || bedContactFloor != 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);

package/src/framework/verify-metrics.js

@@ -108,6 +108,19 @@ export const SUBPART_METRICS = {
     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) },
+  // How much of a printed piece's near-bed flat underside rests on the bed
+  // (oracle/bed-contact.js), in percent. Measured for a part whose FDM profile carries
+  // `bedContact` (or, with no profile, `orientation: "print"`; or this expectation itself);
+  // elsewhere `extract` returns null and check() skips it. A GATE, unlike overhangArea:
+  // a flat bottom hovering above a lower knuckle or emboss is a failed print in any
+  // orientation, and a flat face cannot be mistaken for anything else.
+  bedContactPct: { kind: "gate", extract: (s) => s.bedContactPct,
+    hint: "this piece's flat underside sits just above the bed, because something lower (a knuckle, a pin, a boss, or lettering on the bottom) touches first — exporters and slicers rest the piece on that lowest point, so the flat face prints in mid-air. Trim the piece flat at the bed plane (cut everything below z = 0 in its print pose), or raise or shorten the lower feature so the flat face is the lowest; a recess meant to clear the bed can declare a lower bedContactPct",
+    pattern: "piece-hovers-above-bed",
+    locate: (s) => s.bedHoverAt,
+    note: (s) => (s.bedHoverGap != null
+      ? `${s.bedHoverArea.toFixed(1)} mm² of flat underside sits ${s.bedHoverGap.toFixed(2)} mm above the bed; ${s.bedContactArea.toFixed(1)} mm² touches it`
+      : null) },
   // `s.deviation` (measure.js) exists only for a sub-part declaring `reference:
   // "<import name>"`; on every other sub-part `extract` returns null, which
   // `check()` already reports as status "skip" rather than a fail — the

package/src/framework/worker.js

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

package/types/part.d.ts

@@ -489,6 +489,12 @@ export interface DfmProfile {
    * under a named base. A warning, never a gate.
    */
   overhang?: number | null;
+  /**
+   * The least share (%) of a printed piece's near-bed flat underside that must rest
+   * on the bed (50 on the FDM profiles; absent on resin). A GATE, armed by the
+   * profile alone; `null` switches it off under a named base.
+   */
+  bedContact?: number | null;
   /** Carried for a future gap check; not enforced yet. */
   clearance?: number;
   /**
@@ -560,6 +566,12 @@ export interface SubPartExpectations {
    * `verify.orientation: "print"`; a warning, never a gate.
    */
   overhangArea?: Expectation;
+  /**
+   * Share (0–100) of the sub-part's near-bed flat underside — faces within 2° of
+   * level, within 1 mm of its lowest point in the print pose — that touches the bed.
+   * Under an FDM profile every printed sub-part gets `>=50` by default; a gate.
+   */
+  bedContactPct?: 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. */

package/types/testing.d.ts

@@ -419,6 +419,25 @@ export interface SubPartFacts {
   overhangAngle: number | null;
   /** Centroid of the largest offending face; `null` when none. */
   overhangAt: number[] | null;
+  /**
+   * Share (0–100) of the near-bed flat underside, in the print pose, that rests on
+   * the bed (oracle/bed-contact.js); `null` when the part is not checked for bed
+   * contact (no FDM profile) or the sub-part is `exportable: false`.
+   */
+  bedContactPct: number | null;
+  /** Flat underside on the bed, mm²; `null` when not checked. */
+  bedContactArea: number | null;
+  /** Flat underside hovering within 1 mm above the bed, mm²; `null` when not checked. */
+  bedHoverArea: number | null;
+  /** How far above the bed the largest hovering face sits, mm; `null` when nothing hovers. */
+  bedHoverGap: number | null;
+  /** Centroid of the largest hovering face; `null` when nothing hovers. */
+  bedHoverAt: number[] | null;
+  /**
+   * Present only when bed contact had to be read off the piece's export build (its
+   * print pose could not be read from place() alone) and that build failed.
+   */
+  bedContactError?: string;
   /** A sheet sub-part's 2-D facts, or `null` on every other sub-part. */
   sheet: SheetFacts | null;
   /**
@@ -500,6 +519,8 @@ export interface MeasureReport {
   measuredMinWall: boolean;
   /** The overhang angle every sub-part's `overhangArea` was measured against, `null` when the pass did not run. */
   measuredOverhang: number | null;
+  /** Whether the bed-contact pass ran (the part is checked for it). */
+  measuredBedContact: boolean;
   /**
    * Present only in a view holding a sheet part: whether the printed sub-parts' print
    * (export) poses were built for `printBbox`.
@@ -536,6 +557,11 @@ export function measure(
      * `verify` block the way verify does.
      */
     overhang?: number | null;
+    /**
+     * The bed-contact floor (percent) the run is checked against, or `null` for "not
+     * checked". Omitted, measure derives it from the part's own `verify` block.
+     */
+    bedContact?: number | null;
     gapThreshold?: number;
     /**
      * Milliseconds the 2-D sheet checks may spend across every sheet sub-part in