partforge 0.154.0 → 0.155.0

package/docs/AUTHORING-PARTS.md

@@ -4267,11 +4267,11 @@ 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`, `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
+`overhangArea`, `wall` (a range — see below), `bounds` (the axis-aligned corner
+positions, written in the same `{ min, max }` shape `measure` reports them — 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`,
-`volume`, `overlaps`, `centerOfMass`, `boundsMin`, `boundsMax`, plus the pair-wise
+`volume`, `overlaps`, `centerOfMass`, `bounds`, plus the pair-wise
 `contacts` / `clearance` below.
 
 Passing these checks does **not** prove structural strength, fatigue life, stability,
@@ -4283,9 +4283,13 @@ 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`, `boundsMin`, `boundsMax`, a componentwise vector `"<=[x,y,z]"` /
-`">=[x,y,z]"` where `*` skips an axis. The parser is strict — a malformed assertion
-fails loudly.
+`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:
+"<=[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
 advance widths differ by family, so a `text2d` sub-part's `bbox`/`volume` shifts with
@@ -4297,8 +4301,8 @@ need this, but a part whose default already names a specific face does.
 
 ```js
 verify: { expect: {
-  stand: { boundsMin: ">=[0,0,0]", centerOfMass: "<=[*,*,25]" },   // sits in +octant, mass kept low
-  _view: { boundsMax: "<=[220,220,250]" },                          // whole assembly fits the bed
+  stand: { bounds: { min: ">=[0,0,0]" }, centerOfMass: "<=[*,*,25]" },   // sits in +octant, mass kept low
+  _view: { bounds: { max: "<=[220,220,250]" } },                          // whole assembly fits the bed
 } }
 ```
 

package/package.json

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

@@ -3,9 +3,9 @@
 // which is also the documented reason CLI stdout isn't pure JSON in that case.
 // Catching them statically removes both the wasted boot and the stdout caveat.
 import { err } from "./finding.js";
-import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
+import { SUBPART_METRICS, VIEW_METRICS, BOUNDS_FORM, teachableMetrics, sidesSpecError } from "../verify-metrics.js";
 import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
-import { parseAssertion } from "../oracle/assert-dsl.js";
+import { parseAssertion, bareVectorHint } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
 import { PROCESS_IDS } from "../process/registry.js";
 import { SHEET_DOC_ID } from "../sheet/constants.js";
@@ -187,6 +187,46 @@ function checkProcessSpec(spec, path, valid, seen, depth = 0) {
     path)];
 }
 
+// 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 capitalize = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+
+function checkExpr(target, metric, spec, reg) {
+  const path = `verify.expect.${target}.${metric}`;
+  const expr = exprOf(spec);
+  let parsed;
+  try { parsed = parseAssertion(expr); }
+  catch (e) {
+    const bare = bareVectorHint(expr);
+    return [err("verify-bad-expr",
+      `the expectation for ${target}.${metric} is not a valid assertion: ${e?.message || String(e)}`,
+      bare ? `${capitalize(bare)}. A vector expectation is one-sided: "<=" for a limit, ">=" for a floor.` : DSL_HINT,
+      path)];
+  }
+  const form = reg?.form;
+  if (form === "range" && parsed.op !== "range") {
+    return [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.`,
+      path)];
+  }
+  if (form === "range" && parsed.min > parsed.max) {
+    return [err("verify-bad-expr",
+      `the expectation for ${target}.${metric} must be a range with min <= max, got "${expr}"`,
+      `Write ${metric} as \`"<min>..<max>"\` with min <= max, in mm.`,
+      path)];
+  }
+  if (form === "vector" && parsed.op !== "vle" && parsed.op !== "vge") {
+    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).`,
+      path)];
+  }
+  return [];
+}
+
 export const VERIFY_RULES = [
   {
     id: "verify-expect-throws",
@@ -229,9 +269,12 @@ export const VERIFY_RULES = [
         // separately by verify-bad-pair-check, and excluded here.
         const metrics = target === "_view" ? peelPairKeys(metricsRaw) : metricsRaw;
         const registry = target === "_view" ? VIEW_METRICS : SUBPART_METRICS;
-        const valid = Object.keys(registry);
+        // Legacy spellings (boundsMin/boundsMax) still pass this rule, since verify
+        // still evaluates them, but are never listed or suggested: the vocabulary a
+        // reader is shown is the one the docs teach.
+        const valid = teachableMetrics(registry);
         for (const metric of Object.keys(metrics)) {
-          if (valid.includes(metric)) continue;
+          if (Object.hasOwn(registry, metric)) continue;
           const hint = suggest(metric, valid);
           out.push(err("verify-unknown-metric",
             `"${metric}" is not a ${target === "_view" ? "view" : "sub-part"} metric`,
@@ -256,28 +299,28 @@ export const VERIFY_RULES = [
         // 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)) {
-          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}`));
+        for (const [metric, specRaw] of Object.entries(metrics)) {
+          // A compound metric (`bounds: { min, max }`) is checked side by side, each
+          // side an ordinary expectation against its own registry entry.
+          // An unknown metric is verify-unknown-metric's finding; parsing its value
+          // too would only add a second, vaguer error for the same key.
+          if (!Object.hasOwn(registry, metric)) continue;
+          const reg = registry[metric];
+          if (reg.sides) {
+            const bad = sidesSpecError(metric, reg, specRaw);
+            if (bad) {
+              out.push(err("verify-bad-expr",
+                `the expectation for ${target}.${metric} is malformed: ${bad}`,
+                `Write \`${BOUNDS_FORM}\` — the same { min, max } shape measure reports. Either side may be left out, and \`*\` skips an axis.`,
+                `verify.expect.${target}.${metric}`));
+              continue;
+            }
+            for (const [side, sideSpec] of Object.entries(specRaw)) {
+              out.push(...checkExpr(target, `${metric}.${side}`, sideSpec, reg.sides[side]));
+            }
             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}`));
-          }
+          out.push(...checkExpr(target, metric, specRaw, reg));
         }
       }
       out.push(...checkClearanceExprs(expect?._view?.clearance, "verify.expect._view.clearance"));

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

@@ -19,15 +19,47 @@ const reScalar = new RegExp(`^(>=|<=|>|<)?\\s*(${NUM})\\s*${U}$`);
 const reRange = new RegExp(`^(${NUM})\\s*\\.\\.\\s*(${NUM})\\s*${U}$`);
 const reVec = /^(>=|<=)\s*\[\s*(.+?)\s*\]$/;
 
+// A vector with no comparison — `[40,40,10]` or `"[40,40,10]"` (or `"=[…]"`) — is the
+// commonest slip: the writer means "exactly this size". A vector is only ever
+// one-sided, so the error hands back both legal spellings built from the writer'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.
+const reBareVec = /^(?:==?)?\s*\[(.*)\]$/;
+const VEC_TAIL = "(componentwise; * skips an axis)";
+
+export function bareVectorHint(expr) {
+  let comps;
+  if (Array.isArray(expr)) comps = expr.map((c) => String(c).trim());
+  else if (typeof expr === "string") {
+    const m = expr.trim().match(reBareVec);
+    if (!m) return null;
+    comps = m[1].split(",").map((t) => t.trim());
+  } 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))));
+  if (!ok) return `use "<=[x,y,z]" or ">=[x,y,z]" (exactly 3 plain numbers in mm; componentwise; * skips an axis)`;
+  const v = `[${comps.join(",")}]`;
+  return `use "<=${v}" or ">=${v}" ${VEC_TAIL}`;
+}
+
+const show = (expr) => (typeof expr === "string" ? `"${expr}"` : JSON.stringify(expr));
+
 export function parseAssertion(expr) {
   if (typeof expr === "number" || typeof expr === "boolean") return { op: "eq", value: expr };
+  const bare = bareVectorHint(expr);
+  if (bare) throw new Error(`assertion: a vector needs a comparison, got ${show(expr)} — ${bare}`);
   if (typeof expr !== "string") throw new Error(`assertion: unsupported value ${JSON.stringify(expr)}`);
   const s = expr.trim();
 
   const vec = s.match(reVec);
   if (vec) {
     const parts = vec[2].split(",").map((t) => t.trim());
-    if (parts.length !== 3) throw new Error(`assertion: vector needs 3 components: "${expr}"`);
+    const plain = (t) => t === "*" || (t !== "" && Number.isFinite(Number(t)));
+    if (parts.length !== 3 || !parts.every(plain)) {
+      throw new Error(`assertion: a vector takes exactly 3 components, each a plain number in mm or *: "${expr}"`);
+    }
     return { op: vec[1] === "<=" ? "vle" : "vge", vec: parts.map((t) => (t === "*" ? null : toBase(t, undefined))) };
   }
   const range = s.match(reRange);

package/src/framework/oracle/verify.js

@@ -4,7 +4,7 @@ import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { relevanceHash } from "../param-deps.js";
-import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
+import { SUBPART_METRICS, VIEW_METRICS, sidesSpecError } from "../verify-metrics.js";
 import { processById } from "../process/registry.js";
 import { SHEET_DOC_ID, SHEET_CHECKS_NOTICE, SHEET_READ_ERROR_HINT } from "../sheet/constants.js";
 // Re-exported for the callers that read them from here; their one home is sheet/constants.js.
@@ -173,6 +173,21 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
   return out;
 }
 
+// Every check one declared metric yields: one, or one per side of a compound metric
+// (`bounds: { min, max }` → `bounds.min`, `bounds.max`), each judged by `check()` against
+// its side's own registry entry. A malformed compound value throws, as a malformed
+// expression does.
+function checksFor(scope, subpart, metric, spec, registry, factsObj) {
+  const reg = registry[metric];
+  if (!reg?.sides) return [check(scope, subpart, metric, spec, registry, factsObj)];
+  const bad = sidesSpecError(metric, reg, spec);
+  if (bad) throw new Error(`${scope === "view" ? "_view" : subpart}: ${bad}`);
+  return Object.entries(spec).map(([side, sideSpec]) => {
+    const name = `${metric}.${side}`;
+    return check(scope, subpart, name, sideSpec, { [name]: reg.sides[side] }, factsObj);
+  });
+}
+
 // ── sheet parts ──────────────────────────────────────────────────────────────
 // A view holding a sheet part (sheetPart(), partforge/geometry — measure() stamps
 // its row with `sheet`) is judged per part: the process profile's bed fits each
@@ -220,8 +235,7 @@ function sheetRowChecks(s, declaredExp) {
   const budgeted = (metric) => SUBPART_METRICS[metric]?.budgeted === true;
   const unread = (c, metric) => (c.actual == null ? SUBPART_METRICS[metric]?.readError?.(s) ?? null : null);
   const readFailure = (c, why) => ({ ...c, message: `not measured — ${why}`, hint: SHEET_READ_ERROR_HINT, pattern: SHEET_DOC_ID });
-  for (const [metric, expr] of Object.entries(declaredExp)) {
-    const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
+  for (const [metric, expr] of Object.entries(declaredExp)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s)) {
     if (PRINT_ONLY.has(metric)) {
       out.push({ scope: c.scope, subpart: c.subpart, metric, kind: c.kind, expr: c.expr, actual: null, status: "skip", pass: null,
         message: "not measured on a sheet part", hint: PRINT_ONLY_HINT, pattern: SHEET_DOC_ID });
@@ -269,7 +283,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
     ...(profile?.bed && !anySheet ? { bbox: `<=[${profile.bed.join(",")}]` } : {}),
     ...viewScalarExp,
   };
-  for (const [metric, expr] of Object.entries(viewExp)) checks.push(check("view", null, metric, expr, VIEW_METRICS, facts));
+  for (const [metric, expr] of Object.entries(viewExp)) checks.push(...checksFor("view", null, metric, expr, VIEW_METRICS, facts));
   checks.push(...pairGapChecks(facts, { contacts, clearance }, subPartNames));
 
   // Same rule as gapsSkipped above, one metric over: a min-wall gate with no reading
@@ -297,8 +311,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
       ...(expect?.[s.name] ?? {}),
     };
-    for (const [metric, expr] of Object.entries(merged)) {
-      const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
+    for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s)) {
       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 ${metric === "wall" ? "the wall band" : "min wall"}` });

package/src/framework/verify-metrics.js

@@ -15,6 +15,54 @@
 // sheet/constants.js, lint/finding.js) — so the linter's stays kernel-free.
 import { SHEET_METRICS } from "./process/registry.js";
 
+// `bounds` is written the way measure() reports it — `bounds: { min: [x,y,z], max:
+// [x,y,z] }` — so a reader who copies the shape of a measurement gets a legal
+// expectation: `bounds: { min: ">=[0,0,0]", max: "<=[220,220,250]" }`. It is the one
+// COMPOUND metric: its value is an object of `sides`, each an ordinary vector
+// expectation checked on its own and reported as `bounds.min` / `bounds.max`. Either
+// side may be left out; nothing else may sit under it (boundsSpecError).
+export const BOUNDS_FORM = 'bounds: { min: ">=[x,y,z]", max: "<=[x,y,z]" }';
+const BOUNDS_HINT = `write ${BOUNDS_FORM} — either side may be left out, and * skips an axis`;
+
+function boundsMetric(bounds, minHint, maxHint) {
+  return { kind: "gate", hint: BOUNDS_HINT, sides: {
+    min: { kind: "gate", form: "vector", extract: (f) => bounds(f)?.min, hint: minHint },
+    max: { kind: "gate", form: "vector", extract: (f) => bounds(f)?.max, hint: maxHint },
+  } };
+}
+
+// The flat spellings `bounds` replaced. Still evaluated, so a part written against
+// them keeps verifying, but `legacy` keeps them out of everything that TEACHES the
+// vocabulary: lint's list of valid metrics and its did-you-mean (teachableMetrics).
+function legacyBounds(bounds, minHint, maxHint) {
+  return {
+    boundsMin: { kind: "gate", form: "vector", legacy: "bounds", extract: (f) => bounds(f)?.min, hint: minHint },
+    boundsMax: { kind: "gate", form: "vector", legacy: "bounds", extract: (f) => bounds(f)?.max, hint: maxHint },
+  };
+}
+
+// The metric names a reader should be shown: every registry key but the legacy ones.
+export const teachableMetrics = (registry) => Object.keys(registry).filter((k) => !registry[k].legacy);
+
+// Why a compound metric's value is malformed, or null when it is well formed. verify
+// throws with it and lint reports it, so both say the same thing.
+export function sidesSpecError(metric, reg, spec) {
+  const sides = Object.keys(reg.sides);
+  const form = metric === "bounds" ? BOUNDS_FORM : `${metric}: { ${sides.join(", ")} }`;
+  if (spec === null || typeof spec !== "object" || Array.isArray(spec)) {
+    let shown;
+    try { shown = JSON.stringify(spec); } catch { shown = String(spec); }
+    return `${metric} takes an object { ${sides.join(", ")} }, got ${shown} — write ${form}`;
+  }
+  const keys = Object.keys(spec);
+  const unknown = keys.filter((k) => !sides.includes(k));
+  if (unknown.length) {
+    return `${metric} accepts only ${sides.map((k) => `"${k}"`).join(" and ")}, got ${unknown.map((k) => `"${k}"`).join(", ")} — write ${form}`;
+  }
+  if (!keys.length) return `${metric} needs at least one of ${sides.join(" or ")} — write ${form}`;
+  return null;
+}
+
 export const SUBPART_METRICS = {
   holes: { kind: "gate", manifoldOnly: true, extract: (s) => s.holes,
     hint: "genus is wrong — an unintended tunnel exists or an intended bore is blocked; make cut tools pierce fully (overcut past the faces)" },
@@ -27,14 +75,16 @@ export const SUBPART_METRICS = {
     hint: "surface area is out of range — detail features (facets, ribs, textures) are missing or doubled" },
   triangleCount: { kind: "gate", extract: (s) => s.triangleCount,
     hint: "triangle count is out of range — tessellation quality or feature count changed unexpectedly" },
-  bbox: { kind: "gate", extract: (s) => s.bbox,
+  bbox: { kind: "gate", form: "vector", extract: (s) => s.bbox,
     hint: "bounding box is out of range — check the governing dimensions and the part's orientation" },
-  centerOfMass: { kind: "gate", extract: (s) => s.centerOfMass,
+  centerOfMass: { kind: "gate", form: "vector", extract: (s) => s.centerOfMass,
     hint: "center of mass is outside the expected region — mass is distributed differently than intended; check feature placement or a mis-scaled sub-part" },
-  boundsMin: { kind: "gate", extract: (s) => s.bounds?.min,
-    hint: "the low corner is out of range — the part is positioned or oriented differently than expected" },
-  boundsMax: { kind: "gate", extract: (s) => s.bounds?.max,
-    hint: "the high corner is out of range — the part is positioned or oriented differently than expected" },
+  bounds: boundsMetric((s) => s.bounds,
+    "the low corner is out of range — the part is positioned or oriented differently than expected",
+    "the high corner is out of range — the part is positioned or oriented differently than expected"),
+  ...legacyBounds((s) => s.bounds,
+    "the low corner is out of range — the part is positioned or oriented differently than expected",
+    "the high corner is out of range — the part is positioned or oriented differently than expected"),
   minWall: { kind: "warn", extract: (s) => s.minWall,
     hint: "thinnest wall is at the reported location — increase the governing wall/thickness parameter or reduce the intersecting feature's depth",
     pattern: "minwall-sliver-triangles",
@@ -87,17 +137,19 @@ export const SUBPART_METRICS = {
   ...SHEET_METRICS,
 };
 export const VIEW_METRICS = {
-  bbox: { kind: "gate", extract: (r) => r.aggregate.bbox,
+  bbox: { kind: "gate", form: "vector", extract: (r) => r.aggregate.bbox,
     hint: "the assembled view exceeds its size limit — shrink the assembly or pick a process with a larger bed" },
   volume: { kind: "gate", extract: (r) => r.aggregate.volume,
     hint: "total assembly volume is out of range — a sub-part is missing, doubled, or mis-scaled" },
   overlaps: { kind: "gate", extract: (r) => r.overlaps.length,
     hint: "sub-parts interpenetrate near the reported location — adjust placement or add clearance in derive()",
     locate: (r) => r.overlaps[0]?.location ?? null },
-  centerOfMass: { kind: "gate", extract: (r) => r.aggregate.centerOfMass,
+  centerOfMass: { kind: "gate", form: "vector", extract: (r) => r.aggregate.centerOfMass,
     hint: "the assembly's center of mass is outside the expected region — a sub-part is mis-placed or mis-scaled" },
-  boundsMin: { kind: "gate", extract: (r) => r.aggregate.bounds?.min,
-    hint: "the assembly's low corner is out of range — check placement or orientation" },
-  boundsMax: { kind: "gate", extract: (r) => r.aggregate.bounds?.max,
-    hint: "the assembly's high corner is out of range — check placement or orientation" },
+  bounds: boundsMetric((r) => r.aggregate.bounds,
+    "the assembly's low corner is out of range — check placement or orientation",
+    "the assembly's high corner is out of range — check placement or orientation"),
+  ...legacyBounds((r) => r.aggregate.bounds,
+    "the assembly's low corner is out of range — check placement or orientation",
+    "the assembly's high corner is out of range — check placement or orientation"),
 };

package/types/part.d.ts

@@ -506,6 +506,16 @@ export type AssertionExpr = number | string | boolean;
 /** An expectation, optionally carrying a part-authored corrective `hint`. */
 export type Expectation = AssertionExpr | { expr: AssertionExpr; hint?: string };
 
+/**
+ * `bounds`: where the geometry sits, written in the same `{ min, max }` shape
+ * `measure` reports — `{ min: ">=[0,0,0]", max: "<=[220,220,250]" }`. Each side is
+ * a componentwise vector expectation (`*` skips an axis); either may be left out.
+ */
+export interface BoundsExpectation {
+  min?: Expectation;
+  max?: Expectation;
+}
+
 /**
  * Per-sub-part expectations. The keys are exactly `SUBPART_METRICS` in
  * src/framework/verify-metrics.js. `holes`/`watertight` are Manifold-only and
@@ -519,7 +529,11 @@ export interface SubPartExpectations {
   triangleCount?: Expectation;
   bbox?: Expectation;
   centerOfMass?: Expectation;
+  /** The axis-aligned corners: `{ min: ">=[x,y,z]", max: "<=[x,y,z]" }`, as `measure` reports `bounds`. */
+  bounds?: BoundsExpectation;
+  /** @deprecated Write `bounds: { min }` — still evaluated, no longer taught. */
   boundsMin?: Expectation;
+  /** @deprecated Write `bounds: { max }` — still evaluated, no longer taught. */
   boundsMax?: Expectation;
   minWall?: Expectation;
   /**
@@ -574,7 +588,11 @@ export interface ViewExpectations {
   volume?: Expectation;
   overlaps?: Expectation;
   centerOfMass?: Expectation;
+  /** The axis-aligned corners: `{ min: ">=[x,y,z]", max: "<=[x,y,z]" }`, as `measure` reports `bounds`. */
+  bounds?: BoundsExpectation;
+  /** @deprecated Write `bounds: { min }` — still evaluated, no longer taught. */
   boundsMin?: Expectation;
+  /** @deprecated Write `bounds: { max }` — still evaluated, no longer taught. */
   boundsMax?: Expectation;
   /** Pairs that must touch, as `[["a", "b"], …]`. */
   contacts?: Array<[string, string]>;