partforge 0.119.0 → 0.121.0

package/bin/cli.js

@@ -13,8 +13,6 @@ import { fontsFor } from "../src/framework/fonts.js";
 import { imagesFor } from "../src/framework/images.js";
 import { isNoImageSource } from "../src/framework/image-source.js";
 import { viewAnimations, evaluate, cueAt } from "../src/framework/animation.js";
-import { measure } from "../src/framework/oracle/measure.js";
-import { verify } from "../src/framework/oracle/verify.js";
 import { renderViews } from "../src/testing/render.js";
 import {
   createPickServer, requestPicks, formatPickResult,
@@ -114,7 +112,20 @@ const readSources = (partPath) => {
 // `ingest` itself never touches these three. Deferring the import to the
 // commands that actually need them keeps every other verb's behavior
 // unchanged and keeps paper-core.js's first load in `ingest`'s hands.
+//
+// oracle/measure.js and oracle/verify.js join that list for the same reason,
+// since measure.js now statically imports oracle/shape-probe.js, which reaches
+// geometry/contour-ops.js -> geometry/paper-bridge.js -> paper-core just like
+// vectors.js does (verify.js reaches the same path through its own static
+// import of measure.js). A top-level `import { measure } ...`/`import { verify }
+// ...` here would load paper-core before `ingest`'s installNodeDom() runs on
+// every invocation, not only `measure`'s — deferring both to the one verb that
+// calls them keeps `ingest` first in line for paper-core's environment probe.
 const importVectors = () => import("../src/framework/vectors.js");
+const importOracle = () => Promise.all([
+  import("../src/framework/oracle/measure.js"),
+  import("../src/framework/oracle/verify.js"),
+]);
 
 // Pass the part's declared fonts through, mirroring the worker path (jobs.js) —
 // otherwise a part using a named font builds in the browser but dies headlessly
@@ -210,6 +221,7 @@ const commands = {
         }
       }
       const kernel = await bootKernel(part);
+      const [{ measure }, { verify }] = await importOracle();
       const report = measure(kernel, part, view);
       if (!flags.json) printMeasure(report);
       // Write --out right after measure succeeds, then re-write once verify has

package/docs/AUTHORING-PARTS.md

@@ -89,7 +89,7 @@ export default {
     },
   },
   views: { <name>: { label, default?, animations? } },  // view tabs; a view may own animations (below)
-  probes?,                                 // { name: (k, p, d) => Solid | plain JSON } — measurements reported by
+  probes?,                                 // { name: (k, p, d) => Solid | Shape2D | plain JSON } — measurements reported by
                                            // measure/inspect, never rendered or exported (see "Probes" below)
 };
 ```
@@ -2419,6 +2419,45 @@ declare a probe that reads the value, run `measure`, and bake the reported
 number into `defaults` — the probe then keeps watching it on every regen, so a
 swapped import shows up as a probe delta instead of silently stale defaults.
 
+**Reading a 2-D shape's arcs and corners.** Return the `Shape2D` itself and the
+report carries a summary instead of the object: a flat `rings` list — one entry
+per ring, each naming where it came from (`region`, `ring: "outer" | "hole"`,
+plus `hole` on a hole ring) — every arc as `{ center, r, from, to, sweepDeg }`
+(exact for a `{to, via}` arc; a cubic is fitted through its start, midpoint and
+end and tagged `fit: "cubic"`), every corner as `{ position, point,
+interiorAngleDeg, convex }`, plus `area`, `bbox`, and a straight-segment count
+per ring. `position` is a running count across every ring in that same order —
+region by region, outer then holes — which is exactly the positional index
+`fillet({corners: {indices}})` and `shape.corners()` select on, so a corner read
+here can be fed straight back into a fillet call.
+
+Fillet itself never emits a cubic — paper.js has no arc primitive, so an
+exactly-constructed `{to, via}` arc only becomes a cubic once the shape has been
+through a **boolean** (union/cut/intersect), a non-uniform transform, or
+`simplify`. So after any of those, every arc in the summary is `fit: "cubic"`,
+including ones a fillet placed exactly. For an unclipped arc that cubic fit is
+still exact to the reporting grid; when a boolean clips an arc **mid-sweep**,
+the fit's centre and radius drift, and the drift grows as the kept fragment
+shortens. So when you need an exact centre, read it off the **unclipped**
+shape and use a clip only to find which arc to look at — don't trust the centre
+reported on the clipped fragment itself:
+
+```js
+probes: {
+  fullBend: (k, p, d) => trayPocket(k, p, d),
+  // Clip only to locate the arc; read its numbers off fullBend above, not here.
+  bendNear: (k, p, d) => trayPocket(k, p, d).intersect(k.shape2d([[18, -6], [28, -6], [28, 4], [18, 4]])),
+}
+// → probes.fullBend.rings[0].arcs: [{ center: [23.75, -3], r: 4, … }, …]
+```
+
+This is the instrument for any question a render cannot settle to a fraction of
+a millimetre: whether two arcs share a centre (a bend's inner and outer radii),
+what radius a `fillet` actually took after clamping, whether a corner is still
+a corner. The summary lists at most 64 arcs and 64 corners **in total**, across
+every ring — not 64 each per ring — and says `truncated` when it had to cut, so
+keep the probe to the region in question.
+
 **Cost.** Probes run on every `measure`/`inspect` (including quick checks — the
 agent loop is exactly who reads them), so keep them proportionate: a handful of
 thin-slab booleans is cheap; a dense sweep of whole-part XORs is not. `verify`'s
@@ -3208,11 +3247,18 @@ 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 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
+fell inside it. `null` unless the sub-part declares `wall` *and* min wall was
+measured for this run — the same "declared but not measured" gap `minWall`
+itself has.
 **The budget depends on whether the reading is checked against anything**: a part
 that declares a min-wall gate — a `verify.process` profile, or an `expect`
-mentioning `minWall` — gets 50,000, because a gate's verdict rides on it; a part
-that declares neither gets 5,000, because there the number is a diagnostic for a
-reader rather than an assertion. Declaring the gate is what buys the resolution.
+mentioning `minWall` or `wall` — gets 50,000, because a gate's verdict rides on
+it; a part that declares neither gets 5,000, because there the number is a
+diagnostic for a reader rather than an assertion. Declaring the gate is what
+buys the resolution.
 `sampled` is how many triangles the walk *selected*, not how many rays were
 cast: a degenerate (zero-area) triangle has no normal to cast along and is
 skipped. A sampled reading is an **upper bound**: it can miss a thin spot, never
@@ -3333,7 +3379,7 @@ are skipped. Switch it off under an FDM profile with an inline
 `{ base: "fdm-pla", overhang: null }`. **What `expect` gives you:** per-sub-part
 assertions on the facts `measure` already reports — `holes` (through-bores / genus),
 `volume`, `surfaceArea`, `triangleCount`, `bbox`, `watertight`, `minWall`,
-`overhangArea`, `boundsMin` / `boundsMax`
+`overhangArea`, `wall` (a range — see below), `boundsMin` / `boundsMax`
 (the axis-aligned `{min,max}` corner positions — where the geometry sits, vs
 `bbox` which is only its size) and `centerOfMass` (`[x,y,z]`, the volume-weighted
 centroid; `null` for a degenerate/zero-volume sub-part); and `_view` assertions `bbox`,
@@ -3374,6 +3420,27 @@ verify: { expect: {
 and so is `overhangArea` (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
+thin"; `wall` answers "does this wall stay what I declared" — the question a bend, a
+fillet or an offset silently breaks. Declare it as a range in mm, per sub-part:
+
+```js
+verify: { expect: { tray: { wall: "1.8..2.2" } } }
+```
+
+It rides the same inward rays as `minWall`. A ray reading inside `[0.75 × min,
+1.5 × max]` counts as this wall (a 1.2 mm floor under a 2 mm wall is another
+feature and is ignored) — but the window discriminates by **thickness alone, not
+intent**: anything else on that sub-part whose thickness falls in the window is
+counted too, so declare `wall` on a sub-part that is mostly this one wall; a rib
+or boss inside the window reads as a deviation, and a part that needs two
+thicknesses declares two sub-parts. The check reports the member farthest from
+the band — or, when every member is inside it, the one farthest from its
+midpoint — with its location, and warns when it lies outside — `wall 2.62 out of
+1.8..2.2 at (22.8, -2.0, 15.1)` is a bend whose outer arc is not concentric with
+its inner one. Range form only (lint refuses `"<=2"`), a warning like `minWall`
+because it is a sampled reading.
+
 **A verify block that declares nothing verifies nothing.** `verify.ok` is tri-state:
 `true` when every declared check passed, `false` on any gate failure, and `null` when
 no verdict can be given — a quick lap that could not measure a gate, or a part with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.119.0",
+  "version": "0.121.0",
   "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/lint/rules-shape.js

@@ -49,13 +49,13 @@ export const SHAPE_RULES = [
       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.",
+          "Declare probes as `probes: { name: (k, p, d) => Solid | Shape2D | 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).",
+          "Every entry in `probes` must be a `(k, p, d)` function returning a Solid (measured into facts), a Shape2D (summarised into its arcs and corners), or plain JSON (reported verbatim).",
           `probes.${name}`));
     },
   },

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

@@ -245,13 +245,28 @@ export const VERIFY_RULES = [
         // from this scalar-metric loop. `clearance`'s values are still assertions
         // though, so they get their own pass (with a pair-shaped path) below.
         const metrics = target === "_view" ? peelPairKeys(metricsRaw) : metricsRaw;
+        const registry = target === "_view" ? VIEW_METRICS : SUBPART_METRICS;
         for (const [metric, spec] of Object.entries(metrics)) {
-          try { parseAssertion(exprOf(spec)); }
+          let parsed;
+          try { parsed = parseAssertion(exprOf(spec)); }
           catch (e) {
             out.push(err("verify-bad-expr",
               `the expectation for ${target}.${metric} is not a valid assertion: ${e?.message || String(e)}`,
               "Use the assertion DSL: a bare value for equality, a comparison like `>=3`, a range like `2..5`, or a componentwise vector like `<=[60,60,60]` (with `*` to skip an axis).",
               `verify.expect.${target}.${metric}`));
+            continue;
+          }
+          const form = registry[metric]?.form;
+          if (form === "range" && parsed.op !== "range") {
+            out.push(err("verify-bad-expr",
+              `the expectation for ${target}.${metric} must be a range like "1.8..2.2" — the ${metric} metric needs both ends of its band`,
+              `Write ${metric} as \`"<min>..<max>"\` in mm.`,
+              `verify.expect.${target}.${metric}`));
+          } else if (form === "range" && parsed.op === "range" && parsed.min > parsed.max) {
+            out.push(err("verify-bad-expr",
+              `the expectation for ${target}.${metric} must be a range with min <= max, got "${exprOf(spec)}"`,
+              `Write ${metric} as \`"<min>..<max>"\` with min <= max, in mm.`,
+              `verify.expect.${target}.${metric}`));
           }
         }
       }

package/src/framework/oracle/gates.js

@@ -6,13 +6,16 @@
 // would put a coarse reading behind a real gate, which is exactly the trap verify's
 // seeding block guards against.
 //
-// Every function here is TOTAL. A part whose profile name is unknown, or whose
-// `expect` function throws, is reported as GATED — the conservative direction, since
-// that is the full-resolution behaviour every part had before budgets existed. The
-// real error surfaces from verify, which is where a reader can act on it.
+// Every function here is TOTAL, with one stated exception: `partWallBands` throws
+// on a malformed `wall` range (see there). Elsewhere, a part whose profile name is
+// unknown, or whose `expect` function throws, is reported as GATED — the
+// conservative direction, since that is the full-resolution behaviour every part
+// had before budgets existed. The real error surfaces from verify, which is where
+// a reader can act on it.
 import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
 import { expandCases } from "./cases.js";
 import { resolveParams } from "../part-model.js";
+import { parseAssertion } from "./assert-dsl.js";
 
 // `expect` may be a function of a case's resolved params, so the answer is a property
 // of the EXPANDED cases, not of the raw spec — which means answering it costs a call
@@ -52,8 +55,46 @@ export function partGatesMinWall(part, { process, expanded } = {}) {
     const spec = process ?? part?.verify?.process;
     if (spec && resolveProfile(spec)?.minWall != null) return true;
     return (expanded ?? expandExpectations(part)).some(({ expect }) =>
-      Object.values(expect ?? {}).some((o) => o && typeof o === "object" && "minWall" in o));
+      Object.values(expect ?? {}).some((o) => o && typeof o === "object" && ("minWall" in o || "wall" in o)));
   } catch {
     return true; // unresolvable → measure it properly and let verify report the error
   }
 }
+
+// The wall bands a measurement of `params` must track, per sub-part, from the part's
+// own `verify.expect` — resolved for exactly these params (a function expect may
+// change the band per case). Range form only: the membership window needs both ends.
+// Throws on a bad form (a non-range expression, or min > max) so verify reports it
+// where a reader can act — measure's caller (Task 6) lets that throw surface as the
+// measure error it is; this is the one place in this file that is not total.
+// A throw from `spec(p, d)` ITSELF is a different, incidental case — the part's own
+// `expect` function failed for a reason that has nothing to do with wall bands (it
+// read a param that does not exist for this preset, say). That is not this
+// function's throw to report: verify's own `expandExpectations` path calls the same
+// spec and already lets that throw surface from `verify()` — reporting it a second
+// time here, mid-measure, would be a confusing duplicate. Swallow it and answer "no
+// bands", the same as a part that declares none.
+export function partWallBands(part, params = {}) {
+  const spec = part?.verify?.expect;
+  if (!spec) return {};
+  let expect;
+  if (typeof spec === "function") {
+    const { p, d } = resolveParams(part, params);
+    try { expect = spec(p, d) ?? {}; } catch { return {}; }
+  } else {
+    expect = spec;
+  }
+  const out = {};
+  for (const [name, metrics] of Object.entries(expect)) {
+    if (name === "_view" || !metrics || typeof metrics !== "object" || !("wall" in metrics)) continue;
+    const raw = metrics.wall;
+    const expr = raw && typeof raw === "object" && "expr" in raw ? raw.expr : raw;
+    let parsed = null;
+    try { parsed = parseAssertion(expr); } catch { parsed = null; }
+    if (!parsed || parsed.op !== "range" || parsed.min > parsed.max) {
+      throw new Error(`wall expectation for "${name}" must be a range like "1.8..2.2" with min <= max`);
+    }
+    out[name] = { min: parsed.min, max: parsed.max };
+  }
+  return out;
+}

package/src/framework/oracle/measure.js

@@ -6,7 +6,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, partOverhangAngle } from "./gates.js";
+import { partGatesMinWall, 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]];
 const unionBounds = (list) => list.reduce(
@@ -15,20 +16,37 @@ const unionBounds = (list) => list.reduce(
 );
 
 // ── probes ──────────────────────────────────────────────────────────────────
-// Part-declared measurements: `probes: { name: (k, p, d) => Solid | JSON }`,
+// Part-declared measurements: `probes: { name: (k, p, d) => Solid | Shape2D | 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`.
+// queries the facts need) is replaced by a fact object; a Shape2D by its arc/corner
+// summary (shape-probe.js); 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";
 
+// A Shape2D is a plain object carrying a `_shape2d` marker, not a class instance, but
+// walking it as generic JSON would still leak its storage fields (`_regions`, `_hash`)
+// and turn its methods into `{error}` entries. Duck-typed on the two reads the summary
+// needs, so a foreign shape-like value (same two methods, no marker) is still summarised.
+const isShape2D = (v) => v !== null && typeof v === "object"
+  && typeof v.toContours === "function" && typeof v.area === "function";
+
+const shapeProbeFacts = (shape) => {
+  const empty = typeof shape.isEmpty === "function" ? shape.isEmpty() : false;
+  return summarizeContours(shape.toContours(), {
+    isEmpty: empty,
+    area: empty ? 0 : shape.area(),
+    bbox: empty ? null : (typeof shape.boundingBox === "function" ? shape.boundingBox() : null),
+  });
+};
+
 function solidProbeFacts(solid) {
   const mesh = solid.toMesh();
   // Empty = the probe's boolean found nothing (a slab that misses the part).
@@ -60,8 +78,9 @@ function solidProbeFacts(solid) {
 const MAX_PROBE_VALUE_DEPTH = 4;
 function resolveProbeValue(v, depth = 0) {
   if (isSolid(v)) return solidProbeFacts(v);
+  if (isShape2D(v)) return shapeProbeFacts(v);
   if (v === null || typeof v !== "object") {
-    return typeof v === "function" ? { error: "probe returned a function — return a Solid or plain JSON" } : v;
+    return typeof v === "function" ? { error: "probe returned a function — return a Solid, a Shape2D 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));
@@ -124,6 +143,9 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // inward ray per sampled triangle plus the BVH those rays need — and on an
   // ungated part it buys a fact nobody checks, at full price, on every agent edit.
   const minWallSamples = partGatesMinWall(part) ? undefined : DIAGNOSTIC_SAMPLES;
+  // Declared wall bands, per sub-part, for exactly these params (Task 5). Resolved
+  // once per measure; a bad declaration throws here, which is a measure error.
+  const wallBands = opts.minWall ? partWallBands(part, params) : {};
   // Overhang is measured only for a part that opted in (dfm-profiles.js
   // overhangAngleFor) — everything else reads null. verify hands the angle it
   // resolved in (a `process` override changes it); `null` there is an explicit
@@ -138,7 +160,9 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     subBounds.push(b);
     // Resolved lazily and only when asked for: without min-wall, a single-sub-part
     // view (no meshGaps) must still build no index at all.
-    const mw = opts.minWall ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples }) : null;
+    const mw = opts.minWall
+      ? 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, already in hand from bounds(). A sub-part
     // that is never printed (`exportable: false` — a reference ghost, a probe
@@ -189,6 +213,11 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       // `measuredMinWall` false is "never looked".
       minWallSampled: mw?.sampled ?? false,
       minWallSamples: mw ? { sampled: mw.sampledTriangles, total: mw.totalTriangles } : null,
+      // The declared wall band's worst member (min-wall.js): null unless this
+      // sub-part declared `wall` and the pass ran.
+      wall: mw?.band && wallBands[name]
+        ? { value: mw.band.value, location: mw.band.location, band: wallBands[name], members: mw.band.members }
+        : null,
       // Unsupported downward-facing area in mm² (overhang.js), null when the part
       // is not laid out for a bed: bridges and bore ceilings count, by design.
       overhangArea: oh ? oh.area : null,

package/src/framework/oracle/min-wall.js

@@ -65,12 +65,19 @@ function sampleStride(n) {
   return s;
 }
 
+// Membership window for a declared wall band: a ray reading inside
+// [BAND_FLOOR × min, BAND_CEIL × max] belongs to that wall; anything outside is another
+// feature (a thinner floor, a solid boss) and is ignored. Constants, not knobs: a part
+// that needs two bands declares two sub-parts.
+export const BAND_FLOOR = 0.75;
+export const BAND_CEIL = 1.5;
+
 // `bvh` is an already-built index for THIS mesh — one mesh, one index, so there is
 // nothing to key here: measure() resolves it out of the Map it shares with meshGaps
 // (see cachedBVH for why that Map is the caller's) and passes the value. Omit it and
 // one is built. It does not interact with sampling — sampling picks WHICH rays to
 // cast, not how the index is built, so a shared BVH is equally valid sampled or exact.
-export function minWall(mesh, { maxThickness, maxSamples = MAX_SAMPLES, bvh = buildBVH(mesh) } = {}) {
+export function minWall(mesh, { maxThickness, maxSamples = MAX_SAMPLES, bvh = buildBVH(mesh), band = null } = {}) {
   const n = bvh.triangleCount;
   if (n === 0) return null;
   const V = bvh.vertices;
@@ -91,6 +98,19 @@ export function minWall(mesh, { maxThickness, maxSamples = MAX_SAMPLES, bvh = bu
   const sampled = budget < n;
   const stride = sampled ? sampleStride(n) : 1;   // stride 1 = every triangle, in mesh order
 
+  // Band tracking: the member farthest from the band, or — while every member is
+  // inside it — farthest from its midpoint. One comparison per ray, no new rays.
+  // All four locals below are meaningless without a band, so they stay undefined
+  // on the no-band path rather than holding dead zeroes nothing reads.
+  let bandLo, bandHi, bandMid, bandScore;
+  if (band) {
+    bandLo = BAND_FLOOR * band.min;
+    bandHi = BAND_CEIL * band.max;
+    bandMid = (band.min + band.max) / 2;
+    bandScore = (x) => x > band.max ? 1 + (x - band.max) : x < band.min ? 1 + (band.min - x) : Math.abs(x - bandMid) / (band.max - band.min + 1e-9);
+  }
+  let bandWorst = -1, bandValue = null, bandLoc = null, members = 0;
+
   let best = Infinity, loc = null, t = 0;
   const tri = new Float64Array(9);                  // reused per triangle; no per-ray garbage
   for (let s = 0; s < budget; s++, t = t + stride < n ? t + stride : t + stride - n) {
@@ -107,9 +127,17 @@ export function minWall(mesh, { maxThickness, maxSamples = MAX_SAMPLES, bvh = bu
     const origin = [c[0] + dir[0] * 1e-4, c[1] + dir[1] * 1e-4, c[2] + dir[2] * 1e-4];
     const hit = bvh.raycast(origin, dir, { tMax: maxThickness, skipTri: t });
     if (hit && hit.t < best) { best = hit.t; loc = c; }
+    if (band && hit && hit.t >= bandLo && hit.t <= bandHi) {
+      members++;
+      const score = bandScore(hit.t);
+      if (score > bandWorst) { bandWorst = score; bandValue = hit.t; bandLoc = c; }
+    }
   }
   // No hit anywhere still reports HOW it looked (see the header): a `value: null`
   // with the sampling accounting intact, never a bare null that reads downstream as
   // "min wall was never measured".
-  return { value: best === Infinity ? null : best, location: loc, sampled, sampledTriangles: budget, totalTriangles: n };
+  return {
+    value: best === Infinity ? null : best, location: loc, sampled, sampledTriangles: budget, totalTriangles: n,
+    band: band ? { value: bandValue, location: bandLoc, members } : null,
+  };
 }

package/src/framework/oracle/shape-probe.js

@@ -0,0 +1,146 @@
+// The probe-report summary of a Shape2D: its arcs as centre + radius, its corners as
+// point + angle. A reader asking "do these two arcs share a centre?" or "what radius
+// did that fillet actually take?" reads the numbers here instead of a render.
+//
+// Arcs come from the contour IR, never from tessellation: a {to, via} segment is exact
+// (circumcircle of from/via/to). A cubic is FITTED through its start, midpoint and end
+// and tagged `fit: "cubic"` so the reader knows it is an approximation. Fillet itself
+// never emits a cubic — paper.js has no arc primitive, so a shape stores one only once
+// it has been through a BOOLEAN (union/cut/intersect), a non-uniform transform, or
+// simplify. `fit: "cubic"` therefore means "this shape passed through one of those",
+// not "this arc came from a curve-adjacent fillet". For an unclipped arc the cubic fit
+// is exact to the reporting grid; when a boolean clips an arc mid-sweep the fit's error
+// grows as the kept fragment shortens (measured: a r=4 fillet corner clipped at x=18
+// read back centre [16.0063, 16.0184] r 3.9816; a r=100 arc clipped to a 20 mm band read
+// back centre off by 0.59 mm, r 100.586) — compare centres on the UNCLIPPED shape and
+// use a clip only to find which arcs to look at, never to read an exact centre off the
+// clipped fragment itself. See docs/AUTHORING-PARTS.md's probes section.
+//
+// Either recovery (via or cubic) can also produce a near-infinite-radius circle from
+// residual curvature on a segment that reads as straight — most visibly after
+// `simplify`, which can leave a nominally-straight edge with a fraction of a micron
+// of real (not floating-point-noise) bow. A segment whose sagitta (the arc's peak
+// deviation from its own chord, r·(1 − cos(Δ/2))) falls below STRAIGHT_SAGITTA_MM
+// (1e-3 mm, a micron — below anything a print or a reader can act on; an r=100 arc on
+// a 20 mm chord has 0.5 mm of sagitta and an r=1000 one 0.05 mm, so a real bend is
+// nowhere near this floor) is reported as a line instead of a kilometre-radius arc.
+//
+// Corners are profileCorners' reader-facing fields, plus `position`: a running count
+// across every ring in the summary's own order (region by region, outer then holes) —
+// exactly the positional index `fillet({corners: {indices}})` and `shape.corners()`
+// use (both resolve against profileCorners' own flattened order), computed by that same
+// function here rather than re-derived. The `index` field (profileCorners' vertex
+// number within its own contour, not a position into this list) is deliberately
+// dropped — carrying it here is what invites the {indices} mistake.
+//
+// The summary is a FLAT list of rings (each one names its own `region`/`ring`/`hole?`)
+// rather than nested `{outer, holes}` objects, and the two caps below are counted
+// across the WHOLE summary, not per ring: partforge-cloud drops a probe value that
+// grows past its JSON budget or nests past its depth cap. Flat, the summary bottoms
+// out at rings[] → ring → arcs[] → arc → center[] — 4 containers below the summary
+// object itself (5 including it), against the cloud's `DESCRIBE_MAX_DEPTH = 8`, with
+// headroom even wrapped in the paired-probe `{pair: {mine, ref}}` form.
+import { arcCenterAndSweep } from "../geometry/paper-bridge.js";
+import { cubicAt, profileCorners } from "../geometry/contour-ops.js";
+
+export const MAX_ARCS = 64;
+export const MAX_CORNERS = 64;
+// A micron: below anything a print or a reader can act on. An r=100 arc on a 20 mm
+// chord has 0.5 mm of sagitta and an r=1000 one 0.05 mm, so a real bend is nowhere
+// near this floor — only residual curvature left by simplify/boolean noise is.
+export const STRAIGHT_SAGITTA_MM = 1e-3;
+
+const round = (x) => {
+  const v = Math.round(x * 1e4) / 1e4;
+  return v === 0 ? 0 : v; // normalize -0 so the report never prints a bare minus sign
+};
+const pt = ([x, y]) => [round(x), round(y)];
+const toDeg = (rad) => (rad * 180) / Math.PI;
+
+// A recovered circle → an arc record, or null when its sagitta (peak deviation from
+// its own chord) is below STRAIGHT_SAGITTA_MM — a near-straight segment reads as a
+// line rather than a many-kilometre arc.
+function arcFromCircle(c, from, to, fit) {
+  const sagitta = c.r * (1 - Math.cos(Math.abs(c.dA) / 2));
+  if (sagitta < STRAIGHT_SAGITTA_MM) return null;
+  const rec = { center: pt(c.center), r: round(c.r), from: pt(from), to: pt(to), sweepDeg: round(toDeg(c.dA)) };
+  if (fit) rec.fit = fit;
+  return rec;
+}
+
+// One segment → an arc record, or null for a straight (degenerate or near-straight) segment.
+function arcOf(from, seg) {
+  if (seg.c1 && seg.c2) {
+    const mid = cubicAt(from, seg.c1, seg.c2, seg.to, 0.5);
+    const c = arcCenterAndSweep(from, mid, seg.to);
+    return c ? arcFromCircle(c, from, seg.to, "cubic") : null;
+  }
+  if (seg.via) {
+    const c = arcCenterAndSweep(from, seg.via, seg.to);
+    return c ? arcFromCircle(c, from, seg.to, null) : null;
+  }
+  return null;
+}
+
+// One ring's segments → { segments, arcs, lines }. `state.arcsUsed` is the
+// WHOLE-SUMMARY arc budget (MAX_ARCS), shared across every ring's call so the cap is
+// counted across the whole summary rather than restarting per ring; `segments`/`lines`
+// stay exact counts regardless of truncation.
+function ringArcs(contour, state) {
+  const arcs = [];
+  let lines = 0;
+  let from = contour.start;
+  for (const seg of contour.segments) {
+    const a = arcOf(from, seg);
+    if (a) {
+      if (state.arcsUsed < MAX_ARCS) { arcs.push(a); state.arcsUsed++; } else state.truncated = true;
+    } else lines++;
+    from = seg.to;
+  }
+  return { segments: contour.segments.length, arcs, lines };
+}
+
+// The key a ring is filed under, shared between the rings[] list this function builds
+// and the bucketing of profileCorners' flattened output back onto the ring it came from.
+const ringKey = (region, kind, hole) => (kind === "outer" ? `${region}:outer` : `${region}:hole:${hole}`);
+
+/**
+ * Summarise a Shape2D's stored contour regions (the `toContours()` value) for the
+ * probe report. `isEmpty`, `area` and `bbox` are read by the caller from the shape
+ * itself so this stays a pure function of plain data.
+ */
+export function summarizeContours(regions, { isEmpty, area, bbox }) {
+  if (isEmpty || !regions?.length) return { kind: "shape2d", empty: true, area: 0, bbox: null, rings: [], truncated: false };
+  const state = { arcsUsed: 0, truncated: false };
+
+  // profileCorners(regions) walks every ring in the SAME region-by-region,
+  // outer-then-holes order this function does, and its `position` field is already
+  // the flattened index {corners: {indices}} and shape.corners() agree on — computed
+  // once here, over the whole shape, rather than restarting the count per ring.
+  const allCorners = profileCorners(regions);
+  if (allCorners.length > MAX_CORNERS) state.truncated = true;
+  const cornersByRing = new Map();
+  for (let i = 0; i < allCorners.length && i < MAX_CORNERS; i++) {
+    const c = allCorners[i];
+    const key = c.ring === "outer" ? ringKey(c.regionIndex, "outer") : ringKey(c.regionIndex, "hole", c.ring.hole);
+    const bucket = cornersByRing.get(key) ?? [];
+    bucket.push({ position: c.position, point: pt(c.point), interiorAngleDeg: round(c.interiorAngleDeg), convex: c.convex });
+    cornersByRing.set(key, bucket);
+  }
+
+  const rings = [];
+  regions.forEach((rg, region) => {
+    const outerFacts = ringArcs(rg.outer, state);
+    rings.push({ region, ring: "outer", ...outerFacts, corners: cornersByRing.get(ringKey(region, "outer")) ?? [] });
+    (rg.holes ?? []).forEach((h, hole) => {
+      const holeFacts = ringArcs(h, state);
+      rings.push({ region, ring: "hole", hole, ...holeFacts, corners: cornersByRing.get(ringKey(region, "hole", hole)) ?? [] });
+    });
+  });
+
+  return {
+    kind: "shape2d", empty: false, area: round(area),
+    bbox: bbox ? { min: pt(bbox.min), max: pt(bbox.max) } : null,
+    rings, truncated: state.truncated,
+  };
+}

package/src/framework/oracle/verify.js

@@ -134,6 +134,21 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
       if (note) out.note = note;
       return out;
     }
+    // `reg.unavailable` marks a metric whose "no reading" is a real, actionable
+    // finding rather than an inert skip — today only `wall`: a declared band with
+    // zero members means the wall the part is tracking may have drifted away from
+    // the window entirely, which is exactly the case a silent skip would hide (a
+    // 2 mm wall collapsed to 0.9 mm under "1.8..2.2" has no members, and `ok` must
+    // not stay true for that). Data-driven on the registry entry, not a second
+    // `metric === "wall"` literal, so a future metric opts in the same way minWall
+    // did before it had its own branch.
+    if (reg.unavailable) {
+      const out = { ...base, actual, status: "warn", pass: null, message: reg.unavailable,
+        hint: partHint ?? "no ray read as this wall — the declared band may not match the geometry (check minWall for the real thickness), or a sampled run missed it" };
+      const note = reg.note?.(factsObj);
+      if (note) out.note = note;
+      return out;
+    }
     return { ...base, actual, status: "skip", pass: null, message: "unavailable" };
   }
   const { pass, message } = evaluateAssertion(parseAssertion(expr), actual);
@@ -185,9 +200,9 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
     };
     for (const [metric, expr] of Object.entries(merged)) {
       const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
-      if (minWallSkipped && metric === "minWall" && c.actual == null) {
+      if (minWallSkipped && (metric === "minWall" || metric === "wall") && c.actual == null) {
         checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
-          hint: "re-run this check without `quick` to measure min wall" });
+          hint: `re-run this check without \`quick\` to measure ${metric === "wall" ? "the wall band" : "min wall"}` });
         continue;
       }
       if (overhangSkipped && metric === "overhangArea" && c.actual == null) {

package/src/framework/verify-metrics.js

@@ -58,6 +58,20 @@ export const SUBPART_METRICS = {
   // "<import name>"`; on every other sub-part `extract` returns null, which
   // `check()` already reports as status "skip" rather than a fail — the
   // no-reference path needs nothing here.
+  // The declared wall band's worst member (min-wall.js `band`): the member thickness
+  // farthest from the range the part declared, located. Range form only — `form` is
+  // read by the linter's verify-bad-expr rule only. A warning like minWall,
+  // because it is a sampled ray reading: a sample can miss the widest spot, never
+  // invent one. `unavailable` is the skip message when no ray fell in the window.
+  wall: { kind: "warn", form: "range", extract: (s) => s.wall?.value ?? null,
+    hint: "wall thickness drifts from the declared band at the reported location — a fillet radius, an offset or a boolean tool there is not tracking the wall",
+    locate: (s) => s.wall?.location ?? null,
+    unavailable: "no wall in band",
+    note: (s) => {
+      if (!s.wall) return null;
+      const sampled = s.minWallSampled && s.minWallSamples ? ` (sampled ${s.minWallSamples.sampled} of ${s.minWallSamples.total} triangles)` : "";
+      return `${s.wall.members} rays read as this wall${sampled}`;
+    } },
   refXorVolume: { kind: "gate", extract: (s) => s.deviation?.xorVolume ?? null,
     hint: "the rebuild's symmetric difference vs its reference import is too large — compare the ghost overlay, then adjust the governing dimensions toward the measured reference" },
   refVolumeDeltaPct: { kind: "gate", extract: (s) => s.deviation?.volumeDeltaPct ?? null,

package/types/part.d.ts

@@ -457,6 +457,13 @@ export interface SubPartExpectations {
   boundsMin?: Expectation;
   boundsMax?: Expectation;
   minWall?: Expectation;
+  /**
+   * A wall that must stay one thickness, as a range in mm (`"1.8..2.2"`; range
+   * form only). Rides the same inward rays as `minWall` — a ray reading inside
+   * `[0.75 × min, 1.5 × max]` counts as this wall — and warns when the member
+   * farthest from the band lies outside it. A warning, never a gate.
+   */
+  wall?: Expectation;
   /**
    * Unsupported downward-facing surface in mm² (faces steeper than the profile's
    * `overhang` angle, bed at the sub-part's own lowest Z). Measured only under

package/types/testing.d.ts

@@ -283,6 +283,15 @@ export interface SubPartFacts {
   minWallAt: number[] | null;
   minWallSampled: boolean;
   minWallSamples: { sampled: number; total: number } | null;
+  /**
+   * The declared wall band's worst member: the sampled thickness farthest from the
+   * range the part's `verify.expect.<name>.wall` declared (or, when every member is
+   * inside it, farthest from its midpoint), where it was read, the band, and how many
+   * rays fell in the membership window `[0.75 × min, 1.5 × max]`. `null` when the
+   * sub-part declares no band or min wall was not measured; `value` null when no ray
+   * read as this wall.
+   */
+  wall: { value: number | null; location: number[] | null; band: { min: number; max: number }; members: number } | null;
   /**
    * Unsupported downward-facing area in mm² (oracle/overhang.js), `null` when the
    * part is not laid out for a bed (`verify.orientation: "print"` under a
@@ -304,6 +313,57 @@ export interface AggregateFacts {
   triangleCount: number;
 }
 
+/** One arc of a probed `Shape2D` ring: centre and radius from the contour IR. */
+export interface ProbeArc {
+  center: [number, number];
+  r: number;
+  from: [number, number];
+  to: [number, number];
+  /** Signed; positive counter-clockwise. */
+  sweepDeg: number;
+  /** Present when the segment was a cubic and the circle is a fit, not a construction. */
+  fit?: "cubic";
+}
+
+export interface ProbeRing {
+  /** 0-based index into the shape's `regions` — which region this ring belongs to. */
+  region: number;
+  /** Whether this is the region's outer boundary or one of its holes. */
+  ring: "outer" | "hole";
+  /** 0-based hole index within its region; present only when `ring === "hole"`. */
+  hole?: number;
+  /** Total segment count, before any cap. */
+  segments: number;
+  /** At most 64 across the WHOLE summary (all rings combined), not per ring;
+   * `truncated` on the summary says when the list was cut. */
+  arcs: ProbeArc[];
+  /** Straight segments, count only. */
+  lines: number;
+  corners: Array<{
+    /** Running index across every ring in the summary's own order (region by region,
+     * outer then holes) — the positional index `fillet({corners: {indices}})` and
+     * `shape.corners()` select on. */
+    position: number;
+    point: [number, number];
+    interiorAngleDeg: number;
+    convex: boolean;
+  }>;
+}
+
+/** What a `Shape2D` returned from a probe becomes in the report. */
+export interface ShapeProbeFacts {
+  kind: "shape2d";
+  empty: boolean;
+  area: number;
+  bbox: { min: [number, number]; max: [number, number] } | null;
+  /** A flat list of every ring across every region — region by region, outer then
+   * holes — never nested `{outer, holes}` objects. */
+  rings: ProbeRing[];
+  /** At most 64 arcs and 64 corners total, across every ring; true when either
+   * budget was spent and something was cut. */
+  truncated: boolean;
+}
+
 export interface MeasureReport {
   /** `part.meta.title`, falling back to the view name. */
   part: string;
@@ -319,6 +379,12 @@ export interface MeasureReport {
   gaps: Gap[];
   /** The pairs with an unintended-looking gap under the threshold. */
   nearMisses: Gap[];
+  /**
+   * Declared probes' values, present only when the part declares probes and this
+   * run evaluated them. A Solid in a probe's return value becomes a fact object, a
+   * Shape2D becomes a `ShapeProbeFacts`, plain JSON passes through, a throw is `{error}`.
+   */
+  probes?: Record<string, unknown>;
   /** Every sub-part watertight and nothing interpenetrating. Near misses never affect it. */
   ok: boolean;
 }