partforge 0.172.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), 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 |
+| **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
@@ -2018,12 +2018,20 @@ 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).
+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:
@@ -2033,18 +2041,41 @@ 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: {
+  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: { … },
+},
 ```
 
-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.
+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
 
@@ -4468,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
@@ -4567,16 +4599,25 @@ 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
+**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
@@ -4603,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`, `flexRoot`, `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

@@ -236,9 +236,21 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 
 ## 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".
+- **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
 

package/package.json

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

@@ -6,6 +6,7 @@ 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";
@@ -449,21 +450,36 @@ export const VERIFY_RULES = [
   },
   {
     // `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.
+    // 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 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\"]`).";
+      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 feature labels`, form, "verify.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) || (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}]`));
+        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;
     },
@@ -485,8 +501,9 @@ export const VERIFY_RULES = [
       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 [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`,

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

@@ -1,5 +1,6 @@
 // src/framework/oracle/flex-root.js
-// Whether a flexing member meets the rest of its part through a rounded root.
+// 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
@@ -7,7 +8,11 @@
 // 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.
+// 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
@@ -20,10 +25,27 @@
 // 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
@@ -34,45 +56,139 @@
 // 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.
+// 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;
 
-/** 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));
+// 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 name a member group is reported under: its first label. */
-export const groupName = (group) => group[0];
+// 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
- * @returns {{ found: boolean, attached: boolean, sharpLength: number, maxTurn: number|null, at: number[]|null }}
+ * @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).
+ *   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) {
+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 { found: false, attached: false, sharpLength: 0, maxTurn: null, at: null };
+  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 and centroids, and every edge of a member triangle, keyed by welded endpoints.
+  // 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);
+  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++) {
@@ -81,17 +197,20 @@ export function flexRoot(mesh, group) {
     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.
+  // 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: [] });
@@ -106,23 +225,84 @@ export function flexRoot(mesh, group) {
   }
 
   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];
-    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.
+    // 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);
-    if (front <= 1e-9) continue;                                  // convex: an outside edge
+    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]; }
   }
-  if (!attached || sharpLength < ROOT_FLOOR) return { found: true, attached, sharpLength: 0, maxTurn: null, at: null };
-  return { found: true, attached, sharpLength, maxTurn, at };
+  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,7 +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, flexGroups, groupName } from "./flex-root.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";
 
@@ -326,7 +327,11 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // 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 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
@@ -339,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.
@@ -355,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;
@@ -482,8 +487,12 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       // 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)
+      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

package/src/framework/oracle/verify.js

@@ -2,11 +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 { 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, FLEX_ROOT_HINT } 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.
@@ -219,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", "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.";
+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
@@ -282,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 = [] }) {
+// `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.
@@ -325,21 +329,37 @@ 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}` } : {}),
-      // 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
     // 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"}` });
@@ -388,9 +408,8 @@ 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 };
+  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" });
@@ -437,7 +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 = flexGroups(part?.verify?.flex);
+  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
@@ -512,7 +534,7 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   const needPrintBboxes = profile?.bed != null;
   const printBboxesMatch = !needPrintBboxes || seed?.result?.measuredPrintBboxes !== false;
   // 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)));
+  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 });
@@ -548,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, flex }) : 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

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

@@ -66,12 +66,29 @@ 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);
+// 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,
@@ -142,16 +159,16 @@ 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,
+  // 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,
@@ -160,8 +177,32 @@ export const SUBPART_METRICS = {
     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("; ");
+      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

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;
 }
@@ -582,11 +600,24 @@ export interface SubPartExpectations {
    */
   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.
+   * 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. */
@@ -665,16 +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 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.
+   * 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[])[];
+  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

@@ -447,7 +447,16 @@ export interface SubPartFacts {
    * 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;
+  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.