partforge 0.171.0 → 0.173.0

package/docs/AUTHORING-PARTS.md

@@ -1953,9 +1953,9 @@ 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 |
-| **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 |
+| **gate** — a defect in any orientation | bed fit (`bbox` within `bed`), bed contact (`bedContactPct` ≥ 50), a declared flexing member's root fillet (`flexRoot` ≥ half its thickness) | fails it |
+| **cost** — a design choice with a price | overhang (`overhangArea`, id `supports`), footprint (`footprintPct` ≥ 10, id `footprint`), a flexing member printed standing (`flexTilt` ≤ 45°, id `standing`) | never |
+| **advisory** — a reading that may not matter | min wall (`minWall`), `wall`, a flexing member's root strain at its declared deflection (`flexStrain`) | never; a warning |
 
 A **gate** is fixed before the work is done: the piece cannot be printed this way
 whatever the user wants. A **cost** is a fact with a number and a location — mm² of
@@ -1976,7 +1976,7 @@ A threshold the user named ("under 500 mm² of supports") is an `expect`:
 `overhangArea: "<=500"` — still a cost, reported in `costs` and never failing `ok`;
 the user's own limit keeps its meaning, so it is never marked accepted, whatever
 `accept` says (`accept` covers only the process's default check). Lint refuses an `accept` entry the process does not define
-(`verify-unknown-accept`): `fdm` defines `supports` and `footprint`; `resin` prints on
+(`verify-unknown-accept`): `fdm` defines `supports`, `footprint` and `standing`; `resin` prints on
 supports and defines none.
 
 **What arms what.** Under `fdm-pla`/`fdm-petg` the profile alone arms every check in
@@ -2015,6 +2015,68 @@ 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 — fails in four ways, and the first three read off the
+same declaration. It 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, so 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). Its
+**root strain** at the travel it is designed for must stay under what the material takes
+— for a straight cantilever that is 1.5 × thickness × deflection / length², so a short,
+thick arm with a deep undercut yields or cracks whatever its root looks like: lengthen
+it, thin it, shorten the travel, or taper it (half the thickness at the tip bends about
+60% further). It must **lie flat on the bed**: an arm standing up in the print pose has
+its layers stacked across its root, and a layer bond is a fraction of the in-plane
+strength. And it must not be thinner than the process prints (`minWall`, as for anything).
+
+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: [
+    { feature: "Right prong", deflection: p.undercut },   // the travel it snaps through
+    { feature: "Left prong", deflection: p.undercut },
+    ["Latch", "Latch barb"],                               // one member made of two labels
+  ],
+  expect: { … },
+},
+```
+
+An entry is a label, a list of labels that make one member (an arm and the rib or barb
+on it, which otherwise counts as "the rest of the part"), or an object with `feature`,
+optional `labels`, the `deflection` in mm that arms the strain reading, and a
+`thickness` in mm when the mesh would misread the bending thickness (the member's
+smallest extent, which a wide hook or a tapered arm can fool). verify then reports, per
+sub-part carrying a member:
+
+- `flexRoot` — the root's fillet radius in mm, 0 where any of it is sharp, against the
+  process's `rootFillet` share of the member's thickness (0.5 everywhere). A gate,
+  under any process or none: a fillet's faces are tangent where they meet the member
+  and the body, a face that only continues flush into the body is not a corner, and a
+  45° chamfer is still a corner.
+- `flexStrain` — the root strain in percent at the declared deflection, against the
+  process's `strain` (1.5 on PLA, 3 on PETG, 2 on resin). An advisory, since the
+  cantilever formula is a first approximation; a member with no `deflection` is not read.
+- `flexTilt` — the degrees the member's long axis rises off the bed in the print pose,
+  against the FDM profiles' `flexTilt` (45°). A cost, `standing`, that the user may
+  accept (`accept: ["standing"]`); resin is isotropic and never asks.
+
+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, a member no sub-part of the verified view carries is
+reported as skipped, and a member whose label meets nothing (the label put on the whole
+union) withholds the verdict.
+
 ### 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 +2090,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 +4195,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.
 
@@ -4435,8 +4499,9 @@ A part can declare how it should be checked, co-located with its schema, so
 ```js
 verify: {
   process: "fdm-pla",            // a DFM profile: fdm-pla | fdm-petg | resin, or an inline
-                                  // { base, bed:[x,y,z], minWall, overhang, bedContact, footprint, fits, holeUndersize, bridge } object
-  accept: ["supports"],          // optional; the costs the user chose to pay (fdm: supports, footprint)
+                                  // { base, bed:[x,y,z], minWall, overhang, bedContact, footprint, fits, holeUndersize, bridge,
+                                  //   rootFillet, strain, flexTilt } object
+  accept: ["supports"],          // optional; the costs the user chose to pay (fdm: supports, footprint, standing)
   orientation: "print",          // optional; declares build() is the print pose (Z up, bed at
                                   // the lowest Z) — with no profile it arms bed contact
   cases: ["defaults", "M3"],     // optional; default = defaults + every preset
@@ -4534,6 +4599,33 @@ 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 — `flexRoot` a GATE armed by `verify.flex` alone, `flexStrain` an
+advisory from a declared deflection, `flexTilt` the `standing` cost under FDM.** `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; an object,
+`{ feature: "Arm", deflection: 1.2, thickness: 2 }`, adds the travel in mm the member
+is designed to flex through and, when the mesh would misread it, its bending
+thickness). Every printed sub-part whose mesh carries a member's label gets one row per
+reading (your own expectation on that sub-part replaces the default): `flexRoot` is the
+root fillet radius in mm of the member whose root is worst (least radius over what it
+needs), 0 where any of it is sharp — a concave edge turning more than 30° between one of
+its triangles and one that is not — against `>=` the profile's `rootFillet` share of that
+member's thickness (`feature` names the member, `location` is the longest sharp stretch,
+`note` lists every member the sub-part carries with its radius and need); `flexStrain`
+is the worst member's root strain in percent at its declared deflection, 1.5 × thickness ×
+deflection / length² for a straight cantilever, against `<=` the profile's `strain`;
+`flexTilt` is the degrees the worst member's long axis rises off the bed in the print
+pose, against `<=` the profile's `flexTilt`, a cost (`standing`). The root and strain
+readings are independent of the process and of the print pose; the tilt is read in the
+print pose, like bed contact, and withheld when that pose cannot be read. 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`).
@@ -4552,13 +4644,16 @@ an inline `{ base: "fdm-pla", fits: { … } }` replaces the whole table.
 | `fits.printInPlace` — printed already assembled | 0.45 | 0.50 | 0.20 |
 | `holeUndersize` | 0.25 | 0.30 | 0.05 |
 | `bridge` (mm) | 10 | 10 | — |
+| `rootFillet` — a flexing member's root fillet, as a share of its thickness (a gate) | 0.5 | 0.5 | 0.5 |
+| `strain` — the root strain (%) a one-time snap may reach (an advisory) | 1.5 | 3 | 2 |
+| `flexTilt` — the steepest a flexing member may stand off the bed, degrees (a cost, `standing`) | 45 | 45 | — |
 
 `fits` are diametral; the `clearance` expectation below reads a pair's minimum surface distance, so a pin in a bore is declared at half the fit (`fits.slip` 0.25 → `clearance: { "pin×body": "0.08..0.18" }`).
 
 **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`, `flexStrain`, `flexTilt`, `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,24 @@ 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": sharp root (90°, 12.2 mm of corner)` or `"Right prong": root radius 0.4 mm, needs ≥ 1 (2 mm thick)`; 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, or through a fillet smaller than the process's `rootFillet` share of its thickness (half, on every built-in profile). 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"]]`. If the mesh misreads the member's bending thickness (a wide hook reads its width), declare it: `flex: [{ feature: "Arm", thickness: 2 }]`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Printed parts".
+
+## flex-strain-over
+
+- **Symptom:** A `⚠ … flexStrain` warning from `verify`, e.g. `"Arm": 2.67% at 2 mm (15 mm long, 2 mm thick)` against `<=1.5`; or, in use, a snap arm that whitens, takes a set or cracks at its root the first time it is pressed home.
+- **Cause:** At the deflection declared for it (`flex: [{ feature, deflection }]`) the member's root strain — 1.5 × thickness × deflection / length² for a straight cantilever — is over what the process's material takes for a one-time snap (`strain`: 1.5% PLA, 3% PETG, 2% resin). A short, thick arm with a deep undercut is the usual shape.
+- **Fix:** Lengthen the arm, thin it, or reduce its travel (a shallower undercut; a lead-in chamfer so the snap spreads over more of the stroke). Tapering the arm to half its thickness at the tip lets it bend about 60% further at the same root strain. Switch to PETG where the design is fixed. The formula is a first approximation — a curved or hooked member bends differently — so declare the real bending `thickness` when the mesh misreads it. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Printed parts".
+
+## flex-member-standing
+
+- **Symptom:** A `flexTilt` cost from `verify` under an FDM profile, e.g. `"Arm": 90° off the bed` against `<=45`; or, in use, a snap arm that breaks cleanly along a layer line at its root.
+- **Cause:** In the print pose the member's long axis stands up off the bed, so its layers are stacked across its root; a layer bond is a fraction of the in-plane strength, and bending loads exactly that bond.
+- **Fix:** Pose the piece in `place(..., { purpose: "export" })` so the arm lies along the bed (its root corner then sits within one layer), or split the part so the arm prints flat and joins afterwards. A standing arm the user keeps is a cost they accept (`accept: ["standing"]`): use PETG or anneal, and round the root generously. Resin is isotropic and never reports this. 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.173.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,10 +2,11 @@
 // 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";
+import { flexMembers } from "../oracle/flex-members.js";
 import { suggest } from "../geometry/op-options.js";
 import { PRINT_PROCESSES, PROCESS_IDS, printProcessFor } from "../process/registry.js";
 import { SHEET_DOC_ID } from "../sheet/constants.js";
@@ -447,4 +448,70 @@ 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, a list of labels read as one member, or a member
+    // object `{ feature, labels?, deflection?, thickness? }`. 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 flexing members, each a feature label (`\"Left arm\"`), a list of labels that make one member (`[\"Arm\", \"Arm rib\"]`), or an object `{ feature: \"Arm\", labels?: [...], deflection?: <mm of travel>, thickness?: <mm> }`.";
+      if (!Array.isArray(flex)) {
+        return [err("verify-bad-flex", `\`verify.flex\` is ${describe(flex)}, not a list of flexing members`, form, "verify.flex")];
+      }
+      const label = (l) => typeof l === "string" && l.length > 0;
+      const labels = (ls) => Array.isArray(ls) && ls.length > 0 && ls.every(label);
+      const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+      const out = [];
+      flex.forEach((e, i) => {
+        if (label(e) || labels(e)) return;
+        const at = `verify.flex[${i}]`;
+        if (!e || typeof e !== "object" || Array.isArray(e)) {
+          out.push(err("verify-bad-flex", `\`${at}\` is ${describe(e)}, not a feature label, a list of them or a member object`, form, at));
+          return;
+        }
+        if (!label(e.feature)) out.push(err("verify-bad-flex", `\`${at}.feature\` is ${describe(e.feature)}, not a feature label`, form, `${at}.feature`));
+        if (e.labels !== undefined && !labels(e.labels)) out.push(err("verify-bad-flex", `\`${at}.labels\` is ${describe(e.labels)}, not a list of feature labels`, form, `${at}.labels`));
+        for (const k of ["deflection", "thickness"]) {
+          if (e[k] !== undefined && !num(e[k])) out.push(err("verify-bad-flex", `\`${at}.${k}\` is ${describe(e[k])}, not a positive number of mm`, form, `${at}.${k}`));
+        }
+        for (const k of Object.keys(e)) {
+          if (!["feature", "labels", "deflection", "thickness"].includes(k)) out.push(err("verify-bad-flex", `\`${at}.${k}\` is not a flexing-member field`, form, `${at}.${k}`));
+        }
+      });
+      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) => {
+        const [m] = flexMembers([e]);                                  // a bad shape is verify-bad-flex's
+        for (const l of m?.labels ?? []) {
+          if (seen.has(l)) continue;
+          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/dfm-profiles.js

@@ -109,3 +109,58 @@ export function footprintFor(part, process, { expanded = [] } = {}) {
     Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && "footprintPct" in o));
   return asserted ? DEFAULT_FOOTPRINT : null;
 }
+
+// ── flexing members (`verify.flex`, oracle/flex-root.js) ─────────────────────
+// The root fillet a flexing member needs, as a share of its thickness; the strain its
+// material takes at the root for a one-time snap, in percent; the steepest its long
+// axis may rise off the bed, in degrees. Guide defaults for a part that names no
+// profile — the root rule and the strain rule hold in any material.
+export const DEFAULT_ROOT_FILLET = 0.5;
+export const DEFAULT_STRAIN = 1.5;
+export const DEFAULT_FLEX_TILT = 45;
+
+const orientationOk = (part) => {
+  const orientation = part?.verify?.orientation;
+  if (orientation != null && !ORIENTATIONS.includes(orientation)) {
+    throw new Error(`unknown verify.orientation: ${JSON.stringify(orientation)} (known: ${ORIENTATIONS.join(", ")})`);
+  }
+};
+const asserts = (expanded, metric) => expanded.some(({ expect }) =>
+  Object.entries(expect ?? {}).some(([name, o]) => name !== "_view" && o && typeof o === "object" && metric in o));
+
+// The least root fillet, as a share of the member's thickness, a declared flexing
+// member is held to (a GATE), or null when switched off. Armed by `verify.flex` alone —
+// no profile needed, the rule holds in any material — so with no profile it is the
+// default; the profile's `rootFillet` sets it, `{ base, rootFillet: null }` switches it off.
+export function rootFilletFor(part, process) {
+  orientationOk(part);
+  const spec = process ?? part?.verify?.process;
+  const v = spec ? resolveProfile(spec).rootFillet : undefined;
+  if (v === null) return null;
+  return typeof v === "number" && Number.isFinite(v) ? v : DEFAULT_ROOT_FILLET;
+}
+
+// The largest root strain, in percent, a flexing member may see at its declared
+// deflection (an advisory), or null when switched off. Read for a member that declares
+// a `deflection`, or where the author asserts `flexStrain`; the profile's `strain` sets
+// the limit, the default stands in with no profile, `{ base, strain: null }` switches it off.
+export function strainFor(part, process) {
+  orientationOk(part);
+  const spec = process ?? part?.verify?.process;
+  const v = spec ? resolveProfile(spec).strain : undefined;
+  if (v === null) return null;
+  return typeof v === "number" && Number.isFinite(v) ? v : DEFAULT_STRAIN;
+}
+
+// The steepest a flexing member's long axis may rise off the bed, in degrees, before
+// its layers stack across the root (a COST, `standing`), or null when not checked. Like
+// overhangAngleFor: the PROFILE alone arms it (the FDM profiles carry `flexTilt`; resin
+// is isotropic and carries none), or an authored `flexTilt` expectation, read against
+// the default when the profile has none.
+export function flexTiltFor(part, process, { expanded = [] } = {}) {
+  orientationOk(part);
+  const spec = process ?? part?.verify?.process;
+  const v = spec ? resolveProfile(spec).flexTilt : undefined;
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  return asserts(expanded, "flexTilt") ? DEFAULT_FLEX_TILT : null;
+}

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

@@ -0,0 +1,35 @@
+// src/framework/oracle/flex-members.js
+// The shape of `verify.flex`: the part's flexing members, as declared, normalized to one
+// record each. Import-free and pure — the linter reads it at boot (rules-verify.js's
+// verify-bad-flex and verify-flex-unknown-label), so it must stay a leaf the worker can
+// load eagerly, apart from flex-root.js's reading, which loads with the rest of the
+// oracle on the first inspect job (test/worker-layering.test.js).
+
+/**
+ * The flexing members `verify.flex` declares, one record each: `{ feature, labels,
+ * deflection, thickness }`. An entry is a label, a list of labels read as one member
+ * (named by its first), or an object `{ feature, labels?, deflection?, thickness? }` —
+ * `deflection` the travel in mm the member is designed to flex through (arms the strain
+ * reading), `thickness` its bending thickness in mm when the author knows it better than
+ * the mesh does. A malformed entry is dropped (lint's verify-bad-flex reports it).
+ */
+export function flexMembers(flex) {
+  if (!Array.isArray(flex)) return [];
+  const label = (l) => typeof l === "string" && l.length > 0;
+  const labels = (ls) => Array.isArray(ls) && ls.length > 0 && ls.every(label);
+  const num = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null);
+  const out = [];
+  for (const e of flex) {
+    if (label(e)) out.push({ feature: e, labels: [e], deflection: null, thickness: null });
+    else if (labels(e)) out.push({ feature: e[0], labels: [...e], deflection: null, thickness: null });
+    else if (e && typeof e === "object" && !Array.isArray(e) && label(e.feature)) {
+      out.push({ feature: e.feature, labels: labels(e.labels) ? [...e.labels] : [e.feature],
+        deflection: num(e.deflection), thickness: num(e.thickness) });
+    }
+  }
+  return out;
+}
+
+/** The label groups of `flex`, as measure() stamps them (`measuredFlex`). */
+export const flexGroups = (flex) => flexMembers(flex).map((m) => m.labels);
+

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

@@ -0,0 +1,308 @@
+// src/framework/oracle/flex-root.js
+// A flexing member, read off the mesh: how it meets the rest of its part, how big it is,
+// and how it lies on the print bed.
+//
+// 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 —
+// and the three other ways such a member fails read off the same labelled triangles:
+// too much strain for its length (verify's flexStrain, from a declared deflection),
+// printed standing so the layers stack across its root (flexTilt), and thinner than
+// the process prints (minWall, already).
+//
+// 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).
+//
+// THE ROOT RADIUS. A fillet tangent to the member's face is a circle through the
+// member's boundary (where its label ends), tangent to the face there. A ray from that
+// boundary, parallel to the face and lifted a small ε off it into the air, meets the
+// fillet at the point where the arc has risen ε off the face: the chord from the tangent
+// point to that hit is 2·r·sin(φ/2), and 2·r·(1 − cos φ) = ε, so r = chord² / (2·ε),
+// exact on a circle and read off the member and the air alone — whatever the fillet's
+// tessellation (mesh-fillet starts its arc past an extension sliver on the face plane, so
+// nothing about the first chord row can be trusted), and whatever angle the body meets
+// the member at. A root that continues flush meets nothing: it reads as the ray's reach.
+// A sharp edge is r = 0; the member's radius is a low quantile, by length, of its
+// boundary's readings (a corner patch reads noisily), and 0 wherever ROOT_FLOOR of
+// sharp root exists at all. The rays are few — one per boundary edge, a handful per
+// member — and are tested against the triangles their segments' box reaches, no index.
+//
+// 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.
+//
+// The declaration itself (`verify.flex` → member records) is flex-members.js, a leaf
+// the linter shares; this module is the reading, loaded with the rest of the oracle.
+//
+// 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;
+// 22.5° at mesh-fillet's 16-segment floor for radii under 1 mm, and the boundary edge
+// turns half of one), 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);
+// A concave edge turning less than this (degrees) is flush: a face continuing into the
+// body, not a fillet's first chord. Below it the chord formula divides by ~0.
+export const FLUSH_DEG = 0.25;
+const FLUSH_COS = Math.cos((FLUSH_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 radius reported is the reading this share of the rounded boundary's length sits
+// under — a low quantile, so a noisy corner patch neither sets nor hides it.
+const RADIUS_QUANTILE = 0.1;
+// A root ray is followed this many member thicknesses (at least RAY_MIN mm): a fillet
+// larger than that passes any ratio a profile asks for, and reads as that length.
+const RAY_REACH = 10, RAY_MIN = 2;
+// The ray's lift off the member's face, as a share of its thickness (at least LIFT_MIN
+// mm): small against any fillet worth having, large against a chord's sagitta.
+const LIFT = 0.05, LIFT_MIN = 0.02;
+// Hits closer than this (mm) are the ray's own edge.
+const HIT_EPS = 1e-4;
+
+// Möller–Trumbore: the distance along the ray (o, d) to triangle (a, b, c), or null.
+function rayTri(P, o, d, a, b, c) {
+  const e1x = P[b * 3] - P[a * 3], e1y = P[b * 3 + 1] - P[a * 3 + 1], e1z = P[b * 3 + 2] - P[a * 3 + 2];
+  const e2x = P[c * 3] - P[a * 3], e2y = P[c * 3 + 1] - P[a * 3 + 1], e2z = P[c * 3 + 2] - P[a * 3 + 2];
+  const px = d[1] * e2z - d[2] * e2y, py = d[2] * e2x - d[0] * e2z, pz = d[0] * e2y - d[1] * e2x;
+  const det = e1x * px + e1y * py + e1z * pz;
+  if (Math.abs(det) < 1e-12) return null;
+  const inv = 1 / det;
+  const tx = o[0] - P[a * 3], ty = o[1] - P[a * 3 + 1], tz = o[2] - P[a * 3 + 2];
+  const u = (tx * px + ty * py + tz * pz) * inv;
+  if (u < -1e-9 || u > 1 + 1e-9) return null;
+  const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+  const v = (d[0] * qx + d[1] * qy + d[2] * qz) * inv;
+  if (v < -1e-9 || u + v > 1 + 1e-9) return null;
+  const t = (e2x * qx + e2y * qy + e2z * qz) * inv;
+  return t > HIT_EPS ? t : null;
+}
+
+// The eigenvectors of a symmetric 3×3 (cyclic Jacobi), columns of `v`, with the
+// eigenvalues in `w` — a handful of sweeps on a 3×3 converges to machine precision.
+function eigen3(m) {
+  const a = m.map((r) => r.slice());
+  const v = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+  for (let sweep = 0; sweep < 32; sweep++) {
+    let off = 0;
+    for (let p = 0; p < 3; p++) for (let q = p + 1; q < 3; q++) off += a[p][q] * a[p][q];
+    if (off < 1e-24) break;
+    for (let p = 0; p < 3; p++) for (let q = p + 1; q < 3; q++) {
+      if (Math.abs(a[p][q]) < 1e-300) continue;
+      const theta = (a[q][q] - a[p][p]) / (2 * a[p][q]);
+      const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+      const c = 1 / Math.sqrt(t * t + 1), s = t * c;
+      for (let k = 0; k < 3; k++) {
+        const akp = a[k][p], akq = a[k][q];
+        a[k][p] = c * akp - s * akq; a[k][q] = s * akp + c * akq;
+      }
+      for (let k = 0; k < 3; k++) {
+        const apk = a[p][k], aqk = a[q][k];
+        a[p][k] = c * apk - s * aqk; a[q][k] = s * apk + c * aqk;
+      }
+      for (let k = 0; k < 3; k++) {
+        const vkp = v[k][p], vkq = v[k][q];
+        v[k][p] = c * vkp - s * vkq; v[k][q] = s * vkp + c * vkq;
+      }
+    }
+  }
+  return { w: [a[0][0], a[1][1], a[2][2]], v };
+}
+
+// The member's size along its own axes: the principal axes of its vertices, and the
+// extent of the vertices along each — `length` the largest, `thickness` the smallest
+// (the direction a cantilever bends in), `axis` the unit direction of the largest.
+function extents(P, verts) {
+  const n = verts.length;
+  if (n < 3) return { length: 0, thickness: 0, axis: null };
+  const c = [0, 0, 0];
+  for (const i of verts) for (let k = 0; k < 3; k++) c[k] += P[i * 3 + k] / n;
+  const cov = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+  for (const i of verts) {
+    const d = [P[i * 3] - c[0], P[i * 3 + 1] - c[1], P[i * 3 + 2] - c[2]];
+    for (let r = 0; r < 3; r++) for (let s = 0; s < 3; s++) cov[r][s] += d[r] * d[s];
+  }
+  const { w, v } = eigen3(cov);
+  const order = [0, 1, 2].sort((i, j) => w[j] - w[i]);
+  const ext = order.map((col) => {
+    const ax = [v[0][col], v[1][col], v[2][col]];
+    let lo = Infinity, hi = -Infinity;
+    for (const i of verts) {
+      const s = ax[0] * P[i * 3] + ax[1] * P[i * 3 + 1] + ax[2] * P[i * 3 + 2];
+      if (s < lo) lo = s;
+      if (s > hi) hi = s;
+    }
+    return { ax, size: hi - lo };
+  });
+  return { length: ext[0].size, thickness: ext[2].size, axis: ext[0].ax };
+}
+
+/**
+ * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, featureIds?: ArrayLike<number>, features?: string[] }} mesh
+ * @param {string[]} group the labels making up one flexing member
+ * @param {{ printMatrix?: number[]|null }} [opts] the display→print mat4 (column-major,
+ *   pose.js) the member is posed by for `tilt`; null when the display pose is the print pose
+ * @returns {{ found: boolean, attached: boolean, sharpLength: number, maxTurn: number|null, at: number[]|null,
+ *   rootRadius: number|null, thickness: number, length: number, axis: number[]|null, tilt: 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);
+ *   `rootRadius` the root's fillet radius in mm — 0 when any of it is sharp, null when
+ *   the member meets the body flush everywhere (no inside corner at all);
+ *   `thickness`, `length`, `axis` the member's own extents and long direction;
+ *   `tilt` the degrees that direction rises off the print bed (0 lying flat, 90
+ *   standing), in the print pose.
+ */
+export function flexRoot(mesh, group, { printMatrix = null } = {}) {
+  const { positions: P, indices: I, featureIds, features } = mesh;
+  const none = { found: false, attached: false, sharpLength: 0, maxTurn: null, at: null, rootRadius: null, thickness: 0, length: 0, axis: null, tilt: null };
+  const ids = new Set();
+  if (featureIds && features) features.forEach((f, i) => { if (group.includes(f)) ids.add(i + 1); });
+  if (!ids.size) return none;
+  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, areas 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), area2 = new Float64Array(nTri);
+  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;
+    area2[t] = len;                                               // twice the area
+    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. The member's welded vertices feed its extents.
+  const keys = [];
+  const memberVerts = new Map();                                  // welded key -> index
+  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++) {
+      if (!memberVerts.has(keys[t][j])) memberVerts.set(keys[t][j], v[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;
+  const starts = [];                                              // rounded boundary edges: a root ray each
+  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];
+    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. Flush (the
+    // face continuing into the body, or mesh-fillet's extension sliver on it) is neither.
+    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);
+    const flush = d > FLUSH_COS;
+    if (!flush && 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]);
+    if (!(len > 0)) continue;
+    if (flush || d > SHARP_COS) {                                 // rounded or flush: a root ray
+      const tm = inMember(t1) ? t1 : t2;
+      const nm = [normal[tm * 3], normal[tm * 3 + 1], normal[tm * 3 + 2]];
+      // In the member face's plane, perpendicular to the edge, away from the member:
+      // n × e, flipped if it points at the triangle's own centroid.
+      const ex = (P[e.b * 3] - P[e.a * 3]) / len, ey = (P[e.b * 3 + 1] - P[e.a * 3 + 1]) / len, ez = (P[e.b * 3 + 2] - P[e.a * 3 + 2]) / len;
+      let dx = nm[1] * ez - nm[2] * ey, dy = nm[2] * ex - nm[0] * ez, dz = nm[0] * ey - nm[1] * ex;
+      if (dx * (cent[tm * 3] - mx) + dy * (cent[tm * 3 + 1] - my) + dz * (cent[tm * 3 + 2] - mz) > 0) { dx = -dx; dy = -dy; dz = -dz; }
+      starts.push({ o: [mx, my, mz], d: [dx, dy, dz], n: nm, len });
+      continue;
+    }
+    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]; }
+  }
+  const size = extents(P, [...memberVerts.values()]);
+  let tilt = null;
+  if (size.axis) {
+    const [x, y, z] = size.axis, m = printMatrix;
+    const pz = m ? m[2] * x + m[6] * y + m[10] * z : z;
+    tilt = (Math.asin(Math.min(1, Math.abs(pz))) * 180) / Math.PI;
+  }
+  const base = { found: true, attached, thickness: size.thickness, length: size.length, axis: size.axis, tilt };
+  if (!attached) return { ...base, sharpLength: 0, maxTurn: null, at: null, rootRadius: null };
+  if (sharpLength >= ROOT_FLOOR) return { ...base, sharpLength, maxTurn, at, rootRadius: 0 };
+  let rootRadius = null;
+  if (starts.length) {
+    const reach = Math.max(RAY_REACH * size.thickness, RAY_MIN);
+    const lift = Math.max(LIFT * size.thickness, LIFT_MIN);
+    // The non-member triangles any ray's segment box reaches, gathered once.
+    const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+    for (const { o, d, n } of starts) for (let k = 0; k < 3; k++) {
+      const a = o[k] + n[k] * lift;
+      lo[k] = Math.min(lo[k], a, a + d[k] * reach); hi[k] = Math.max(hi[k], a, a + d[k] * reach);
+    }
+    const near = [];
+    for (let t = 0; t < nTri; t++) {
+      if (inMember(t)) continue;
+      const [a, b, c] = tri(t);
+      let out = false;
+      for (let k = 0; k < 3 && !out; k++) {
+        const x = Math.min(P[a * 3 + k], P[b * 3 + k], P[c * 3 + k]), y = Math.max(P[a * 3 + k], P[b * 3 + k], P[c * 3 + k]);
+        out = y < lo[k] - 1e-6 || x > hi[k] + 1e-6;
+      }
+      if (!out) near.push(t);
+    }
+    const readings = [];                                          // [radius, length]
+    for (const { o, d, n, len } of starts) {
+      const origin = [o[0] + n[0] * lift, o[1] + n[1] * lift, o[2] + n[2] * lift];
+      let best = Infinity;
+      for (const t of near) {
+        const [a, b, c] = tri(t);
+        const dist = rayTri(P, origin, d, a, b, c);
+        if (dist != null && dist < best) best = dist;
+      }
+      // chord² = s² + lift², and 2·r·lift = chord² on the circle tangent at the boundary.
+      readings.push([best > reach ? reach : Math.min(reach, (best * best + lift * lift) / (2 * lift)), len]);
+    }
+    readings.sort((p, q) => p[0] - q[0]);
+    const total = readings.reduce((s, [, l]) => s + l, 0);
+    let acc = 0;
+    for (const [r, l] of readings) { acc += l; rootRadius = r; if (acc >= RADIUS_QUANTILE * total) break; }
+  }
+  return { ...base, sharpLength: 0, maxTurn: null, at: null, rootRadius };
+}

package/src/framework/oracle/measure.js

@@ -14,6 +14,8 @@ 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 } from "./flex-root.js";
+import { flexMembers } from "./flex-members.js";
 import { partBedContact, partFootprint, partGatesMinWall, partHasBed, partOverhangAngle, partWallBands } from "./gates.js";
 import { summarizeContours } from "./shape-probe.js";
 
@@ -320,6 +322,16 @@ 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 members = flexMembers(opts.flex !== undefined ? opts.flex : part.verify?.flex);
+  const flex = members.map((m) => m.labels);
+  // A flexing member is read in its print pose too (its tilt off the bed), so the pose
+  // is resolved whenever one is declared, as it is for the underside readings.
+  const posed = underside || members.length > 0;
   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
@@ -332,7 +344,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // The overhang reading poses each piece for print (printPoseOverhang), which reads the
   // resolved params through place() — recorded into the same sink, since the reading
   // depends on them.
-  const poseParams = underside ? (sheetParams ?? resolveParams(part, params, undefined, reads)) : null;
+  const poseParams = posed ? (sheetParams ?? resolveParams(part, params, undefined, reads)) : null;
   // The print-pose sizes are read by one check, the process bed (verify passes whether
   // its profile has one; alone, measure asks the part's own profile), and each costs a
   // second build of the part — so they are built only for a bed.
@@ -348,7 +360,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // (printPoseOverhang) is read off place() with the resolved params — geometry-free,
     // so it is resolved here, ahead of the memo, which must key on it.
     const printed = part.parts[name]?.exportable !== false && !sheet;
-    const printPose = underside && printed && poseParams?.p
+    const printPose = posed && printed && poseParams?.p
       ? displayToPrintPose(part.parts[name], { view, p: poseParams.p, d: poseParams.d })
       : null;
     const printMatrix = printPose?.matrix ?? null;
@@ -372,7 +384,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 +483,17 @@ 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: members.length && !sheet
+        ? members.map((m) => {
+          const r = flexRoot(mesh, m.labels, { printMatrix });
+          // A pose the probes could not read is not the display pose: no tilt to report.
+          return { feature: m.feature, labels: m.labels, ...r, ...(printPose && !printPose.trusted ? { tilt: null } : {}) };
+        }).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 +585,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 { resolveProfile, overhangAngleFor, bedContactFor, footprintFor } from "./dfm-profiles.js";
+import { flexMembers } from "./flex-members.js";
+import { resolveProfile, overhangAngleFor, bedContactFor, footprintFor, rootFilletFor, strainFor, flexTiltFor } 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, worstFlexRoot } 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", "flexStrain", "flexTilt"]);
+const PRINT_ONLY_HINT = "minWall, wall, overhangArea, bedContactPct, footprintPct, flexRoot, flexStrain and flexTilt 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,11 @@ 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 = [] }) {
+// `flex` the declared flexing members (flex-root.js flexMembers), `rootFillet` the
+// share of a member's thickness its root fillet must reach (null: off), `strain` the
+// percent root strain allowed at a member's declared deflection (null: off), `flexTilt`
+// the degrees a member's axis may rise off the bed (null: not checked).
+export function evaluateCase(facts, { profile, expect, subPartNames, exportableNames, overhang = null, bedContact = null, footprint = null, accept = [], flex = [], rootFillet = null, strain = null, flexTilt = null }) {
   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.
@@ -321,8 +329,27 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
         message: `not measured: its print (export) pose did not build — ${s.printBboxError}`,
         hint: "build() should make each piece as it prints — a printed piece shown in an assembly gets its assembled pose from its `views` entry, never from build(). Its export pose failed to build, so its print size — and its STL/3MF export — is unavailable. Fix the pose; the bed check then runs." });
     }
+    // The flexing members this sub-part carries, each stamped with what verify asks of
+    // it: the root radius it needs (the process's share of its thickness — declared over
+    // measured) and, from a declared deflection, its root strain. The registry's worst-
+    // member pickers read these stamps, so the row's expr names that member's need.
+    const flexEval = (s.flexRoots ?? []).map((r) => {
+      const m = flex.find((x) => sameGroup(x.labels, r.labels));
+      const t = m?.thickness ?? r.thickness;
+      return { ...r, thicknessUsed: t,
+        required: rootFillet != null ? rootFillet * t : null,
+        deflection: m?.deflection ?? null,
+        strain: m?.deflection != null && r.length > 0 ? (100 * 1.5 * t * m.deflection) / (r.length * r.length) : null };
+    });
+    const sf = flexEval.length ? { ...s, flexRoots: flexEval } : s;
+    const worstRoot = rootFillet != null ? worstFlexRoot(sf) : null;
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
+      ...(worstRoot ? { flexRoot: `>=${Math.round(worstRoot.required * 100) / 100}` } : {}),
+      ...(strain != null && flexEval.some((r) => r.strain != null) ? { flexStrain: `<=${strain}` } : {}),
+      // A member whose print pose could not be read has no tilt: the row then skips
+      // "unavailable" rather than vanishing, so the cost is seen to be unread.
+      ...(flexTilt != null && flexEval.some((r) => r.attached) ? { flexTilt: `<=${flexTilt}` } : {}),
       ...(overhang != null ? { overhangArea: "<=1" } : {}),
       ...(bedContact != null && (!printedNames || printedNames.has(s.name)) ? { bedContactPct: `>=${bedContact}` } : {}),
       ...(footprint != null && (!printedNames || printedNames.has(s.name)) ? { footprintPct: `>=${footprint}` } : {}),
@@ -332,7 +359,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, exportableN
     // wrote in `expect` is the user's own limit and keeps its meaning, never accepted.
     const authored = expect?.[s.name] ?? {};
     const acceptFor = (metric) => (Object.hasOwn(authored, metric) ? [] : accept);
-    for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, s, acceptFor(metric))) {
+    for (const [metric, expr] of Object.entries(merged)) for (const c of checksFor("subpart", s.name, metric, expr, SUBPART_METRICS, sf, acceptFor(metric))) {
       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"}` });
@@ -363,9 +390,47 @@ 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 { feature, labels: g } of flex) {
+    const base = { scope: "subpart", metric: "flexRoot", kind: "gate", feature, expr: "rounded root", 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 +456,10 @@ 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 = flexMembers(part?.verify?.flex);
+  const rootFillet = flex.length ? rootFilletFor(part, process) : null;
+  const strainLimit = flex.length ? strainFor(part, process) : null;
+  const flexTilt = flexTiltFor(part, process, { expanded });
   // 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 +533,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(({ labels }) => (seed?.result?.measuredFlex ?? []).some((m) => sameGroup(m, labels)));
+  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 +549,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 +570,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, rootFillet, strain: strainLimit, flexTilt }) : 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 +605,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/process/fdm/descriptor.js

@@ -23,6 +23,16 @@
 // `footprint` is the percent of a printed piece's posed base area resting on the
 // bed below which the footprint cost fires.
 //
+// A flexing member (`verify.flex`, oracle/flex-root.js) reads three more: `rootFillet`
+// is the least root fillet radius as a share of the member's thickness (a GATE, 0.5
+// from every snap-fit guide; the stress riser is the same in any material, so resin
+// carries it too); `strain` the largest root strain, in percent, the material takes
+// for a one-time snap (an advisory, read from a declared deflection: PLA is brittle,
+// PETG forgiving); `flexTilt` the steepest the member's long axis may rise off the bed,
+// in degrees, before its layers stack across the root (a COST, `standing`: the layer
+// bond is a fraction of the in-plane strength, so a standing arm snaps along a layer;
+// resin is isotropic and carries none).
+//
 // Import-free, like every process descriptor: lint and the oracle read it through
 // process/registry.js.
 export const FDM = {
@@ -35,14 +45,16 @@ export const FDM = {
       bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45, bedContact: 50, footprint: 10,
       fits: { press: -0.1, push: 0.05, slip: 0.25, moving: 0.35, printInPlace: 0.45 },
       holeUndersize: 0.25, bridge: 10,
+      rootFillet: 0.5, strain: 1.5, flexTilt: 45,
     },
     "fdm-petg": {
       bed: [220, 220, 250], minWall: 1.5, clearance: 0.3, overhang: 45, bedContact: 50, footprint: 10,
       fits: { press: -0.1, push: 0.05, slip: 0.3, moving: 0.4, printInPlace: 0.5 },
       holeUndersize: 0.3, bridge: 10,
+      rootFillet: 0.5, strain: 3, flexTilt: 45,
     },
   },
-  costs: { supports: "overhangArea", footprint: "footprintPct" },
+  costs: { supports: "overhangArea", footprint: "footprintPct", standing: "flexTilt" },
   metrics: {},
   lintRules: [],
 };

package/src/framework/process/resin/descriptor.js

@@ -1,6 +1,7 @@
 // Resin printing as DATA: see process/fdm/descriptor.js for what each profile field
 // means. Resin prints on supports, so it carries no overhang, bedContact, footprint
-// or bridge, and no costs. Import-free, like every process descriptor.
+// or bridge, and no costs; it is isotropic, so no flexTilt either. A flexing member's
+// root fillet and strain apply in any material. Import-free, like every process descriptor.
 export const RESIN = {
   id: "resin",
   label: "Resin 3D printing",
@@ -11,6 +12,7 @@ export const RESIN = {
       bed: [120, 68, 160], minWall: 0.6, clearance: 0.1,
       fits: { press: -0.05, push: 0.05, slip: 0.1, moving: 0.15, printInPlace: 0.2 },
       holeUndersize: 0.05,
+      rootFillet: 0.5, strain: 2,
     },
   },
   costs: {},

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,30 @@ export function sidesSpecError(metric, reg, spec) {
   return null;
 }
 
+// The flexing-member readings (oracle/flex-root.js, `verify.flex`): what each 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 through too small a root fillet, or none — bending concentrates the stress at that corner and the member snaps off at its root. Round the root to at least the process's share of the member's thickness (half, on every built-in profile): `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\"]]`";
+export const FLEX_STRAIN_HINT = "at its declared deflection this member's root strain (1.5 × thickness × deflection / length², a straight cantilever) is over what the material takes for a one-time snap — it yields or cracks at the root. Lengthen the member, thin it, or reduce its travel (a shallower undercut, a lead-in that spreads the snap over more of the stroke); a member tapered to half its thickness at the tip bends ~60% further at the same root strain. If the mesh misreads its bending thickness, declare it: `flex: [{ feature, deflection, thickness }]`";
+export const FLEX_TILT_HINT = "this member's long axis stands up off the bed in the print pose, so its layers stack across its root — and a layer bond is a fraction of the in-plane strength, so it snaps along a layer line. Lay the member flat: pose the piece in `place(..., { purpose: \"export\" })` so the arm lies along the bed (its root corner then sits in one layer), or split the part so the arm prints flat; a standing arm the user keeps is a cost (`accept: [\"standing\"]`) — use PETG or anneal, and round the root generously";
+// The flexing member a sub-part's row answers for: the one whose root is worst (least
+// radius over what it needs — `required`, stamped by verify from the profile's share of
+// its thickness), among those that meet the rest of the sub-part and have a corner to
+// read; null when none does. Exported for verify, whose expr must name that member's need.
+export const worstFlexRoot = (s) => (s.flexRoots ?? []).filter((r) => r.attached && r.rootRadius != null)
+  .reduce((w, r) => (w == null || (r.required ?? 1) > 0 && r.rootRadius / (r.required ?? 1) < w.rootRadius / (w.required ?? 1) ? r : w), null);
+const worstFlexStrain = (s) => (s.flexRoots ?? []).filter((r) => r.strain != null)
+  .reduce((w, r) => (w == null || r.strain > w.strain ? r : w), null);
+const worstFlexTilt = (s) => (s.flexRoots ?? []).filter((r) => r.attached && r.tilt != null)
+  .reduce((w, r) => (w == null || r.tilt > w.tilt ? r : w), null);
+const mm = (v) => Math.round(v * 100) / 100;
+const memberLine = (r) => {
+  if (!r.attached) return "never meets the rest of this sub-part";
+  if (r.rootRadius === 0) return `sharp root (${Math.round(r.maxTurn)}°, ${r.sharpLength.toFixed(1)} mm of corner)`;
+  if (r.rootRadius == null) return "no inside corner at its root";
+  const need = r.required != null ? `, needs ≥ ${mm(r.required)} (${mm(r.thicknessUsed ?? r.thickness)} mm thick)` : "";
+  return `root radius ${mm(r.rootRadius)} mm${need}`;
+};
+
 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 +159,51 @@ 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`): its fillet
+  // radius in mm, 0 where it is sharp. One row per sub-part, like every print metric:
+  // `actual` is the WORST member's reading (least radius over what it needs), `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) => { const w = worstFlexRoot(s); return w ? mm(w.rootRadius) : 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 ?? [];
+      return rows.length ? rows.map((r) => `"${r.feature}": ${memberLine(r)}`).join("; ") : null;
+    } },
+  // A declared flexing member's root strain at its declared deflection, in percent
+  // (verify stamps `strain` from the member's measured length and thickness — 1.5·t·y/L²,
+  // a straight cantilever). The worst member per sub-part. An ADVISORY: the formula is a
+  // first approximation (a taper, a curve or a hook changes it), read against the
+  // process's `strain`.
+  flexStrain: { kind: "warn", extract: (s) => { const w = worstFlexStrain(s); return w ? Math.round(w.strain * 100) / 100 : null; },
+    hint: FLEX_STRAIN_HINT,
+    pattern: "flex-strain-over",
+    feature: (s) => worstFlexStrain(s)?.feature ?? null,
+    note: (s) => {
+      const rows = (s.flexRoots ?? []).filter((r) => r.strain != null);
+      return rows.length ? rows.map((r) => `"${r.feature}": ${(Math.round(r.strain * 100) / 100).toFixed(2)}% at ${r.deflection} mm (${mm(r.length)} mm long, ${mm(r.thicknessUsed ?? r.thickness)} mm thick)`).join("; ") : null;
+    } },
+  // How far a declared flexing member's long axis rises off the bed in the print pose,
+  // in degrees (0 lying flat, 90 standing) — the worst member per sub-part. A COST
+  // (`standing`), armed by an FDM profile's `flexTilt`: an arm the user prints standing is
+  // a choice with a price, not a defect, and resin (isotropic) never asks.
+  flexTilt: { kind: "cost", costId: "standing", extract: (s) => { const w = worstFlexTilt(s); return w ? Math.round(w.tilt * 10) / 10 : null; },
+    hint: FLEX_TILT_HINT,
+    pattern: "flex-member-standing",
+    feature: (s) => worstFlexTilt(s)?.feature ?? null,
+    note: (s) => {
+      const rows = (s.flexRoots ?? []).filter((r) => r.attached && r.tilt != null);
+      return rows.length ? rows.map((r) => `"${r.feature}": ${Math.round(r.tilt)}° off the bed`).join("; ") : null;
+    } },
   // `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

@@ -510,6 +510,24 @@ export interface DfmProfile {
   holeUndersize?: number;
   /** Longest flat span printed unsupported, mm. Absent on a process that prints on supports. */
   bridge?: number;
+  /**
+   * The least root fillet a flexing member (`verify.flex`) must meet its body through,
+   * as a share of the member's thickness (0.5 on every built-in profile) — a GATE,
+   * armed by `verify.flex` alone; `null` switches it off under a named base.
+   */
+  rootFillet?: number | null;
+  /**
+   * The largest root strain, in percent, the material takes for a one-time snap (1.5 on
+   * PLA, 3 on PETG, 2 on resin) — an advisory, read for a flexing member that declares
+   * a `deflection`; `null` switches it off under a named base.
+   */
+  strain?: number | null;
+  /**
+   * The steepest a flexing member's long axis may rise off the bed in the print pose, in
+   * degrees (45 on the FDM profiles; absent on resin, which is isotropic), before its
+   * layers stack across the root. A cost (`standing`), armed by the profile alone.
+   */
+  flexTilt?: number | null;
   /** Inherit from a named profile and override the rest. */
   base?: DfmProfileName | DfmProfile;
 }
@@ -581,6 +599,25 @@ export interface SubPartExpectations {
    * a cost (`verify.costs`), never a failure; `accept: ["footprint"]` records a brim.
    */
   footprintPct?: Expectation;
+  /**
+   * The root fillet radius (mm, 0 where sharp) of the flexing member named in
+   * `verify.flex` whose root is worst on this sub-part — `feature` names it. Every
+   * sub-part carrying a declared member gets `>=` the profile's share of the member's
+   * thickness by default; a gate.
+   */
+  flexRoot?: Expectation;
+  /**
+   * Root strain (%) of the worst declared flexing member on this sub-part at its declared
+   * deflection — 1.5 × thickness × deflection / length², a straight cantilever. Under a
+   * profile every member with a `deflection` gets `<=` the profile's `strain`; a warning.
+   */
+  flexStrain?: Expectation;
+  /**
+   * Degrees the worst declared flexing member's long axis rises off the bed in the
+   * print pose (0 lying flat, 90 standing). Under an FDM profile every member gets
+   * `<=45`; reported as a cost (`standing`), never a failure.
+   */
+  flexTilt?: 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. */
@@ -659,7 +696,19 @@ export interface VerifyBlock<P = ResolvedParams, D = Derived> {
    * process's own default check is marked accepted: a limit you wrote in `expect`
    * (`overhangArea: "<=500"`) keeps its meaning and is never marked accepted.
    */
-  accept?: ("supports" | "footprint")[];
+  accept?: ("supports" | "footprint" | "standing")[];
+  /**
+   * 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 root fillet of at
+   * least the process's share of its thickness (`flexRoot`, a gate); one that declares
+   * its `deflection` (mm of travel) is also read for root strain (`flexStrain`, an
+   * advisory), and under an FDM profile every member is read for how far it stands up
+   * off the bed (`flexTilt`, the `standing` cost). An entry is a label, a list of labels
+   * that make one member (an arm and the rib on it), or a member object; `thickness`
+   * (mm) overrides the bending thickness the mesh reads. Label the member apart from
+   * the body it grows from.
+   */
+  flex?: (string | string[] | { feature: string; labels?: string[]; deflection?: number; thickness?: number })[];
   /** Which cases to check; default is `"defaults"` plus every preset name. */
   cases?: string[];
   /**

package/types/testing.d.ts

@@ -441,6 +441,22 @@ 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;
+    /** The root's fillet radius in mm: 0 where sharp, `null` where the member meets the body flush everywhere. */
+    rootRadius: number | null;
+    /** The member's own extents (mm) along its principal axes, and the unit direction of the longest. */
+    thickness: number; length: number; axis: number[] | null;
+    /** Degrees the long axis rises off the bed in the print pose; `null` when that pose could not be read. */
+    tilt: 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.