partforge 0.120.0 → 0.121.1

package/docs/AUTHORING-PARTS.md

@@ -3247,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
@@ -3372,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`,
@@ -3413,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.120.0",
+  "version": "0.121.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/arc-math.js

@@ -0,0 +1,27 @@
+// Pure arc math, paper-free: circumcircle center + signed sweep for the arc through three
+// points. Split out of paper-bridge.js so callers that only need this number crunching (the
+// oracle's shape-probe.js, contour-ops.js's corner/tangent math) don't pull in paper-core —
+// paper-bridge.js still re-exports arcCenterAndSweep so every existing importer of it is
+// unaffected.
+
+// Circumcircle center + signed sweep for the arc through (p0, via, to) — the sweep is the
+// one passing through `via` (sign-free, winding-free), same recovery as profile.js's
+// sampleArc. Returns null for a collinear (degenerate) triple. Shared by arcToCubicSegments
+// (paper-bridge.js) and contour-ops.js's jointTangents (arc tangents are ⊥ radius, oriented by dA's sign).
+export function arcCenterAndSweep(p0, via, to) {
+  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = to;
+  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d) < 1e-12) return null;
+  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 r = 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;
+  return { center: [ux, uy], r, dA };
+}

package/src/framework/geometry/contour-corners.js

@@ -0,0 +1,130 @@
+// Paper-free corner/tangent math for the contour IR, split out of contour-ops.js so the
+// oracle's shape-probe.js (and anything else that only needs a shape's corners/tangents, not
+// its booleans/transforms) doesn't pull in paper-core through contour-ops.js's own
+// paper-bridge.js import. Imports only profile.js, shape2d-regions.js and arc-math.js — never
+// paper-bridge.js or contour-ops.js, which is what keeps this leaf paper-free.
+import { isPathContour, tessellateContour, pointsToContour, closeContourGap } from "./profile.js";
+import { ringArea } from "./shape2d-regions.js";
+import { arcCenterAndSweep } from "./arc-math.js";
+
+export const WINDING_SEGS = 64;   // tessellation LOD for orientation/containment sampling
+
+export const isPointList = (x) => Array.isArray(x) && x.length > 0 && Array.isArray(x[0]);
+// pointsToContour always closes explicitly; a raw {start,segments} contour (hand-authored
+// via pathProfile, or handed back from a Shape2D's own stored regions) might not —
+// closeContourGap is a no-op when it's already closed, so every ring liftProfile hands to
+// contour-ops' corner/transform/query functions is guaranteed explicitly closed.
+export const liftContour = (c) => (isPointList(c) ? pointsToContour(c) : closeContourGap(c));
+
+export function liftProfile(input) {
+  if (input && input._shape2d) return { kind: "regions", regions: input.toContours() };
+  if (isPointList(input)) return { kind: "points", regions: [{ outer: pointsToContour(input), holes: [] }] };
+  if (isPathContour(input)) return { kind: "contour", regions: [{ outer: closeContourGap(input), holes: [] }] };
+  if (Array.isArray(input) && input.every((r) => r && r.outer))
+    return { kind: "regions", regions: input.map((r) => ({ outer: liftContour(r.outer), holes: (r.holes ?? []).map(liftContour) })) };
+  if (input && input.outer)
+    return { kind: "region", regions: [{ outer: liftContour(input.outer), holes: (input.holes ?? []).map(liftContour) }] };
+  throw new Error("contour-ops: input must be [[x,y],…], a {start,segments} contour, {outer,holes}, or a region array");
+}
+
+export const contourIsCCW = (c) => ringArea(tessellateContour(c, WINDING_SEGS)) >= 0;
+
+// ── Corner model ────────────────────────────────────────────────────────────
+// profileCorners() walks a contour's joints and reports each non-smooth one: the interior
+// angle, whether it's convex (material-relative — see below), and the segment kinds either
+// side of it. jointTangents() is the shared per-vertex tangent computation, reused by Task 6.
+
+export const SMOOTH_JOINT_DEG = 1;
+
+// Unit tangent of segment `s` (from `from`) at its start (dir=+1) or end (dir=-1 → arrival direction).
+// Exported for contour-winding.js's _chain: junction ordering at a curved pinch point needs
+// the exact endpoint tangent, not an approximation (via/c1/c2 are NOT control points that
+// happen to sit near the tangent — via in particular is a THROUGH point near mid-sweep, so
+// from->via is systematically biased by about sweep/4). This recovers it exactly for arcs
+// (perpendicular to the radius at the recovered center, oriented by the sweep's sign) and
+// cubics (including the degenerate c1===from case, where the true tangent comes from c2).
+export function segTangent(from, s, atStart) {
+  const norm = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L, y / L]; };
+  if (s.c1) {
+    if (atStart) {
+      const d = [s.c1[0] - from[0], s.c1[1] - from[1]];
+      return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.c2[0] - from[0], s.c2[1] - from[1]]);
+    }
+    const d = [s.to[0] - s.c2[0], s.to[1] - s.c2[1]];
+    return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.to[0] - s.c1[0], s.to[1] - s.c1[1]]);
+  }
+  if (s.via) {
+    // tangent ⊥ radius, oriented along the sweep (recover center like arcToCubicSegments)
+    const c = arcCenterAndSweep(from, s.via, s.to);          // {center:[x,y], dA} or null
+    if (!c) return norm([s.to[0] - from[0], s.to[1] - from[1]]);
+    const p = atStart ? from : s.to;
+    const r = [p[0] - c.center[0], p[1] - c.center[1]];
+    const t = c.dA >= 0 ? [-r[1], r[0]] : [r[1], -r[0]];
+    return norm(t);
+  }
+  return norm([s.to[0] - from[0], s.to[1] - from[1]]);
+}
+
+export function jointTangents(contour) {  // per vertex i: tangent arriving at and leaving vertex i
+  const n = contour.segments.length;
+  const pts = [contour.start, ...contour.segments.map((s) => s.to)];
+  return contour.segments.map((_, i) => {
+    const prevSeg = contour.segments[(i - 1 + n) % n];
+    const prevFrom = pts[(i - 1 + n) % n];
+    return {
+      point: pts[i],
+      inTan: segTangent(prevFrom, prevSeg, false),
+      outTan: segTangent(pts[i], contour.segments[i], true),
+    };
+  });
+}
+
+export const segType = (s) => (s.c1 ? "cubic" : s.via ? "arc" : "line");
+
+export function contourCorners(contour) {
+  const ccw = contourIsCCW(contour);
+  const n = contour.segments.length;
+  const out = [];
+  jointTangents(contour).forEach(({ point, inTan, outTan }, i) => {
+    const cross = inTan[0] * outTan[1] - inTan[1] * outTan[0];
+    const dot = Math.min(1, Math.max(-1, inTan[0] * outTan[0] + inTan[1] * outTan[1]));
+    const turnDeg = (Math.atan2(Math.abs(cross), dot) * 180) / Math.PI;
+    if (turnDeg < SMOOTH_JOINT_DEG) return;
+    const leftTurn = cross > 0;
+    out.push({
+      index: i, point: [point[0], point[1]],
+      interiorAngleDeg: ccw === leftTurn ? 180 - turnDeg : 180 + turnDeg,
+      convex: leftTurn === ccw,
+      segTypes: [segType(contour.segments[(i - 1 + n) % n]), segType(contour.segments[i])],
+    });
+  });
+  return out;
+}
+
+// Two numbers on every corner, and they are NOT interchangeable. `index` is the joint's
+// vertex number within its own contour (what buildCornerOpRing, simplify and the lofts
+// key on); `position` is the corner's place in THIS returned list — the one
+// `{corners: {indices}}` selects by. They diverge as soon as a contour has a smooth
+// joint (a collinear midpoint, a G1 arc-line join), and on region input `index`
+// restarts per ring while `position` runs on through the flattened order.
+const withPositions = (corners) => corners.map((c, position) => ({ ...c, position }));
+
+export function profileCorners(input) {
+  const { kind, regions } = liftProfile(input);
+  if (kind === "points" || kind === "contour") return withPositions(contourCorners(regions[0].outer));
+  const out = [];
+  regions.forEach((rg, regionIndex) => {
+    for (const c of contourCorners(rg.outer)) out.push({ regionIndex, ring: "outer", ...c });
+    rg.holes.forEach((h, hi) => { for (const c of contourCorners(h)) out.push({ regionIndex, ring: { hole: hi }, ...c }); });
+  });
+  return withPositions(out);
+}
+
+export function cubicAt(p0, c1, c2, p1, t) {
+  const u = 1 - t;
+  return [0, 1].map((k) => u * u * u * p0[k] + 3 * u * u * t * c1[k] + 3 * u * t * t * c2[k] + t * t * t * p1[k]);
+}
+export function cubicDeriv(p0, c1, c2, p1, t) {
+  const u = 1 - t;
+  return [0, 1].map((k) => 3 * u * u * (c1[k] - p0[k]) + 6 * u * t * (c2[k] - c1[k]) + 3 * t * t * (p1[k] - c2[k]));
+}

package/src/framework/geometry/contour-ops.js

@@ -1,32 +1,19 @@
-import { isPathContour, tessellateContour, pointsToContour, reverseContour, closeContourGap } from "./profile.js";
+import { reverseContour, closeContourGap } from "./profile.js";
 import { ringArea, pointInRing } from "./shape2d-regions.js";
 import { arcToCubicSegments, arcCenterAndSweep, paperScope, toPaperPath, toContour, toOpenContour } from "./paper-bridge.js";
+import { liftProfile, contourIsCCW, contourCorners, cubicAt, cubicDeriv } from "./contour-corners.js";
 
 // Re-exported so existing importers (test/contour-ops-lift.test.js and others) keep
-// working unchanged — the definitions live in profile.js (the contour-IR home) so
-// paper-bridge.js can use them without importing this module (which already imports
+// working unchanged — the definition lives in profile.js (the contour-IR home) so
+// paper-bridge.js can use it without importing this module (which already imports
 // paper-bridge.js; importing back would cycle).
-export { pointsToContour, reverseContour };
-
-const WINDING_SEGS = 64;   // tessellation LOD for orientation/containment sampling
-
-const isPointList = (x) => Array.isArray(x) && x.length > 0 && Array.isArray(x[0]);
-// pointsToContour always closes explicitly; a raw {start,segments} contour (hand-authored
-// via pathProfile, or handed back from a Shape2D's own stored regions) might not —
-// closeContourGap is a no-op when it's already closed, so every ring liftProfile hands to
-// contour-ops' corner/transform/query functions is guaranteed explicitly closed.
-const liftContour = (c) => (isPointList(c) ? pointsToContour(c) : closeContourGap(c));
-
-export function liftProfile(input) {
-  if (input && input._shape2d) return { kind: "regions", regions: input.toContours() };
-  if (isPointList(input)) return { kind: "points", regions: [{ outer: pointsToContour(input), holes: [] }] };
-  if (isPathContour(input)) return { kind: "contour", regions: [{ outer: closeContourGap(input), holes: [] }] };
-  if (Array.isArray(input) && input.every((r) => r && r.outer))
-    return { kind: "regions", regions: input.map((r) => ({ outer: liftContour(r.outer), holes: (r.holes ?? []).map(liftContour) })) };
-  if (input && input.outer)
-    return { kind: "region", regions: [{ outer: liftContour(input.outer), holes: (input.holes ?? []).map(liftContour) }] };
-  throw new Error("contour-ops: input must be [[x,y],…], a {start,segments} contour, {outer,holes}, or a region array");
-}
+export { reverseContour };
+
+// The paper-free corner/tangent/lift math now lives in contour-corners.js — so the oracle's
+// shape-probe.js can use profileCorners()/cubicAt() without pulling in paper-core through
+// this module's own paper-bridge.js import below — re-exported here so every existing
+// importer of these names from contour-ops.js keeps working unchanged.
+export { liftProfile, contourIsCCW, SMOOTH_JOINT_DEG, segTangent, jointTangents, profileCorners, cubicAt } from "./contour-corners.js";
 
 export function restoreProfile(kind, regions) {
   if (kind === "regions") return regions;
@@ -43,8 +30,6 @@ export function restoreProfile(kind, regions) {
   return outer;   // curves were introduced — upgrade to a contour
 }
 
-export const contourIsCCW = (c) => ringArea(tessellateContour(c, WINDING_SEGS)) >= 0;
-
 export function ensureRegionWinding(region) {
   return {
     outer: contourIsCCW(region.outer) ? region.outer : reverseContour(region.outer),
@@ -116,97 +101,6 @@ export function mirrorProfile(input, axis) {
   return transformProfile(input, [a, b, b, -a, px - a * px - b * py, py - b * px + a * py]);
 }
 
-// ── Corner model ────────────────────────────────────────────────────────────
-// profileCorners() walks a contour's joints and reports each non-smooth one: the interior
-// angle, whether it's convex (material-relative — see below), and the segment kinds either
-// side of it. jointTangents() is the shared per-vertex tangent computation, reused by Task 6.
-
-export const SMOOTH_JOINT_DEG = 1;
-
-// Unit tangent of segment `s` (from `from`) at its start (dir=+1) or end (dir=-1 → arrival direction).
-// Exported for contour-winding.js's _chain: junction ordering at a curved pinch point needs
-// the exact endpoint tangent, not an approximation (via/c1/c2 are NOT control points that
-// happen to sit near the tangent — via in particular is a THROUGH point near mid-sweep, so
-// from->via is systematically biased by about sweep/4). This recovers it exactly for arcs
-// (perpendicular to the radius at the recovered center, oriented by the sweep's sign) and
-// cubics (including the degenerate c1===from case, where the true tangent comes from c2).
-export function segTangent(from, s, atStart) {
-  const norm = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L, y / L]; };
-  if (s.c1) {
-    if (atStart) {
-      const d = [s.c1[0] - from[0], s.c1[1] - from[1]];
-      return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.c2[0] - from[0], s.c2[1] - from[1]]);
-    }
-    const d = [s.to[0] - s.c2[0], s.to[1] - s.c2[1]];
-    return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.to[0] - s.c1[0], s.to[1] - s.c1[1]]);
-  }
-  if (s.via) {
-    // tangent ⊥ radius, oriented along the sweep (recover center like arcToCubicSegments)
-    const c = arcCenterAndSweep(from, s.via, s.to);          // {center:[x,y], dA} or null
-    if (!c) return norm([s.to[0] - from[0], s.to[1] - from[1]]);
-    const p = atStart ? from : s.to;
-    const r = [p[0] - c.center[0], p[1] - c.center[1]];
-    const t = c.dA >= 0 ? [-r[1], r[0]] : [r[1], -r[0]];
-    return norm(t);
-  }
-  return norm([s.to[0] - from[0], s.to[1] - from[1]]);
-}
-
-export function jointTangents(contour) {  // per vertex i: tangent arriving at and leaving vertex i
-  const n = contour.segments.length;
-  const pts = [contour.start, ...contour.segments.map((s) => s.to)];
-  return contour.segments.map((_, i) => {
-    const prevSeg = contour.segments[(i - 1 + n) % n];
-    const prevFrom = pts[(i - 1 + n) % n];
-    return {
-      point: pts[i],
-      inTan: segTangent(prevFrom, prevSeg, false),
-      outTan: segTangent(pts[i], contour.segments[i], true),
-    };
-  });
-}
-
-const segType = (s) => (s.c1 ? "cubic" : s.via ? "arc" : "line");
-
-function contourCorners(contour) {
-  const ccw = contourIsCCW(contour);
-  const n = contour.segments.length;
-  const out = [];
-  jointTangents(contour).forEach(({ point, inTan, outTan }, i) => {
-    const cross = inTan[0] * outTan[1] - inTan[1] * outTan[0];
-    const dot = Math.min(1, Math.max(-1, inTan[0] * outTan[0] + inTan[1] * outTan[1]));
-    const turnDeg = (Math.atan2(Math.abs(cross), dot) * 180) / Math.PI;
-    if (turnDeg < SMOOTH_JOINT_DEG) return;
-    const leftTurn = cross > 0;
-    out.push({
-      index: i, point: [point[0], point[1]],
-      interiorAngleDeg: ccw === leftTurn ? 180 - turnDeg : 180 + turnDeg,
-      convex: leftTurn === ccw,
-      segTypes: [segType(contour.segments[(i - 1 + n) % n]), segType(contour.segments[i])],
-    });
-  });
-  return out;
-}
-
-// Two numbers on every corner, and they are NOT interchangeable. `index` is the joint's
-// vertex number within its own contour (what buildCornerOpRing, simplify and the lofts
-// key on); `position` is the corner's place in THIS returned list — the one
-// `{corners: {indices}}` selects by. They diverge as soon as a contour has a smooth
-// joint (a collinear midpoint, a G1 arc-line join), and on region input `index`
-// restarts per ring while `position` runs on through the flattened order.
-const withPositions = (corners) => corners.map((c, position) => ({ ...c, position }));
-
-export function profileCorners(input) {
-  const { kind, regions } = liftProfile(input);
-  if (kind === "points" || kind === "contour") return withPositions(contourCorners(regions[0].outer));
-  const out = [];
-  regions.forEach((rg, regionIndex) => {
-    for (const c of contourCorners(rg.outer)) out.push({ regionIndex, ring: "outer", ...c });
-    rg.holes.forEach((h, hi) => { for (const c of contourCorners(h)) out.push({ regionIndex, ring: { hole: hi }, ...c }); });
-  });
-  return withPositions(out);
-}
-
 // ── Fillet / chamfer ─────────────────────────────────────────────────────────
 // Resolve opts.corners against a flat corner list (contourCorners()'s order, or
 // profileCorners()'s flattened order for region/regions input — {indices} always
@@ -280,14 +174,6 @@ const normalize2 = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L,
 const rot90 = ([x, y]) => [-y, x];
 const addScaled = (p, v, s) => [p[0] + v[0] * s, p[1] + v[1] * s];
 
-export function cubicAt(p0, c1, c2, p1, t) {
-  const u = 1 - t;
-  return [0, 1].map((k) => u * u * u * p0[k] + 3 * u * u * t * c1[k] + 3 * u * t * t * c2[k] + t * t * t * p1[k]);
-}
-function cubicDeriv(p0, c1, c2, p1, t) {
-  const u = 1 - t;
-  return [0, 1].map((k) => 3 * u * u * (c1[k] - p0[k]) + 6 * u * t * (c2[k] - c1[k]) + 3 * t * t * (p1[k] - c2[k]));
-}
 // Exact de Casteljau split of cubic (p0,c1,c2,p1) at t → two exact cubic pieces.
 export function splitCubic(p0, c1, c2, p1, t) {
   const lerp = (a, b) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];

package/src/framework/geometry/paper-bridge.js

@@ -3,6 +3,7 @@
 // package-global project — another consumer in the same worker may import paper too.
 import paper from "paper/dist/paper-core.js";
 import { tessellateContour, reverseContour, closeContourGap } from "./profile.js";
+import { arcCenterAndSweep } from "./arc-math.js";
 
 const ORIENT_SEGS = 8;   // points/segment for the local orientation sampler below
 
@@ -12,27 +13,9 @@ function paperScope() {
   return _scope;
 }
 
-// Circumcircle center + signed sweep for the arc through (p0, via, to) — the sweep is the
-// one passing through `via` (sign-free, winding-free), same recovery as profile.js's
-// sampleArc. Returns null for a collinear (degenerate) triple. Shared by arcToCubicSegments
-// below and contour-ops.js's jointTangents (arc tangents are ⊥ radius, oriented by dA's sign).
-export function arcCenterAndSweep(p0, via, to) {
-  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = to;
-  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
-  if (Math.abs(d) < 1e-12) return null;
-  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 r = 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;
-  return { center: [ux, uy], r, dA };
-}
+// arcCenterAndSweep now lives in arc-math.js (paper-free), re-exported here so every
+// existing importer of it from this module keeps working unchanged.
+export { arcCenterAndSweep } from "./arc-math.js";
 
 // Circular arc through (p0, via, to) → cubic Bézier segments, ≤90° each, endpoints
 // exact. Each piece uses the standard k = (4/3)·tan(θ/4) control-point offset.

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,7 @@ 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]];
@@ -143,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
@@ -157,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
@@ -208,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

@@ -40,8 +40,8 @@
 // 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";
+import { arcCenterAndSweep } from "../geometry/arc-math.js";
+import { cubicAt, profileCorners } from "../geometry/contour-corners.js";
 
 export const MAX_ARCS = 64;
 export const MAX_CORNERS = 64;

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