partforge 0.171.0 → 0.172.0

package/docs/AUTHORING-PARTS.md

@@ -1953,7 +1953,7 @@ Every print check is in exactly one tier, decided by what the reading means:
 
 | tier | checks | effect on `verify.ok` |
 | --- | --- | --- |
-| **gate** — a defect in any orientation | bed fit (`bbox` within `bed`), bed contact (`bedContactPct` ≥ 50) | fails it |
+| **gate** — a defect in any orientation | bed fit (`bbox` within `bed`), bed contact (`bedContactPct` ≥ 50), a declared flexing member's root (`flexRoot`) | fails it |
 | **cost** — a design choice with a price | overhang (`overhangArea`, id `supports`), footprint (`footprintPct` ≥ 10, id `footprint`) | never |
 | **advisory** — a reading that may not matter | min wall (`minWall`), `wall` | never; a warning |
 
@@ -2015,6 +2015,37 @@ pin together) or a pinned clevis, not a socket snapped over a sphere: the snap's
 is a downward cavity that prints on supports nobody can reach. Build the snap only when
 the user wants it and has accepted the supports.
 
+### Flexing members
+
+Anything meant to bend in use — a snap arm, a buckle prong, a clip, a latch hook, a
+cantilever tab, a living spring — must meet the body it grows from through a **fillet
+at its root of at least half its thickness**. Bending puts the highest stress at the
+root, a sharp inside corner multiplies it several times over, and an FDM print's layers
+are weakest across exactly that corner: an unrounded arm snaps off flush with the body,
+often on the first few flexes. Decide the root fillet with the arm, not after it, and
+keep it clear of whatever the arm slides into (chamfer that mouth so the fillet seats).
+
+Declare every such member in `verify.flex`, by its feature label, and label the member
+**apart from the body** it grows from:
+
+```js
+const arm = k.prism({ points: armPts, h: d.armH }).label("Right prong");
+let s = k.union([base, arm, otherArm])
+  .fillet({ r: 0.5 * p.armThick, edges: { inPlane: "XZ", at: 0 } }); // the arms' roots on the base face
+// …
+verify: { process: "fdm-pla", flex: ["Right prong", "Left prong"], expect: { … } },
+```
+
+verify then fails (`flexRoot`, a gate, under any process or none) wherever a triangle of
+the member meets a triangle of anything else at a sharp inside corner — a fillet's faces
+are new surfaces turning a few degrees per facet, so a rounded root reads clean, and a
+face that only continues flush into the body is not a corner. A rib or barb on the arm
+that carries its own label is part of the member: list them together,
+`flex: [["Right prong", "Right prong rib"]]`. Only what you declare is checked: the
+oracle cannot tell an arm that bends from a wall, a tooth or a pin of the same shape. A
+name no build labels is lint's `verify-flex-unknown-label` warning, and a member no
+sub-part of the verified view carries is reported as skipped.
+
 ### Small features and scale
 
 A feature thinner than the profile's `minWall` (1.2 mm PLA, 1.5 mm PETG, 0.6 mm
@@ -2028,7 +2059,8 @@ in the control's label ("below 150 mm the pins get thin").
 Size a mating feature from the profile's fit class — `press`, `push`, `slip`,
 `moving`, `printInPlace` — copied into `derive()` with a comment naming it
 (`// slip fit: fdm-pla 0.25`), and a horizontal bore enlarged by `holeUndersize`. A
-snap is a contact; its fit is `push` or `slip`. The numbers, and how a diametral fit
+snap is a contact; its fit is `push` or `slip`, and its arm gets a root fillet
+("Flexing members" above). The numbers, and how a diametral fit
 becomes a `clearance` expectation, are in the `verify` section below.
 
 ### First layer
@@ -4132,8 +4164,9 @@ runtime a throwing probe only degrades quietly to `{ error }`.
 
 **Verify block** — `verify-unknown-metric`, `verify-unknown-subpart`,
 `verify-bad-expr`, `verify-bad-pair-check`, `verify-unknown-process`,
-`verify-unknown-orientation`, `verify-unknown-accept`,
-`verify-expect-throws` (all errors). Note `_view` also accepts the pair-wise
+`verify-unknown-orientation`, `verify-unknown-accept`, `verify-bad-flex`,
+`verify-expect-throws` (all errors), and `verify-flex-unknown-label` (a warning: a
+`verify.flex` label no build writes at the default parameters). Note `_view` also accepts the pair-wise
 `contacts` / `clearance` / `held` keys, which are not scalar view metrics; they are
 validated by `verify-bad-pair-check`, matching `verify.js`'s own handling.
 
@@ -4534,6 +4567,24 @@ records it. Your own `footprintPct` expectation arms it under any profile; `orie
 does not, and `{ base: "fdm-pla", footprint: null }` switches it off. `exportable: false`
 sub-parts are not judged.
 
+**Flexing members — a GATE, armed by `verify.flex` alone.** `flex` lists the part's
+flexing members by feature label (`flex: ["Right prong", "Left prong"]`; a list entry,
+`["Arm", "Arm rib"]`, is one member made of several labels). Every printed sub-part
+whose mesh carries a member's label gets one `flexRoot` row (`"0"` by default; your own
+`flexRoot` expectation on that sub-part replaces it): the sharp inside corner where a
+member meets anything else — a concave edge turning more than 30° between one of its
+triangles and one that is not — fails on any. `actual` is the worst member's length in
+mm, `feature` names that member, `location` is its longest stretch, and `note` lists
+every member the sub-part carries. A rounded root reads 0. It is independent of the
+process and of the print pose: the root is the same in any orientation. Three
+declaration problems are reported per member rather than per sub-part: a member no
+sub-part of the verified view carries is skipped (it may be switched off in that case);
+a member carried but meeting nothing — its label put on the whole union, or a piece
+that never touches the body — withholds the verdict (`unevaluated`), since a clean root
+and no root must never read alike; and a seed that did not read a member answers
+unevaluated on a quick lap. See "Flexing members" under "Printed parts" for why, and
+how to round a root.
+
 **What the profile tells you.** Three more fields carry the numbers a mating
 feature needs. Nothing checks them; they are the one place the value is spelled,
 so `derive()` copies it with a comment naming the fit (`// slip fit: fdm-pla 0.25`).
@@ -4558,7 +4609,7 @@ an inline `{ base: "fdm-pla", fits: { … } }` replaces the whole table.
 **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`, `bedContactPct`, `footprintPct`, `wall` (a range — see below), `bounds` (the axis-aligned corner
+`overhangArea`, `bedContactPct`, `footprintPct`, `flexRoot`, `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`,

package/docs/ERROR-PATTERNS.md

@@ -234,6 +234,12 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** The lowest point of the piece is not a flat face, so almost none of its silhouette on the bed actually touches it (a cylinder on its side reads a few percent, under the floor): the first layer has almost nothing to bond to, and the piece tips or pulls loose unless it prints with a brim, a raft, or in a different orientation.
 - **Fix:** Lay the piece on its flat face in its print pose, add a flat foot or pad at its lowest point, or print it with a brim. When the user chose the brim, `verify.accept: ["footprint"]` records it and the cost reads accepted. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Printed parts".
 
+## flex-root-sharp
+
+- **Symptom:** A `✗ … flexRoot` failure from `verify` naming the member in `feature`, whose note reads e.g. `"Right prong": 12.2 mm of sharp inside corner (90°)`; or, in use, a snap arm, buckle prong, clip or cantilever tab that breaks off flush with the body it grows from.
+- **Cause:** The member declared in `verify.flex` meets the rest of the part at a sharp inside corner. Bending puts the highest stress at the root, a sharp corner multiplies it several times over, and in FDM the layer bonds are weakest right there — so the member snaps at its root, often on the first few flexes.
+- **Fix:** Round the root with a fillet of at least half the member's thickness: `s.fillet({ r, edges: { near: [x, y, z] } })` on the joined solid, one root edge at a time, or `edges: { inPlane, at }` when every root edge lies on the face the member grows from (fillet before anything else that touches that face joins, so only the roots are selected); or draw the fillet into the 2-D profile the member and body share. Keep the fillet clear of whatever the member slides into — chamfer that mouth to seat it. If a grip rib or barb on the member is labelled apart, list it with the member: `flex: [["Arm", "Arm rib"]]`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Printed parts".
+
 ## expect-static-across-presets
 
 - **Symptom:** A `verify` exact gate (`holes`, `volume`, …) fails on SOME presets only — e.g. `✗ planter holes 1  (0 != 1)` on two cases while defaults pass — and the preview looks right for every preset.

package/package.json

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

@@ -2,7 +2,7 @@
 // throws from verify() mid-run, AFTER measure has printed and the kernel has booted,
 // 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 { err, warn } from "./finding.js";
 import { SUBPART_METRICS, VIEW_METRICS, BOUNDS_FORM, teachableMetrics, sidesSpecError } from "../verify-metrics.js";
 import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
 import { parseAssertion, bareVectorHint } from "../oracle/assert-dsl.js";
@@ -447,4 +447,54 @@ export const VERIFY_RULES = [
       return out;
     },
   },
+  {
+    // `verify.flex` names the part's flexing members by feature label (oracle/flex-root.js):
+    // a list whose entries are a label, or a list of labels read as one member. verify()
+    // drops a malformed entry silently, so the shape is checked here.
+    id: "verify-bad-flex",
+    run: ({ part }) => {
+      const flex = part?.verify?.flex;
+      if (flex == null) return [];
+      const form = "Write `flex` as a list of feature labels, e.g. `flex: [\"Left arm\", \"Right arm\"]`; an entry that is itself a list names one member made of several labels (`[\"Arm\", \"Arm rib\"]`).";
+      if (!Array.isArray(flex)) {
+        return [err("verify-bad-flex", `\`verify.flex\` is ${describe(flex)}, not a list of feature labels`, form, "verify.flex")];
+      }
+      const label = (l) => typeof l === "string" && l.length > 0;
+      const out = [];
+      flex.forEach((e, i) => {
+        if (label(e) || (Array.isArray(e) && e.length > 0 && e.every(label))) return;
+        out.push(err("verify-bad-flex", `\`verify.flex[${i}]\` is ${describe(e)}, not a feature label or a list of them`, form, `verify.flex[${i}]`));
+      });
+      return out;
+    },
+  },
+  {
+    // A flex label no build writes is a check that never runs: verify skips a member no
+    // sub-part carries (it may be switched off in that case), so a typo would pass
+    // silently. The geometry-free probe records every `.label()` call at the default
+    // params; a label set only under other params reads as missing, hence a warning.
+    id: "verify-flex-unknown-label",
+    run: ({ part, probe }) => {
+      const flex = part?.verify?.flex;
+      if (!Array.isArray(flex) || !flex.length) return [];
+      const run = probe();
+      if (run.runaway || run.throws.length) return [];   // an unfinished build saw only some labels
+      const seen = new Set(run.calls.filter((c) => c.op === "label")
+        .map((c) => { try { return JSON.parse(c.args[0]); } catch { return null; } })
+        .filter((l) => typeof l === "string"));
+      const known = [...seen];
+      const out = [];
+      flex.forEach((e, i) => {
+        for (const l of Array.isArray(e) ? e : [e]) {
+          if (typeof l !== "string" || !l || seen.has(l)) continue;   // a bad shape is verify-bad-flex's
+          const hint = safeSuggest(l, known);
+          out.push(warn("verify-flex-unknown-label",
+            `\`verify.flex\` names "${l}", but no build labels a feature "${l}" at the default parameters`,
+            `Label the flexing member itself — \`.label("${l}")\` on the arm, apart from the body it grows from — or correct the name${hint ? ` (did you mean "${hint}"?)` : known.length ? ` (labels the build writes: ${known.slice(0, 12).map((k) => `"${k}"`).join(", ")})` : ""}. Until it matches, the root check never runs.`,
+            `verify.flex[${i}]`));
+        }
+      });
+      return out;
+    },
+  },
 ];

package/src/framework/oracle/flex-root.js

@@ -0,0 +1,128 @@
+// src/framework/oracle/flex-root.js
+// Whether a flexing member meets the rest of its part through a rounded root.
+//
+// The failure this exists for: a snap arm, a buckle prong, a clip or a cantilever tab
+// joined to its body at a sharp inside corner. Bending concentrates the stress at the
+// root, and a sharp inside corner multiplies it several times over, so the member snaps
+// there — often on the first flex, in FDM plastic whose layer bonds are weakest across
+// exactly that corner. Seen on a real forge: a side-release buckle whose prongs, each a
+// 2 mm prism unioned onto the base, broke off flush with the base face. A fillet at the
+// root of about half the member's thickness spreads the stress and is what fixes it.
+//
+// A mesh cannot tell a member that bends from a wall, a rib, a tooth or a pin — every
+// one of them is a thin feature joined at a sharp corner, and a shape-only detector
+// flagged most parts it was tried on. So the part SAYS which members flex
+// (`verify.flex`, by feature label), and this reads only those: every edge where a
+// triangle of the member meets a triangle of anything else. A root is sharp where that
+// edge is concave and turns by more than SHARP_DEG. A fillet's own faces are new,
+// unlabelled surfaces (or the sub-part's), and a tessellated fillet turns by a few
+// degrees per facet, tangent where it meets the member and the body — so a filleted
+// root reads clean, and so does a member whose faces only continue coplanar into the
+// body (its top face flush with the base's top).
+//
+// One pass over the triangles to weld edges, pure, no BVH. Works on both mesh forms the
+// oracle sees (Manifold's soup, OCCT's indexed vertices) — but only on a mesh carrying
+// `featureIds`/`features` (the feature labels), which both backends attach.
+//
+// Known limits, stated: an inside corner WITHIN one label (the member and its body
+// labelled alike, or a barb's own notch) is invisible — label the flexing member apart
+// from the body it grows from. A label that covers the whole sub-part, or a member that
+// never touches the rest of it, therefore has NO root to read: that is `attached` false,
+// which verify withholds a verdict on rather than passing (a clean root and no root
+// must never read alike). And a feature touching the member (a grip rib on the arm)
+// counts as "the rest of the part", so its corners read as roots unless it is listed
+// with the member: `flex: [["Arm", "Arm rib"]]` treats the group as one member.
+
+// A concave edge turning more than this (degrees) is a sharp corner. A tessellated
+// fillet turns a few degrees per facet (3.1° per step at the preview's 116 segments), a
+// 45° chamfer turns 45° twice — a chamfer is a corner too, if a softer one.
+export const SHARP_DEG = 30;
+const SHARP_COS = Math.cos((SHARP_DEG * Math.PI) / 180);
+// Sharp root edges shorter than this in total (mm) are boolean noise, never reported.
+export const ROOT_FLOOR = 0.1;
+
+/** The member groups `verify.flex` declares: each entry a label or a list of labels. */
+export function flexGroups(flex) {
+  if (!Array.isArray(flex)) return [];
+  return flex.map((e) => (Array.isArray(e) ? e : [e])).filter((g) => g.length && g.every((l) => typeof l === "string" && l));
+}
+
+/** The name a member group is reported under: its first label. */
+export const groupName = (group) => group[0];
+
+/**
+ * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, featureIds?: ArrayLike<number>, features?: string[] }} mesh
+ * @param {string[]} group the labels making up one flexing member
+ * @returns {{ found: boolean, attached: boolean, sharpLength: number, maxTurn: number|null, at: number[]|null }}
+ *   `found` false when no triangle carries any of the labels (the check cannot run);
+ *   `attached` false when the member shares no edge with the rest of the mesh (nothing
+ *   to read either — the label covers everything, or the member touches nothing);
+ *   `sharpLength` the total length (mm) of sharp concave root edges, 0 under ROOT_FLOOR;
+ *   `maxTurn` the sharpest such edge's turn in degrees and `at` the midpoint of the
+ *   longest one (both null when the root is clean).
+ */
+export function flexRoot(mesh, group) {
+  const { positions: P, indices: I, featureIds, features } = mesh;
+  const ids = new Set();
+  if (featureIds && features) features.forEach((f, i) => { if (group.includes(f)) ids.add(i + 1); });
+  if (!ids.size) return { found: false, attached: false, sharpLength: 0, maxTurn: null, at: null };
+  const nTri = I ? I.length / 3 : P.length / 9;
+  const vi = (t, j) => (I ? I[t * 3 + j] : t * 3 + j);
+  const key = (i) => `${Math.round(P[i * 3] * 1e4)},${Math.round(P[i * 3 + 1] * 1e4)},${Math.round(P[i * 3 + 2] * 1e4)}`;
+
+  // Normals and centroids, and every edge of a member triangle, keyed by welded endpoints.
+  const inMember = (t) => ids.has(featureIds[t]);
+  const normal = new Float64Array(nTri * 3), cent = new Float64Array(nTri * 3);
+  const edges = new Map(); // key -> { a, b, tris: [] }
+  const tri = (t) => [vi(t, 0), vi(t, 1), vi(t, 2)];
+  for (let t = 0; t < nTri; t++) {
+    const [a, b, c] = tri(t);
+    const ux = P[b * 3] - P[a * 3], uy = P[b * 3 + 1] - P[a * 3 + 1], uz = P[b * 3 + 2] - P[a * 3 + 2];
+    const vx = P[c * 3] - P[a * 3], vy = P[c * 3 + 1] - P[a * 3 + 1], vz = P[c * 3 + 2] - P[a * 3 + 2];
+    let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const len = Math.hypot(nx, ny, nz) || 1;
+    normal[t * 3] = nx / len; normal[t * 3 + 1] = ny / len; normal[t * 3 + 2] = nz / len;
+    for (let k = 0; k < 3; k++) cent[t * 3 + k] = (P[a * 3 + k] + P[b * 3 + k] + P[c * 3 + k]) / 3;
+  }
+  // Only edges touching a member triangle matter; register those first, then let any
+  // triangle sharing such an edge join it.
+  const keys = [];
+  for (let t = 0; t < nTri; t++) {
+    const v = tri(t);
+    keys.push(v.map(key));
+    if (!inMember(t)) continue;
+    for (let j = 0; j < 3; j++) {
+      const ka = keys[t][j], kb = keys[t][(j + 1) % 3];
+      const ek = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+      if (!edges.has(ek)) edges.set(ek, { a: v[j], b: v[(j + 1) % 3], tris: [] });
+    }
+  }
+  for (let t = 0; t < nTri; t++) {
+    for (let j = 0; j < 3; j++) {
+      const ka = keys[t][j], kb = keys[t][(j + 1) % 3];
+      const e = edges.get(ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`);
+      if (e) e.tris.push(t);
+    }
+  }
+
+  let sharpLength = 0, maxTurn = null, longest = 0, at = null, attached = false;
+  for (const e of edges.values()) {
+    if (e.tris.length !== 2) continue;
+    const [t1, t2] = e.tris;
+    if (inMember(t1) === inMember(t2)) continue;                  // inside the member, or not on it
+    attached = true;                                              // a boundary, at any turn
+    const d = normal[t1 * 3] * normal[t2 * 3] + normal[t1 * 3 + 1] * normal[t2 * 3 + 1] + normal[t1 * 3 + 2] * normal[t2 * 3 + 2];
+    if (d > SHARP_COS) continue;                                  // shallow: a fillet facet, a flush face
+    const mx = (P[e.a * 3] + P[e.b * 3]) / 2, my = (P[e.a * 3 + 1] + P[e.b * 3 + 1]) / 2, mz = (P[e.a * 3 + 2] + P[e.b * 3 + 2]) / 2;
+    // Concave: the second triangle lies in front of the first one's face.
+    const front = normal[t1 * 3] * (cent[t2 * 3] - mx) + normal[t1 * 3 + 1] * (cent[t2 * 3 + 1] - my) + normal[t1 * 3 + 2] * (cent[t2 * 3 + 2] - mz);
+    if (front <= 1e-9) continue;                                  // convex: an outside edge
+    const len = Math.hypot(P[e.a * 3] - P[e.b * 3], P[e.a * 3 + 1] - P[e.b * 3 + 1], P[e.a * 3 + 2] - P[e.b * 3 + 2]);
+    const turn = (Math.acos(Math.max(-1, Math.min(1, d))) * 180) / Math.PI;
+    sharpLength += len;
+    if (maxTurn == null || turn > maxTurn) maxTurn = turn;
+    if (len > longest) { longest = len; at = [mx, my, mz]; }
+  }
+  if (!attached || sharpLength < ROOT_FLOOR) return { found: true, attached, sharpLength: 0, maxTurn: null, at: null };
+  return { found: true, attached, sharpLength, maxTurn, at };
+}

package/src/framework/oracle/measure.js

@@ -14,6 +14,7 @@ import { bounds, meshArea, meshCentroid } from "./mesh.js";
 import { minWall, DIAGNOSTIC_SAMPLES } from "./min-wall.js";
 import { overhang } from "./overhang.js";
 import { bedContact } from "./bed-contact.js";
+import { flexRoot, flexGroups, groupName } from "./flex-root.js";
 import { partBedContact, partFootprint, partGatesMinWall, partHasBed, partOverhangAngle, partWallBands } from "./gates.js";
 import { summarizeContours } from "./shape-probe.js";
 
@@ -320,6 +321,12 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // one memo-key bit, covers both readings.
   const bedArmed = (opts.bedContact !== undefined ? opts.bedContact : (partBedContact(part) ?? partFootprint(part))) != null;
   const underside = overhangAngle != null || bedArmed;
+  // The flexing members the part declares (`verify.flex`, by feature label — flex-root.js):
+  // each gets a root reading on every printed sub-part. One pass over the triangles per
+  // member, no index, so it runs on every lap. verify passes its own list; alone, measure
+  // reads the part's. The list measured is stamped as `measuredFlex`, which verify
+  // compares before reusing a seed.
+  const flex = flexGroups(opts.flex !== undefined ? opts.flex : part.verify?.flex);
   const subBounds = [];
   // Sheet parts: a view holding one sizes each printed sub-part in its print pose
   // (verify fits the bed per part there), and every sheet row gets its 2-D facts under
@@ -372,7 +379,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     const memoKey = opts.memo && !sheetView && !sheet && !part.parts[name]?.reference && solid?._hash && !exportBed
       ? JSON.stringify({
         mw: !!opts.minWall, s: minWallSamples ?? null, band: wallBands[name] ?? null,
-        oh: overhangAngle ?? null, bc: bedArmed, ex: printed,
+        oh: overhangAngle ?? null, bc: bedArmed, ex: printed, fx: flex,
         pm: printMatrix ? Array.from(printMatrix) : null,
       })
       : null;
@@ -471,6 +478,13 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       footprintPct: bc && bc.downArea > 0 ? Math.min(100, (100 * bc.contactArea) / bc.downArea) : null,
       footprintAt: bc?.lowestAt ?? null,
       ...(exportBc?.error ? { bedContactError: exportBc.error } : {}),
+      // Each declared flexing member's root (flex-root.js), one entry per member group
+      // whose label this sub-part's mesh carries: the length of sharp inside corner where
+      // the member meets the rest of the part, the sharpest turn, and where the longest
+      // stretch sits. Null when nothing is declared; a sheet part is not printed, so none.
+      flexRoots: flex.length && !sheet
+        ? flex.map((g) => ({ feature: groupName(g), labels: g, ...flexRoot(mesh, g) })).filter((r) => r.found)
+        : null,
       // The process's 2-D facts on a sheet part (sheetRowFacts), null on every other.
       sheet: sheet
         ? sheetRowFacts(kernel, part, name, view, sheetParams, sheetBudget, vol)
@@ -562,6 +576,9 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     measuredBedContact: bedArmed,
     // The footprint is read by the same pass, so the same stamp.
     measuredFootprint: bedArmed,
+    // The flexing-member groups whose roots were read (flex-root.js), as measured —
+    // verify reuses a seed only when it read every group this run declares.
+    measuredFlex: flex,
     // Companion stamp to measuredMinWall, and read the same way: whether the pass
     // ran, said by the pass itself rather than claimed by whoever holds the result.
     measuredGaps,

package/src/framework/oracle/verify.js

@@ -2,10 +2,11 @@ import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
 import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { heldCheck } from "./held.js";
+import { flexGroups, groupName } from "./flex-root.js";
 import { resolveProfile, overhangAngleFor, bedContactFor, footprintFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { relevanceHash } from "../param-deps.js";
-import { SUBPART_METRICS, VIEW_METRICS, sidesSpecError } from "../verify-metrics.js";
+import { SUBPART_METRICS, VIEW_METRICS, sidesSpecError, FLEX_ROOT_HINT } 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.
@@ -149,7 +150,7 @@ function check(scope, subpart, metric, spec, registry, factsObj, accept = []) {
     // 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" };
+        hint: partHint ?? reg.unavailableHint ?? "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;
@@ -159,6 +160,9 @@ function check(scope, subpart, metric, spec, registry, factsObj, accept = []) {
   const { pass, message } = evaluateAssertion(parseAssertion(expr), actual);
   const status = pass ? "pass" : reg.kind === "warn" ? "warn" : reg.kind === "cost" ? "cost" : "fail";
   const out = { ...base, actual, status, pass, message };
+  // The labelled feature a reading is about (flexRoot's worst member), whatever the verdict.
+  const feature = reg.feature?.(factsObj);
+  if (feature) out.feature = feature;
   // A measurement caveat rides along whatever the verdict — a min-wall reading
   // taken from a sample still passed, but the reader should know it was a sample.
   const note = reg.note?.(factsObj);
@@ -215,8 +219,8 @@ const SHEET_BUDGET_HINT = "The 2-D sheet checks did not fit their time budget
 // The print checks: measure() casts no rays and runs no overhang pass on a sheet part.
 // Declared on one, each is a skip — declared, never evaluated, so a sheet-only forge
 // that declares only these has no verdict rather than a vacuous pass.
-const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea", "bedContactPct", "footprintPct"]);
-const PRINT_ONLY_HINT = "minWall, wall, overhangArea, bedContactPct and footprintPct are print checks, and a sheet part is cut, not printed: nothing measures them here. For a laser part declare sheetBridge (the narrowest web or finger) or sheetGap (the narrowest hole or slot) instead.";
+const PRINT_ONLY = new Set(["minWall", "wall", "overhangArea", "bedContactPct", "footprintPct", "flexRoot"]);
+const PRINT_ONLY_HINT = "minWall, wall, overhangArea, bedContactPct, footprintPct and flexRoot are print checks, and a sheet part is cut, not printed: nothing measures them here. For a laser part declare sheetBridge (the narrowest web or finger) or sheetGap (the narrowest hole or slot) instead.";
 
 // A sheet reading the geometry engine could not take (SheetFacts.readErrors): a
 // volunteered check warns with the reason; a declared one warns with it too, and is
@@ -278,7 +282,7 @@ function sheetRowChecks(s, declaredExp) {
 // `footprintPct >= floor` on every printed sub-part.
 // `accept` the cost ids the user accepted (`verify.accept`), stamped on each cost the
 // process volunteered (never on one the author wrote in `expect`).
-export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null, footprint = null, accept = [] }) {
+export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null, footprint = null, accept = [], flex = [] }) {
   const checks = [];
   // contacts/clearance/held are pair-derived, not scalar view metrics — peel
   // them off before the registry loop. held.js explains the exportable bound.
@@ -326,6 +330,9 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
       ...(bedContact != null && (!printedNames || printedNames.has(s.name)) ? { bedContactPct: `>=${bedContact}` } : {}),
       ...(footprint != null && (!printedNames || printedNames.has(s.name)) ? { footprintPct: `>=${footprint}` } : {}),
+      // A declared flexing member this sub-part carries AND meets (flex-root.js): its
+      // root must be rounded. A carried member that meets nothing is flexChecks' row.
+      ...(flex.length && s.flexRoots?.some((r) => r.attached) ? { flexRoot: "0" } : {}),
       ...(expect?.[s.name] ?? {}),
     };
     // `accept` covers only the process's own default check: a cost metric the author
@@ -363,9 +370,48 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
       checks.push(c);
     }
   }
+  checks.push(...flexChecks(facts, flex));
   return checks;
 }
 
+// Flexing members (`verify.flex`, flex-root.js). The reading itself is the registry's
+// `flexRoot` gate, one row per sub-part carrying a member that meets the rest of the
+// part (evaluateCase's `merged`). What is left here is per DECLARED member, the cases
+// where no sub-part row can answer for it: a seed that did not read the member
+// (measuredFlex) answers unevaluated on a quick lap; a member no sub-part of this view
+// carries is a skip, not a fail — a sub-part an `enabled()` turned off, or one shown
+// only in another view — and lint's verify-flex-unknown-label is what catches a label
+// no build ever writes; a member carried but attached nowhere (its label covers the
+// whole sub-part, or the member never touches the body) withholds the verdict: a clean
+// root and no root must never read alike.
+export { FLEX_ROOT_HINT };
+const sameGroup = (a, b) => a.length === b.length && a.every((l, i) => l === b[i]);
+function flexChecks(facts, flex) {
+  const out = [];
+  for (const g of flex) {
+    const feature = groupName(g);
+    const base = { scope: "subpart", metric: "flexRoot", kind: "gate", feature, expr: "0", subpart: null, actual: null, status: "skip", pass: null };
+    if (!(facts.measuredFlex ?? []).some((m) => sameGroup(m, g))) {
+      out.push({ ...base, unevaluated: true,
+        message: "not measured (quick check)", hint: "re-run this check without `quick` to read the flexing member's root" });
+      continue;
+    }
+    const rows = facts.subparts.flatMap((s) => (s.flexRoots ?? []).filter((r) => sameGroup(r.labels, g)));
+    if (!rows.length) {
+      out.push({ ...base,
+        message: `no sub-part in this view carries the label ${g.map((l) => `"${l}"`).join(" or ")}`,
+        hint: "verify.flex names flexing members by their feature label — label the member (`.label(\"Arm\")`) apart from the body it grows from, and spell it the same in both places" });
+      continue;
+    }
+    if (!rows.some((r) => r.attached)) {
+      out.push({ ...base, unevaluated: true,
+        message: `"${feature}" never meets the rest of the part: its label covers every triangle it touches, so there is no root to read`,
+        hint: "label the flexing member apart from the body it grows from (`.label(\"Arm\")` on the arm before the union, not on the union), or, if the member really is a separate piece, it has no root and does not belong in verify.flex" });
+    }
+  }
+  return out;
+}
+
 // `seed` lets a caller that has ALREADY measured this part hand the result in so
 // verify does not recompute it — see the seeding block below for the shape and
 // the one correctness rule that governs it.
@@ -391,6 +437,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   const bedContactFloor = bedContactFor(part, process, { expanded });
   const footprintFloor = footprintFor(part, process, { expanded });
   const accept = Array.isArray(part?.verify?.accept) ? part.verify.accept : [];
+  const flex = flexGroups(part?.verify?.flex);
   // Reuse rule (spec §4): case B may reuse a measurement taken at params A when
   // B agrees with A on every param that measurement READ (recorded by measure()
   // itself). Sound for the same reason the mesh cache is: a deterministic build
@@ -464,7 +511,9 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // sizes cannot answer a bed, so it is admitted only when this run needs no bed.
   const needPrintBboxes = profile?.bed != null;
   const printBboxesMatch = !needPrintBboxes || seed?.result?.measuredPrintBboxes !== false;
-  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && (quick || bedContactMatches) && printBboxesMatch
+  // The flex half: a seed that read every declared member (a superset is free).
+  const flexMatches = flex.every((g) => (seed?.result?.measuredFlex ?? []).some((m) => sameGroup(m, g)));
+  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && (quick || bedContactMatches) && (quick || flexMatches) && printBboxesMatch
     && seed.result.view === view) {
     entries.push({ params: full(seed.params), result: seed.result });
   }
@@ -478,7 +527,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     // for every case buys nothing. (A seed measured WITH probes is a superset in
     // the same way a min-wall seed is: the extra key is simply never read here.)
     const result = measureFn(kernel, part, view, params,
-      { minWall: needMinWall, probes: false, overhang: overhangAngle, bedContact: armsBedPass, printBboxes: needPrintBboxes });
+      { minWall: needMinWall, probes: false, overhang: overhangAngle, bedContact: armsBedPass, printBboxes: needPrintBboxes, flex });
     entries.push({ params: fp, result });
     return result;
   };
@@ -499,7 +548,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   }];
   const caseResults = expanded.map(({ name, params, expect }) => {
     const facts = measureCase(params);
-    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle, bedContact: bedContactFloor, footprint: footprintFloor, accept }) : notMeasured(name) };
+    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang: overhangAngle, bedContact: bedContactFloor, footprint: footprintFloor, accept, flex }) : notMeasured(name) };
   });
   // VACUOUS VERIFY. A part that declares nothing — no profile, an empty or absent
   // `expect` — used to come back `ok: true` with zero checks, and every reader
@@ -534,7 +583,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
     declared++;
     if (c.status !== "skip" && !c.unevaluated) evaluated++;
   }
-  const declaresAnything = profile != null || overhangAngle != null || bedContactFloor != null || footprintFloor != null
+  const declaresAnything = profile != null || overhangAngle != null || bedContactFloor != null || footprintFloor != null || flex.length > 0
     || expanded.some(({ expect }) => Object.values(expect ?? {}).some((o) => o && typeof o === "object" && Object.keys(o).length > 0));
   const failures = all.filter((c) => c.status === "fail");
   const unevaluated = all.filter((c) => c.unevaluated);

package/src/framework/verify-metrics.js

@@ -4,7 +4,10 @@
 // `pattern` (optional stable ERROR-PATTERNS.md#<id>), `locate` (optional
 // [x,y,z] source), `note` (optional caveat about HOW the value was measured,
 // attached whatever the status — a passing-but-sampled reading is exactly the
-// case a reader needs told about). `manifoldOnly` facts are null on OCCT parts.
+// case a reader needs told about), `feature` (optional: the labelled feature the
+// reading is about, stamped whatever the status), `unavailable` (+ `unavailableHint`:
+// a null reading is a finding to warn about, not an inert skip). `manifoldOnly`
+// facts are null on OCCT parts.
 //
 // This lives one level above framework/oracle/ deliberately: the set of legal
 // `verify.expect` metrics is part of the PartDefinition CONTRACT, which both the
@@ -63,6 +66,13 @@ export function sidesSpecError(metric, reg, spec) {
   return null;
 }
 
+// The flexing-member root (oracle/flex-root.js): what the failure means and what fixes it.
+export const FLEX_ROOT_HINT = "a part that flexes (a snap arm, buckle prong, clip or cantilever tab) meets the rest of the part at a sharp inside corner here — bending concentrates the stress at that corner and the member snaps off at its root. Round the root: a fillet of at least half the member's thickness where it joins the body (`s.fillet({ r, edges: { near: [x, y, z] } })` on the joined solid, or a filleted corner in the 2-D profile both share), and keep that fillet clear of whatever the member slides into. A grip rib or barb on the member is part of it: list its label with the member's, `flex: [[\"Arm\", \"Arm rib\"]]`";
+// The member whose root is worst on a sub-part, among those that meet the rest of it;
+// null when none does (nothing declared, no label carried, or every member detached).
+const worstFlexRoot = (s) => (s.flexRoots ?? []).filter((r) => r.attached)
+  .reduce((w, r) => (w == null || r.sharpLength > w.sharpLength ? r : w), 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)" },
@@ -132,6 +142,27 @@ export const SUBPART_METRICS = {
     hint: "the share of this piece's silhouette on the bed (its outline in the print pose) that actually touches it is small — it stands on a point, a line or a curve, which reads near zero, so the first layer has almost nothing to hold on to and the piece can tip or pull loose. Lay it on its flat face, add a flat foot or pad at its lowest point, or print it with a brim (accept: [\"footprint\"] records that choice)",
     pattern: "piece-stands-on-nothing",
     locate: (s) => s.footprintAt },
+  // A declared flexing member's root (oracle/flex-root.js, `verify.flex`): the length in
+  // mm of sharp inside corner where the member meets the rest of the sub-part. One row
+  // per sub-part, like every print metric: `actual` is the WORST member's reading,
+  // `feature` names it, and `note` lists every member the sub-part carries. Measured on
+  // a sub-part carrying a declared label; elsewhere `extract` is null — "no root to
+  // read" rather than an inert skip, since an authored expectation with nothing
+  // declared, or on a member that never meets the body, is a mistake to point at. A
+  // GATE under any process or none: the root is the same in any orientation and the
+  // stress concentration is the same in any material.
+  flexRoot: { kind: "gate", extract: (s) => worstFlexRoot(s)?.sharpLength ?? null,
+    hint: FLEX_ROOT_HINT,
+    pattern: "flex-root-sharp",
+    locate: (s) => worstFlexRoot(s)?.at ?? null,
+    feature: (s) => worstFlexRoot(s)?.feature ?? null,
+    unavailable: "no root to read",
+    unavailableHint: "flexRoot reads the root of a member named in `verify.flex` — declare the flexing member there by its feature label, and label it (`.label(\"Arm\")`) apart from the body it grows from, so this sub-part carries a member that meets the rest of the part",
+    note: (s) => {
+      const rows = s.flexRoots ?? [];
+      if (!rows.length) return null;
+      return rows.map((r) => `"${r.feature}": ${!r.attached ? "never meets the rest of this sub-part" : r.sharpLength > 0 ? `${r.sharpLength.toFixed(1)} mm of sharp inside corner (${Math.round(r.maxTurn)}°)` : "rounded root"}`).join("; ");
+    } },
   // `s.deviation` (measure.js) exists only for a sub-part declaring `reference:
   // "<import name>"`; on every other sub-part `extract` returns null, which
   // `check()` already reports as status "skip" rather than a fail — the

package/types/part.d.ts

@@ -581,6 +581,12 @@ export interface SubPartExpectations {
    * a cost (`verify.costs`), never a failure; `accept: ["footprint"]` records a brim.
    */
   footprintPct?: Expectation;
+  /**
+   * Length (mm) of sharp inside corner where a flexing member named in `verify.flex`
+   * meets the rest of this sub-part — `actual` is the worst member's, `feature` names
+   * it. Every sub-part carrying a declared member gets `"0"` by default; a gate.
+   */
+  flexRoot?: Expectation;
   /** Symmetric-difference volume vs. the sub-part's declared `reference` import. */
   refXorVolume?: Expectation;
   /** Percent volume delta vs. the sub-part's declared `reference` import. */
@@ -660,6 +666,15 @@ export interface VerifyBlock<P = ResolvedParams, D = Derived> {
    * (`overhangArea: "<=500"`) keeps its meaning and is never marked accepted.
    */
   accept?: ("supports" | "footprint")[];
+  /**
+   * The part's flexing members — snap arms, buckle prongs, clips, cantilever tabs —
+   * by feature label. Each must meet the rest of its part through a rounded root:
+   * verify fails on a sharp inside corner where a triangle of the member meets a
+   * triangle of anything else. An entry that is a list names one member made of
+   * several labels (an arm and the rib on it). Label the member apart from the body
+   * it grows from.
+   */
+  flex?: (string | string[])[];
   /** Which cases to check; default is `"defaults"` plus every preset name. */
   cases?: string[];
   /**

package/types/testing.d.ts

@@ -441,6 +441,13 @@ export interface SubPartFacts {
   footprintPct: number | null;
   /** The piece's lowest point, in display coordinates; `null` when not checked. */
   footprintAt: number[] | null;
+  /**
+   * The root of each flexing member (`verify.flex`) this sub-part carries, one entry per
+   * declared member group whose label its mesh holds; `null` when none is declared, or on
+   * a sheet part. `attached` is false when the member shares no edge with the rest of the
+   * mesh (nothing to read); `sharpLength` the mm of sharp inside corner at its root.
+   */
+  flexRoots: { feature: string; labels: string[]; found: boolean; attached: boolean; sharpLength: number; maxTurn: number | null; at: number[] | null }[] | null;
   /**
    * Present only when bed contact had to be read off the piece's export build (its
    * print pose could not be read from place() alone) and that build failed.