partforge 0.120.0 → 0.121.0

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.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-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/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