partforge 0.81.0 → 0.83.0

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

@@ -1,5 +1,6 @@
 import { helixTube } from "./helix-tube.js";
 import { loftMesh } from "./loft.js";
+import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
 import { sweepMesh } from "./sweep.js";
 import { roundedBoxRings } from "./rounded-solids.js";
 import { tessellateContour, tessellateProfile } from "./profile.js";
@@ -434,6 +435,34 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         const g0 = m.getMesh();
         const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
         const oids0 = new Set(g0.runOriginalID);
+        // Sector-aware re-stamp: a provenance-sectored loft (the `sector` policy
+        // marker) must keep every run's identity — folding them (either the plain
+        // asOriginal below or the blend path's two-group stamp) would erase the
+        // sector creases and dividing lines the runs exist to draw. Re-stamp every
+        // distinct id 1:1 onto fresh reserved ids: each keeps its policy (blend
+        // runs riding along keep BLEND), all map to the one label string, and the
+        // fresh ids give the same reuse-under-another-label guarantee as
+        // asOriginal(). Unregistered ids (plain boolean tools) stay unregistered —
+        // they shade SMOOTH by default exactly as before.
+        if ([...oids0].some((oid) => !!oidPolicies.get(oid)?.sector)) {
+          const olds = [...oids0];
+          const base2 = Manifold.reserveIDs(olds.length);
+          const mapId = new Map(olds.map((o2, i2) => [o2, base2 + i2]));
+          g0.runOriginalID = Uint32Array.from(g0.runOriginalID, (o2) => mapId.get(o2));
+          const o = T(new Manifold(g0));
+          g0.delete?.();
+          const setIds = [];
+          for (const [oldId, newId] of mapId) {
+            featureLabels.set(newId, name);
+            const pol = oidPolicies.get(oldId);
+            if (pol !== undefined) oidPolicies.set(newId, pol);
+            setIds.push(newId);
+          }
+          return { value: wrap(o, lh), pin: o, dispose: () => {
+            for (const id2 of setIds) { featureLabels.delete(id2); oidPolicies.delete(id2); }
+            o.delete?.();
+          } };
+        }
         if ([...oids0].some(isBlend)) {
           const baseId = Manifold.reserveIDs(2), blendId = baseId + 1;
           // base-group policy: the same triangle-weighted majority vote as the plain
@@ -605,16 +634,29 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // Ring loft: hand-meshed via the shared ring-mesh helpers (helix-tube recipe).
     // Cached atomically; the hash folds every ring's points/z/rotate/scale and the
     // opts (including `shading`, so toggling the hint is a fresh cache node).
-    // asOriginal() stamps a stable originalID; the shading policy (inferred from
-    // the rings, or forced by `shading`) registers under it for the crease pass
-    // and lives exactly as long as the cache pins the solid.
+    // Sectored lofts (curve/resample rings with sharp features or silhouette kinks)
+    // come back already stamped with reserved per-run original IDs, whose policies
+    // loftMesh reports through the out-param — register them all and never
+    // asOriginal() (it would fold the runs into one surface and erase every
+    // provenance crease). Unsectored lofts keep the legacy single-surface path:
+    // asOriginal() + one inferred policy. Either way the registrations live
+    // exactly as long as the cache pins the solid.
     loft: (rings, opts = {}) => {
-      const key = h("loft", rings, opts);
+      const key = h("loft", loftRingsKey(rings), opts);
       return cache.lookup(key, () => {
-        const raw = T(loftMesh(wasm, rings, opts));
+        const rl = resolveLoftRings(rings);        // resolve once: mesh + shading share it
+        const runPol = new Map();
+        const raw = T(loftMesh(wasm, rl, opts, runPol));
+        if (runPol.size > 0) {
+          for (const [oid, pol] of runPol) oidPolicies.set(oid, pol);
+          return { value: wrap(raw, key), pin: raw, dispose: () => {
+            for (const oid of runPol.keys()) oidPolicies.delete(oid);
+            raw.delete?.();
+          } };
+        }
         const m = T(raw.asOriginal());
         const id = m.originalID();
-        oidPolicies.set(id, loftShadingPolicy(rings, opts));
+        oidPolicies.set(id, loftShadingPolicy(rl, opts));
         return { value: wrap(m, key), pin: m, dispose: () => { oidPolicies.delete(id); m.delete?.(); } };
       });
     },

package/src/framework/geometry/mesh-build.js

@@ -51,3 +51,19 @@ export function manifoldFromMesh(wasm, V, Tr) {
   mesh.delete?.(); // input mesh is consumed by ofMesh; free it (caller tracks `out`)
   return out;
 }
+
+// Same import, but with the triangles partitioned into runs carrying pre-reserved
+// original IDs (Manifold.reserveIDs), so downstream shading (creased-normals) can
+// treat each run as its own surface with its own policy — and the partition
+// survives every boolean, exactly like mesh-fillet's blend bands. `runIndex` is in
+// triVert units (3 × triangle count, MeshGL convention), first entry 0, last Tr.length.
+export function manifoldFromMeshRuns(wasm, V, Tr, runIndex, runOriginalID) {
+  const mesh = new wasm.Mesh({
+    numProp: 3, vertProperties: Float32Array.from(V), triVerts: Uint32Array.from(Tr),
+    runIndex: Uint32Array.from(runIndex), runOriginalID: Uint32Array.from(runOriginalID),
+  });
+  mesh.merge();
+  const out = wasm.Manifold.ofMesh(mesh);
+  mesh.delete?.();
+  return out;
+}

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

@@ -23,7 +23,7 @@ import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
-import { resolveRings } from "./loft.js";
+import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
 import { resolveSweepStations } from "./sweep.js";
 import { normalizeProfile } from "./profile.js";
 import { roundedRectContour } from "./rounded-solids.js";
@@ -423,13 +423,18 @@ export function createOcctKernel(replicad) {
     });
   };
 
-  // ring loft: each ring becomes a closed polygon wire placed at its z (native loft closes
-  // the ends for closed wires). closed:true loops are Manifold-only (replicad loft is open).
+  // ring loft: mode "curve" (structurally identical curve rings) lofts the ORIGINAL
+  // baked contours as true arc/spline wires — STEP stays curve-exact; every other mode
+  // lofts the same resolved point rings the Manifold backend stitches, so parity is by
+  // construction (ThruSections' own wire-matching never gets to pick a different seam).
+  // closed:true loops are Manifold-only (replicad loft is open).
   const loftOp = (rings, { ruled = true, closed = false } = {}) => {
     if (closed) throw new Error("loft: closed:true loops are only supported on the Manifold backend");
-    const key = h("loft", rings, ruled);
+    const key = h("loft", loftRingsKey(rings), ruled);
     return cached(key, () => {
-      const wires = resolveRings(rings).map(({ pts2d, z }) => contourDrawing(pts2d).sketchOnPlane("XY", z).wire);
+      const { mode, resolved } = resolveLoftRings(rings);
+      const wires = resolved.map(({ pts2d, contour, z }) =>
+        (mode === "curve" ? contourDrawing(contour) : contourDrawing(pts2d)).sketchOnPlane("XY", z).wire);
       return wrap(loft(wires, { ruled }), [], key);
     });
   };

package/src/framework/geometry/probe.js

@@ -155,21 +155,34 @@ export function createValidatingProbe({ maxOps = MAX_PROBE_OPS } = {}) {
 }
 
 /**
- * Execute every sub-part's build() against a validating probe.
- * Never throws: a build error becomes an entry in `throws`, a runaway sets `runaway`.
+ * Execute every sub-part's build() — and every declared probe (`part.probes`,
+ * same (k, p, d) contract, see oracle/measure.js) — against a validating probe.
+ * Never throws: a build error becomes an entry in `throws` (probe entries land
+ * in `probeThrows`), a runaway sets `runaway`.
  */
 export function runValidatingProbe(part, p, d, { maxOps = MAX_PROBE_OPS } = {}) {
   const probe = createValidatingProbe({ maxOps });
   const throws = [];
+  const probeThrows = [];
   let runaway = false;
-  for (const [name, sp] of Object.entries(part?.parts ?? {})) {
-    if (typeof sp?.build !== "function") continue; // no-buildable-parts already reports this
+  const run = (fn, onThrow) => {
     try {
-      sp.build(probe.kernel, p, d);
+      fn(probe.kernel, p, d);
     } catch (e) {
-      if (e instanceof ProbeRunawayError) { runaway = true; break; }
-      throws.push({ subpart: name, message: e?.message || String(e) });
+      if (e instanceof ProbeRunawayError) { runaway = true; return false; }
+      onThrow(e?.message || String(e));
+    }
+    return true;
+  };
+  for (const [name, sp] of Object.entries(part?.parts ?? {})) {
+    if (typeof sp?.build !== "function") continue; // no-buildable-parts already reports this
+    if (!run(sp.build, (m) => throws.push({ subpart: name, message: m }))) break;
+  }
+  if (!runaway) {
+    for (const [name, fn] of Object.entries(part?.probes ?? {})) {
+      if (typeof fn !== "function") continue; // invalid-probes already reports this
+      if (!run(fn, (m) => probeThrows.push({ probe: name, message: m }))) break;
     }
   }
-  return { calls: probe.calls, issues: probe.issues, used: probe.used, solidUsed: probe.solidUsed, throws, runaway };
+  return { calls: probe.calls, issues: probe.issues, used: probe.used, solidUsed: probe.solidUsed, throws, probeThrows, runaway };
 }

package/src/framework/geometry/profile.js

@@ -53,6 +53,26 @@ export function normalizeProfile(profile) {
   return { outer, holes };
 }
 
+// Solve the circle through (p0, via, p1) and the CCW-normalized sweep from p0 to p1
+// that passes through `via`. Returns null for a collinear triple (callers emit a
+// straight segment). Shared by sampleArc and loft-rings' fixed-count arc sampler.
+export function arcGeometry(p0, via, p1) {
+  const [ax, ay] = p0, [bx, by] = via, [cx0, cy0] = p1;
+  const d = 2 * (ax * (by - cy0) + bx * (cy0 - ay) + cx0 * (ay - by));
+  if (Math.abs(d) < 1e-12) return null;
+  const sa = ax * ax + ay * ay, sb = bx * bx + by * by, sc = cx0 * cx0 + cy0 * cy0;
+  const cx = (sa * (by - cy0) + sb * (cy0 - ay) + sc * (ay - by)) / d;
+  const cy = (sa * (cx0 - bx) + sb * (ax - cx0) + sc * (bx - ax)) / d;
+  const r = Math.hypot(ax - cx, ay - cy);
+  const a0 = Math.atan2(ay - cy, ax - cx);
+  const av = Math.atan2(by - cy, bx - cx);
+  const a1 = Math.atan2(cy0 - cy, cx0 - cx);
+  const twoPi = 2 * Math.PI;
+  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
+  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
+  return { cx, cy, r, a0, dA: vCCW <= dCCW ? dCCW : dCCW - twoPi };
+}
+
 // Sample the circular arc through (p0, via, p1) — the three-point form roundedProfile
 // emits — into a point list p1…pN (EXCLUDING the start p0, which the ring already holds;
 // the last point is exactly p1). The circle is recovered from the circumcircle of the
@@ -63,27 +83,15 @@ export function normalizeProfile(profile) {
 // triple falls back to a single straight segment to p1 — the same "plain line" the OCCT
 // side gets when roundedProfile emits no `via`.
 export function sampleArc(p0, via, p1, segs) {
-  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = p1;
-  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
-  if (Math.abs(d) < 1e-12) return [[cx, cy]];            // collinear → straight line
-  const sa = ax * ax + ay * ay, sb = bx * bx + by * by, sc = cx * cx + cy * cy;
-  const ux = (sa * (by - cy) + sb * (cy - ay) + sc * (ay - by)) / d;
-  const uy = (sa * (cx - bx) + sb * (ax - cx) + sc * (bx - ax)) / d;
-  const rr = Math.hypot(ax - ux, ay - uy);
-  const a0 = Math.atan2(ay - uy, ax - ux);
-  const av = Math.atan2(by - uy, bx - ux);
-  const a1 = Math.atan2(cy - uy, cx - ux);
-  const twoPi = 2 * Math.PI;
-  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
-  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
-  const dA = vCCW <= dCCW ? dCCW : dCCW - twoPi;          // pick the sweep containing `via`
-  const steps = Math.max(2, Math.ceil((segs * Math.abs(dA)) / twoPi));
+  const g = arcGeometry(p0, via, p1);
+  if (!g) return [[p1[0], p1[1]]];                        // collinear → straight line
+  const steps = Math.max(2, Math.ceil((segs * Math.abs(g.dA)) / (2 * Math.PI)));
   const out = [];
   for (let s = 1; s <= steps; s++) {
-    const ang = a0 + dA * (s / steps);
-    out.push([ux + rr * Math.cos(ang), uy + rr * Math.sin(ang)]);
+    const ang = g.a0 + g.dA * (s / steps);
+    out.push([g.cx + g.r * Math.cos(ang), g.cy + g.r * Math.sin(ang)]);
   }
-  out[out.length - 1] = [cx, cy];                        // pin the exact endpoint
+  out[out.length - 1] = [p1[0], p1[1]];                   // pin the exact endpoint
   return out;
 }
 

package/src/framework/geometry/shading-policy.js

@@ -17,6 +17,13 @@ export const FACETED = Object.freeze({ creaseAngle: 10, sameSurfaceLines: false
 // stay invisible while real mitre crossings still draw.
 export const BLEND = Object.freeze({ creaseAngle: 35, sameSurfaceLines: true, boundaryLines: true });
 
+// Loft sector policies: identical crease/line behavior to SMOOTH/FACETED, plus the
+// `sector` marker label() uses to preserve a sectored loft's runs 1:1 when it
+// re-stamps original IDs (a plain asOriginal would fold the sectors into one
+// surface and erase every provenance crease and dividing line).
+export const LOFT_SECTOR_SMOOTH = Object.freeze({ ...SMOOTH, sector: true });
+export const LOFT_SECTOR_FACETED = Object.freeze({ ...FACETED, sector: true });
+
 export const COPLANAR_ANGLE = 5;  // deg — cut seams bending less than this are coplanar: no line
 export const TANGENT_ANGLE = 5;   // deg — B-rep edges whose faces agree within this are tangent: no line
 export const MIN_EDGE = 0.01;     // mm — drop shorter segments (degenerate slivers, pole edges)
@@ -36,18 +43,17 @@ export const SMOOTH_SIDES_MIN = 32;
 
 export const cosDeg = (deg) => Math.cos((deg * Math.PI) / 180);
 
-// Loft shading inference. An explicit `shading` hint wins; `ruled:false` asks
-// OCCT for a smoothly blended surface, so the Manifold preview of the same part
-// must shade smooth too; otherwise low-side-count rings are intentional facets.
-export function loftShadingPolicy(rings, { shading, ruled } = {}) {
+// Loft shading inference over RESOLVED rings (resolveLoftRings' result). An explicit
+// `shading` hint wins; `ruled:false` must preview smooth (it exports smooth via OCCT);
+// any curved ring segment (arc/cubic) is smooth-surface intent; otherwise low
+// resolved side counts are intentional facets.
+export function loftShadingPolicy(resolvedLoft, { shading, ruled } = {}) {
   if (shading === "smooth") return SMOOTH;
   if (shading === "faceted") return FACETED;
   if (shading != null) throw new Error('loft: shading must be "smooth" | "faceted"');
   if (ruled === false) return SMOOTH;
+  if (resolvedLoft?.hasCurve) return SMOOTH;
   let maxSides = 0;
-  if (Array.isArray(rings)) for (const r of rings) {
-    const n = Array.isArray(r?.polygon) ? r.polygon.length : (Number.isFinite(r?.sides) ? r.sides : 0);
-    if (n > maxSides) maxSides = n;
-  }
+  for (const r of resolvedLoft?.resolved ?? []) if (r.pts2d.length > maxSides) maxSides = r.pts2d.length;
   return maxSides >= SMOOTH_SIDES_MIN ? SMOOTH : FACETED;
 }

package/src/framework/geometry/sweep.js

@@ -5,7 +5,7 @@
 // set of 3-D cross-section stations. BOTH backends build from that SAME station list —
 // Manifold hand-meshes it (sweepMesh below, the loft/helix-tube recipe via mesh-build.js),
 // OCCT lofts the same rings ruled (occt-backend.js). So the elbow shape agrees BY
-// CONSTRUCTION, not by tolerance — the same parity mechanism loft's resolveRings uses.
+// CONSTRUCTION, not by tolerance — the same parity mechanism loft's resolveLoftRings uses.
 //
 // Corners: cornerRadius==0 → a SHARP MITER (one station per vertex, in the bisecting
 // plane, stretched by 1/cos(turn/2) so straight walls meet flush). cornerRadius>0 →

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

@@ -50,6 +50,16 @@ export const BUILD_RULES = [
         "Fix the error in build(). This was raised with no kernel attached, so it is a fault in the build's own logic (bad arithmetic, a missing param, a null dereference) rather than a geometry failure.",
         `parts.${subpart}.build`)),
   },
+  {
+    // Same class of fault as build-throws, located at the probe. A throwing
+    // probe degrades at runtime to `{ error }` in the measure report rather
+    // than crashing anything — this rule is what makes it loud anyway.
+    id: "probe-throws",
+    run: ({ probe }) => probe().probeThrows.map(({ probe: name, message }) =>
+      err("probe-throws", `probe "${name}" threw during a geometry-free run: ${message}`,
+        "Fix the error in the probe function. This was raised with no kernel attached, so it is a fault in the probe's own logic (bad arithmetic, a missing param, a null dereference) rather than a geometry failure — at runtime it would report `{ error }` instead of a measurement.",
+        `probes.${name}`)),
+  },
   {
     id: "manifold-backend-uses-occt-op",
     run: ({ part, probe }) => {
@@ -75,9 +85,9 @@ export const BUILD_RULES = [
     id: "nondeterministic-build",
     run: ({ probe, probeAgain }) => {
       const a = probe();
-      if (a.runaway || a.throws.length > 0) return []; // an aborted build can't be compared
+      if (a.runaway || a.throws.length > 0 || a.probeThrows.length > 0) return []; // an aborted run can't be compared
       const b = probeAgain();
-      if (b.runaway || b.throws.length > 0) return [];
+      if (b.runaway || b.throws.length > 0 || b.probeThrows.length > 0) return [];
       if (JSON.stringify(a.calls) === JSON.stringify(b.calls)) return [];
       return [warn("nondeterministic-build",
         "two builds with identical parameters produced different kernel calls",

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

@@ -40,6 +40,25 @@ export const SHAPE_RULES = [
           `parts.${name}.build`));
     },
   },
+  {
+    // `probes` is optional; when present it must be an object of (k, p, d)
+    // functions — same contract as build, but the result lands in the measure
+    // report instead of the scene (see AUTHORING-PARTS.md "Probes").
+    id: "invalid-probes",
+    run: ({ part }) => {
+      if (part?.probes === undefined) return [];
+      if (!isPlainObject(part.probes)) {
+        return [err("invalid-probes", "`probes` must be an object mapping names to functions",
+          "Declare probes as `probes: { name: (k, p, d) => Solid | plain JSON }` — each is measured into the report by `partforge measure` and the inspect job.",
+          "probes")];
+      }
+      return Object.entries(part.probes)
+        .filter(([, fn]) => typeof fn !== "function")
+        .map(([name]) => err("invalid-probes", `probe "${name}" is not a function`,
+          "Every entry in `probes` must be a `(k, p, d)` function returning a Solid (measured into facts) or plain JSON (reported verbatim).",
+          `probes.${name}`));
+    },
+  },
   {
     id: "missing-views",
     run: ({ part }) => (isPlainObject(part?.views) && Object.keys(part.views).length > 0 ? [] : [

package/src/framework/oracle/measure.js

@@ -1,6 +1,7 @@
 import { buildView } from "./build.js";
 import { cachedBVH } from "./bvh.js";
 import { assemblyOverlaps } from "../assembly.js";
+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";
@@ -12,6 +13,80 @@ const unionBounds = (list) => list.reduce(
   { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] },
 );
 
+// ── probes ──────────────────────────────────────────────────────────────────
+// Part-declared measurements: `probes: { name: (k, p, d) => Solid | JSON }`,
+// pure functions with build's exact contract but whose result lands in the
+// REPORT instead of the scene. The instrument a rebuild-against-reference
+// workflow needs — before this, getting a cross-section's numbers out of the
+// pipeline meant authoring throwaway `exportable: false` sub-parts and fishing
+// their facts out of the sub-part list (the "Probes" feedback report).
+// A Solid anywhere in the return value (duck-typed on volume+toMesh, the two
+// queries the facts need) is replaced by a fact object; scalars/arrays/objects
+// pass through; a throw becomes `{ error }` — probes are instrumentation, so
+// they never crash the measurement and never gate `ok`.
+
+const isSolid = (v) => v !== null && typeof v === "object"
+  && typeof v.volume === "function" && typeof v.toMesh === "function";
+
+function solidProbeFacts(solid) {
+  const mesh = solid.toMesh();
+  // Empty = the probe's boolean found nothing (a slab that misses the part).
+  // A first-class answer, not degenerate infinite bounds: "the reference has no
+  // material here" is exactly what a localizing probe is asked.
+  const empty = typeof solid.isEmpty === "function" ? solid.isEmpty() : mesh.triangles === 0;
+  if (empty) {
+    return { empty: true, bbox: null, bounds: null, centerOfMass: null,
+      volume: 0, surfaceArea: 0, triangleCount: 0, watertight: null, holes: null };
+  }
+  const b = bounds(mesh.positions);
+  return {
+    empty: false,
+    bbox: size(b),
+    bounds: { min: b.min, max: b.max },
+    centerOfMass: meshCentroid(mesh.positions, mesh.indices),
+    volume: solid.volume(),
+    surfaceArea: meshArea(mesh.positions, mesh.indices),
+    triangleCount: mesh.triangles,
+    // Mirrors the sub-part fact: answered by isEmpty where the backend has it
+    // (and this branch already means it said false), null where it can't say.
+    watertight: typeof solid.isEmpty === "function" ? true : null,
+    holes: typeof solid.genus === "function" ? solid.genus() : null,
+  };
+}
+
+// Bounded so a self-referential or absurdly deep return value can't hang the
+// report; past the cap the value is summarized rather than walked.
+const MAX_PROBE_VALUE_DEPTH = 4;
+function resolveProbeValue(v, depth = 0) {
+  if (isSolid(v)) return solidProbeFacts(v);
+  if (v === null || typeof v !== "object") {
+    return typeof v === "function" ? { error: "probe returned a function — return a Solid or plain JSON" } : v;
+  }
+  if (depth >= MAX_PROBE_VALUE_DEPTH) return { error: `probe value deeper than ${MAX_PROBE_VALUE_DEPTH} levels` };
+  if (Array.isArray(v)) return v.map((x) => resolveProbeValue(x, depth + 1));
+  return Object.fromEntries(Object.entries(v).map(([key, x]) => [key, resolveProbeValue(x, depth + 1)]));
+}
+
+// Evaluate every declared probe with resolved (p, d). Reads all solid facts
+// eagerly, so the caller may free the kernel's objects afterwards. Never
+// throws: each probe's failure is its own `{ error }` entry.
+function evaluateProbes(kernel, part, params) {
+  const { p, d } = resolveParams(part, params);
+  // Oracle-owned cache round, same reasoning as buildView's: probe geometry must
+  // not evict what the viewer is showing, and the next round evicts this one.
+  kernel.beginSubPart?.("oracle:probes");
+  try {
+    return Object.fromEntries(Object.entries(part.probes).map(([name, fn]) => {
+      try {
+        if (typeof fn !== "function") throw new Error("probe must be a function (k, p, d)");
+        return [name, resolveProbeValue(fn(kernel, p, d))];
+      } catch (e) {
+        return [name, { error: e?.message || String(e) }];
+      }
+    }));
+  } finally { kernel.endSubPart?.(); }
+}
+
 // Headless geometric report for one view of a part (Manifold-only). Reads exact
 // solid facts (volume/genus/emptiness) and mesh facts (bbox/area/triangles), plus
 // the assembly overlap check plus pair gap distances (near misses are reported,
@@ -100,6 +175,15 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     };
   });
 
+  // Declared probes, evaluated regardless of view (they are part-level facts —
+  // per-view probes were exactly the annoyance this replaces) and before
+  // assemblyOverlaps/cleanup below frees the kernel's objects. `opts.probes:
+  // false` skips them: verify's per-case re-measures pass it because no gate
+  // reads probe values, so re-running their booleans per case buys nothing.
+  const probes = opts.probes !== false && part.probes && Object.keys(part.probes).length
+    ? evaluateProbes(kernel, part, params)
+    : undefined;
+
   // Pair surface distances from the meshes already built — no kernel dependency,
   // so this reads on OCCT too. nearMisses = the issue-#29 signal: pairs that
   // *almost* touch; overlapping pairs are excluded by name (a fully-contained
@@ -155,6 +239,9 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     overlaps,
     gaps,
     nearMisses,
+    // Present only when the part declares probes AND this run evaluated them —
+    // a probe error stays inside its own entry and never reaches `ok` below.
+    ...(probes ? { probes } : {}),
     ok: subparts.every((s) => s.watertight !== false) && overlaps.length === 0,
   };
 }

package/src/framework/oracle/verify.js

@@ -266,7 +266,10 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     const key = signature(params);
     if (memo.has(key)) return memo.get(key);
     if (quick) return null;   // a case the seed does not cover — reported, never built
-    memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall }));
+    // `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 }));
     return memo.get(key);
   };
 

package/src/lofted-bottle-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/lofted-bottle.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/parts/import-demo.js

@@ -1,5 +1,7 @@
 // Reference part for docs/AUTHORING-PARTS.md's "Importing geometry" section —
-// the worked example for BOTH import uses in one part:
+// and for its "Probes" section (the `probes` block below measures the import
+// live into the measure report) — the worked example for BOTH import uses in
+// one part:
 //   • reference — `ref` is a translucent ghost of the imported scan (never
 //     exported); `body` is a parametric rebuild of the same block, bound to
 //     the scan via `reference: "scan"` and held to it by the three ref*
@@ -108,6 +110,25 @@ export default {
   // socket never touches `body` (see `mountOffsetX`). "reference" is the
   // ghost-overlay view, browsed by hand or with an explicit view argument.
   views: { assembly: { label: "Assembly" }, reference: { label: "Reference overlay" } },
+  // Probes — measurements that land in the `measure` report instead of the
+  // scene (docs/AUTHORING-PARTS.md "Probes"). Pure (k, p, d) functions like
+  // build; never rendered, never exported, reported for every view.
+  probes: {
+    // Paired 1 mm cross-sections of the rebuild and the scan at the same X
+    // station — the localizing instrument for the deviation gate above: when
+    // refXorVolume creeps up, slide the slab along X to find WHERE the two
+    // solids disagree instead of guessing from one whole-part number.
+    midSlab: (k, p) => {
+      const slab = () => k.box({ min: [9.5, -50, -50], max: [10.5, 50, 50] });
+      return {
+        body: k.box({ min: [0, 0, 0], max: [p.scanW, p.scanD, p.scanH] }).intersect(slab()),
+        scan: k.import("scan").intersect(slab()),
+      };
+    },
+    // A live reading straight off the import — the numbers `defaults` were
+    // measured from. Plain JSON passes through the report verbatim.
+    scanBounds: (k) => k.import("scan").boundingBox(),
+  },
   verify: {
     process: "fdm-pla",
     expect: {

package/src/parts/lofted-bottle.js

@@ -0,0 +1,61 @@
+// Example PartDefinition — the Shape2D-loft reference part. One rounded-square Shape2D
+// is reused up the body with per-ring scales (structurally identical rings: OCCT lofts
+// the original arc wires, so STEP keeps true circles); the shoulder morphs that square
+// into a circle (structurally different rings: both backends loft the identical
+// resampled sections). See docs/AUTHORING-PARTS.md for the conventions.
+import { circleProfile } from "partforge/geometry";
+
+export default {
+  meta: { title: "Lofted Bottle", units: "mm" },
+  parameters: [
+    {
+      id: "body",
+      title: "Bottle",
+      description: "A bottle lofted from a rounded-square base to a round neck (`k.loft` " +
+        "with `Shape2D` rings). **Corner radius** shapes the base; **Belly** bulges the body.",
+      presets: {
+        "Flask": { width: 40, bodyH: 70, cornerR: 8, belly: 1.15, neckD: 22, neckH: 25 },
+        "Square jar": { width: 60, bodyH: 50, cornerR: 6, belly: 1.0, neckD: 40, neckH: 12 },
+        "Slim vial": { width: 24, bodyH: 60, cornerR: 10, belly: 1.05, neckD: 14, neckH: 20 },
+      },
+      advanced: [
+        { key: "width", label: "Base width", unit: "mm", min: 20, max: 80, step: 1, description: "Across-flats width of the rounded-square base." },
+        { key: "bodyH", label: "Body height", unit: "mm", min: 30, max: 120, step: 1, description: "Height of the square-section body." },
+        { key: "cornerR", label: "Corner radius", unit: "mm", min: 1, max: 12, step: 0.5, description: "Base corner rounding — these arcs stay true circles in STEP." },
+        { key: "belly", label: "Belly", min: 0.9, max: 1.4, step: 0.05, description: "Mid-body scale — above 1 bulges, below 1 pinches." },
+        { key: "neckD", label: "Neck diameter", unit: "mm", min: 10, max: 50, step: 1, description: "Round neck diameter at the mouth." },
+        { key: "neckH", label: "Neck height", unit: "mm", min: 8, max: 40, step: 1, description: "Height of the square-to-circle shoulder." },
+      ],
+    },
+  ],
+  defaults: { width: 40, bodyH: 70, cornerR: 8, belly: 1.15, neckD: 22, neckH: 25 },
+  parts: {
+    bottle: {
+      label: "Bottle", views: ["bottle"], export: { name: "lofted-bottle" },
+      build: (k, p) => {
+        const half = p.width / 2;
+        const r = Math.min(p.cornerR, half - 0.5); // fillet must fit the half-width
+        const sq = k.shape2d([[-half, -half], [half, -half], [half, half], [-half, half]]).fillet(r);
+        // Body: one Shape2D reused with per-ring scale → curve mode (STEP-exact arcs).
+        const body = k.loft({ rings: [
+          { polygon: sq, z: 0 },
+          { polygon: sq, z: p.bodyH * 0.45, scale: p.belly },
+          { polygon: sq, z: p.bodyH },
+        ] }).label("Body");
+        // Shoulder: rounded square → circle → resample mode (shared rings, both backends).
+        const shoulder = k.loft({ rings: [
+          { polygon: sq, z: p.bodyH },
+          { polygon: circleProfile(p.neckD / 2), z: p.bodyH + p.neckH },
+        ] }).label("Shoulder");
+        return body.union(shoulder);
+      },
+    },
+  },
+  views: { bottle: { label: "Bottle" } },
+  verify: {
+    expect: {
+      bottle: { holes: 0, bbox: "<=[120,120,165]" },
+      _view: { overlaps: 0 },
+    },
+  },
+};