partforge 0.161.0 → 0.162.0

package/docs/AUTHORING-PARTS.md

@@ -4375,12 +4375,16 @@ unverified.
 
 **Assertion DSL:** a bare number means equality (`holes: 1`); `">=n"`, `"<=n"`, `">n"`,
 `"<n"`, or a range `"a..b"`; an optional unit suffix `mm`/`cm`/`mm3`/`cm3`; and for
-`bbox`, `centerOfMass` and each side of `bounds`, a componentwise vector `"<=[x,y,z]"` /
-`">=[x,y,z]"` — exactly 3 components, each a plain number in mm or `*` to skip an axis.
-A vector is always one-sided: a bare `[40,40,10]` (meaning "exactly this size") is
-rejected, since a mesh's box shifts with tessellation and no tolerance would be honest
-for every part — pick `<=` for a limit or `>=` for a floor. `bounds` takes an object
-with `min` and/or `max`, each such a vector: `bounds: { min: ">=[0,0,0]", max:
+`bbox`, `centerOfMass` and each side of `bounds`, a componentwise vector — one-sided,
+`"<=[x,y,z]"` / `">=[x,y,z]"`, or two-sided with a range per axis,
+`"[28..32, 18..22, 9..11]"` (the bare comma form `"28..32,18..22,9..11"` is accepted
+too) — exactly 3 components, each a plain number in mm (or a range of them) or `*` to
+skip an axis. A bare `[40,40,10]` (meaning "exactly this size") is rejected, since a
+mesh's box shifts with tessellation and no tolerance would be honest for every part —
+pick `<=` for a limit, `>=` for a floor, or say what tolerance you mean with a range
+per axis (`"[39.5..40.5, 39.5..40.5, 9.8..10.2]"`; a zero-width `40..40` is an exact
+check with the parser's 1e-6 slack, and will fail on a chorded curve). `bounds` takes an
+object with `min` and/or `max`, each such a vector: `bounds: { min: ">=[0,0,0]", max:
 "<=[220,220,250]" }`. The parser is strict — a malformed assertion fails loudly.
 
 **A part whose typeface is a parameter needs band assertions, not points.** Glyph

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.161.0",
+  "version": "0.162.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

@@ -160,6 +160,8 @@ function checkHeld(held, parts, path) {
 // `verify-bad-expr`, not `verify-bad-pair-check`: a malformed key is a pair-naming
 // problem, but a malformed value is an assertion-DSL problem, same as any other
 // metric's expectation.
+const DSL_HINT = "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]` or `[28..32,18..22,9..11]` (with `*` to skip an axis).";
+
 function checkClearanceExprs(clearance, path) {
   if (clearance === undefined || clearance === null || typeof clearance !== "object") return [];
   const out = [];
@@ -168,7 +170,7 @@ function checkClearanceExprs(clearance, path) {
     catch (e) {
       out.push(err("verify-bad-expr",
         `the expectation for _view.clearance["${key}"] 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).",
+        DSL_HINT,
         `${path}[${JSON.stringify(key)}]`));
     }
   }
@@ -218,7 +220,7 @@ function checkProcessSpec(spec, path, valid, seen, depth = 0) {
 // One expectation's well-formedness against its registry entry: it parses, and it has the form the
 // metric reads — a range for `wall`, a componentwise vector for bbox/centerOfMass/the
 // sides of bounds. A bare vector gets the two legal spellings back, in its own numbers.
-const DSL_HINT = "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).";
+const VECTOR_OPS = new Set(["vle", "vge", "vrange"]);
 const capitalize = (t) => t.charAt(0).toUpperCase() + t.slice(1);
 
 function checkExpr(target, metric, spec, reg) {
@@ -246,10 +248,24 @@ function checkExpr(target, metric, spec, reg) {
       `Write ${metric} as \`"<min>..<max>"\` with min <= max, in mm.`,
       path)];
   }
-  if (form === "vector" && parsed.op !== "vle" && parsed.op !== "vge") {
+  if (form === "vector" && parsed.op !== "vle" && parsed.op !== "vge" && parsed.op !== "vrange") {
     return [err("verify-bad-expr",
       `the expectation for ${target}.${metric} must be a componentwise vector, got ${describe(expr)} — ${metric} is an [x,y,z] reading`,
-      `Write ${metric} as \`"<=[x,y,z]"\` or \`">=[x,y,z]"\` (componentwise; * skips an axis).`,
+      `Write ${metric} as \`"<=[x,y,z]"\`, \`">=[x,y,z]"\` or \`"[a..b,c..d,e..f]"\` (componentwise; * skips an axis).`,
+      path)];
+  }
+  // A vector on a scalar metric (`volume: "<=[1,2,3]"`) is not a parse error, and
+  // the evaluator would index a number and pass it vacuously — so it is caught here.
+  if (form !== "vector" && VECTOR_OPS.has(parsed.op)) {
+    return [err("verify-bad-expr",
+      `the expectation for ${target}.${metric} must be a single value, got ${describe(expr)} — ${metric} is one number, not an [x,y,z] reading`,
+      DSL_HINT,
+      path)];
+  }
+  if (parsed.op === "vrange" && parsed.vec.some((c) => c !== null && c[0] > c[1])) {
+    return [err("verify-bad-expr",
+      `the expectation for ${target}.${metric} must be a range vector with min <= max on every axis, got "${expr}"`,
+      `Write each axis of ${metric} as \`<min>..<max>\` with min <= max, in mm (or \`*\` to skip it).`,
       path)];
   }
   return [];

package/src/framework/oracle/assert-dsl.js

@@ -25,7 +25,8 @@ const reVec = /^(>=|<=)\s*\[\s*(.+?)\s*\]$/;
 // own numbers, which is a one-step fix. Returns that hint, or null when `expr` is
 // not a bare vector. An exact vector is deliberately not offered: a mesh's box is
 // tessellation-dependent (a curved face chords inside its true extent), so no
-// tolerance would be honest for every part.
+// tolerance would be honest for every part — a writer who wants both sides
+// declares the tolerance themselves with the per-axis range form below.
 const reBareVec = /^(?:==?)?\s*\[(.*)\]$/;
 const VEC_TAIL = "(componentwise; * skips an axis)";
 
@@ -36,6 +37,10 @@ export function bareVectorHint(expr) {
     const m = expr.trim().match(reBareVec);
     if (!m) return null;
     comps = m[1].split(",").map((t) => t.trim());
+    // A component with `..` in it is a range-vector attempt (below), not a bare
+    // vector: its own parse error names the right fix, and the two-spelling hint
+    // here would send the writer back to a one-sided form.
+    if (comps.some((c) => c.includes(".."))) return null;
   } else return null;
   comps = comps.map((c) => c.replace(/\s*mm$/, ""));
   const ok = comps.length === 3 && comps.every((c) => c === "*" || (c !== "" && Number.isFinite(Number(c))));
@@ -46,6 +51,33 @@ export function bareVectorHint(expr) {
 
 const show = (expr) => (typeof expr === "string" ? `"${expr}"` : JSON.stringify(expr));
 
+// The two-sided vector form: a RANGE per axis, `"[28..32, 18..22, 9..11]"`, with `*`
+// skipping an axis. The brackets are optional because the bare comma form
+// (`"28..32,18..22,9..11"`) is what a model produces when it reaches for this —
+// three trials wrote it before the form existed and were told "unrecognized form".
+// Components are plain numbers in mm, like the one-sided vectors: a unit suffix
+// is refused rather than scaled. Returns null when `s` is not a range-vector
+// attempt at all (no `..` inside a bracket pair or comma list), so the other
+// forms get their turn; a malformed attempt throws its own error.
+const reRangeComp = new RegExp(`^(${NUM})\\s*\\.\\.\\s*(${NUM})$`);
+const RANGE_VEC_SHAPE = "exactly 3 components, each a range a..b in mm or *";
+
+function rangeVector(s) {
+  const bracketed = s.match(/^\[(.*)\]$/);
+  const inner = bracketed ? bracketed[1] : s;
+  if (!inner.includes("..") || !inner.includes(",")) return null;
+  if (!bracketed && /[\[\]]/.test(s)) return null; // one bracket of a pair — not this form
+  const parts = inner.split(",").map((t) => t.trim());
+  if (parts.length !== 3) throw new Error(`assertion: a range vector takes ${RANGE_VEC_SHAPE}: "${s}"`);
+  const vec = parts.map((t) => {
+    if (t === "*") return null;
+    const m = t.match(reRangeComp);
+    if (!m) throw new Error(`assertion: a range vector takes ${RANGE_VEC_SHAPE}: "${s}"`);
+    return [toBase(m[1], undefined), toBase(m[2], undefined)];
+  });
+  return { op: "vrange", vec };
+}
+
 export function parseAssertion(expr) {
   if (typeof expr === "number" || typeof expr === "boolean") return { op: "eq", value: expr };
   const bare = bareVectorHint(expr);
@@ -53,6 +85,8 @@ export function parseAssertion(expr) {
   if (typeof expr !== "string") throw new Error(`assertion: unsupported value ${JSON.stringify(expr)}`);
   const s = expr.trim();
 
+  const vr = rangeVector(s);
+  if (vr) return vr;
   const vec = s.match(reVec);
   if (vec) {
     const parts = vec[2].split(",").map((t) => t.trim());
@@ -76,6 +110,7 @@ export function parseAssertion(expr) {
 const EPS = 1e-6;
 const approxEq = (a, b) => Math.abs(a - b) <= EPS + EPS * Math.abs(b);
 const fmtVec = (v) => "[" + v.map((x) => (x === null ? "*" : x)).join(",") + "]";
+const fmtRangeVec = (v) => "[" + v.map((c) => (c === null ? "*" : `${c[0]}..${c[1]}`)).join(",") + "]";
 
 export function evaluateAssertion(parsed, actual) {
   switch (parsed.op) {
@@ -102,6 +137,15 @@ export function evaluateAssertion(parsed, actual) {
       }
       return { pass, message: `${fmtVec(actual)} ${ge ? ">=" : "<="} ${fmtVec(parsed.vec)}` };
     }
+    case "vrange": {
+      let pass = true;
+      for (let i = 0; i < 3; i++) {
+        const band = parsed.vec[i];
+        if (band === null) continue;
+        if (actual[i] < band[0] - EPS || actual[i] > band[1] + EPS) pass = false;
+      }
+      return { pass, message: `${fmtVec(actual)} ${pass ? "in" : "out of"} ${fmtRangeVec(parsed.vec)}` };
+    }
     default: throw new Error(`assertion: unknown op "${parsed.op}"`);
   }
 }

package/src/framework/verify-metrics.js

@@ -130,7 +130,7 @@ export const SUBPART_METRICS = {
     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,
     hint: "rebuild volume differs from the reference import by more than the allowed percentage — a feature is missing, doubled, or mis-scaled vs the reference" },
-  refBboxDelta: { kind: "gate", extract: (s) => s.deviation?.bboxDelta ?? null,
+  refBboxDelta: { kind: "gate", form: "vector", extract: (s) => s.deviation?.bboxDelta ?? null,
     hint: "the rebuild's bounding-box corners drift from the reference import — check overall dimensions and that the rebuild is aligned to the reference's coordinates" },
   // Sheet parts (sheetPart(), partforge/geometry): each process's own checks. verify
   // volunteers them on every sheet sub-part; an author may declare them like any other.