@rig-c/parts 1.15.0 → 1.17.0

package/src/check.ts

@@ -59,7 +59,10 @@
  * missing from both. When `motion.json` holds an animation, one more bar,
  * `ANIMATIONS_DO_NOT_FOLD` (issues #320, #333): rigc's own `render --folds`
  * over every animation, the idle included, physics constraints left out
- * ({@link FOLD_LINE}). The part-alone renders, the shut-eye still, the keyed
+ * ({@link FOLD_LINE}). Beside it, where a `footwear` part rides a bone that
+ * hangs from another, `FEET_STAY_LEVEL` (issue #348): the same render, with
+ * `--geometry`, read for how far each such part's drawing turns while a bone
+ * above it is turned ({@link LEVEL_LINE}). The part-alone renders, the shut-eye still, the keyed
  * build and the fold render are scratch (`_isolated/`, `_still/`, `_loop/`,
  * `_folds/`), removed before the stage returns.
  *
@@ -77,7 +80,7 @@
 import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { basename, delimiter, dirname, join, resolve } from 'node:path';
 import { measureRecomposite, type RecompositeFigures, recompositeRecord, scenePhrase, sourceInRig } from './assemble.ts';
-import { cropToSpineY } from './coords.ts';
+import { cropToSpineY, normaliseDegrees } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { framesInside, IDLE_FPS, TIME_SLACK } from './motion.ts';
 import {
@@ -108,6 +111,7 @@ import {
   setupToFrame,
   stillReading,
   stillTolerance,
+  type StretchAt,
   stretchFigures,
   stretchSeverity,
   sweptBox,
@@ -120,6 +124,7 @@ import {
   type WorldBox,
 } from './instruments.ts';
 import { type PartRecord, type PartsFile, readParts } from './parts.ts';
+import { turnTwin } from './turn.ts';
 import {
   aimLine,
   contactLine,
@@ -148,6 +153,7 @@ import {
   type SeamPair,
   stretchRequirementLine,
 } from './requirements.ts';
+import { RIG_BONE_INHERIT } from 'rig-c/src/rig.ts';
 import { alphaComposite } from './raster/composite.ts';
 import { readPng, writePng } from './raster/png.ts';
 import { newFloatImage, newRaster, type Raster } from './raster/types.ts';
@@ -1717,6 +1723,12 @@ export interface CheckFigures {
   TEXTURE_STRETCH: JudgementLine;
   /** Written whenever motion.json holds an animation, the idle included (issues #320, #333): {@link FoldsLine}. */
   [FOLD_LINE]?: FoldsLine;
+  /** Written only where a `footwear` part rides a bone with a parent and motion.json holds an animation (issue #348): {@link LevelLine}. */
+  [LEVEL_LINE]?: LevelLine;
+  /** Written whenever parts.json names a `handwear` part and the motion has an idle (issue #347): {@link STRESS_LINE}. */
+  [STRESS_LINE]?: JudgementLine;
+  /** Written only where parts.json holds a part a `config.limbs` segment made (issue #349): {@link LimbLine}. */
+  [LIMB_LINE]?: LimbLine;
   RECOMPOSITE_HOLES: ReportedLine;
   /** Written only under `--source` (issue #77): the setup pose against the painting, REPORTED. */
   SETUP_POSE_VS_SOURCE?: ReportedLine;
@@ -1768,15 +1780,97 @@ export interface RequirementsBlock {
  */
 export const FOLD_LINE = 'ANIMATIONS_DO_NOT_FOLD';
 
+/**
+ * The bar over every animation, the idle included, for a `footwear` part that
+ * rides a bone hanging from another (issue #348): while a bone above the
+ * part's bone is turned, the part's drawing stays within
+ * {@link LEVEL_BAR_DEGREES} of its setup pose.
+ *
+ * ⭐ **What the rig declares, and nothing else.** The feet are the parts
+ * parts.json says come from a See-through `footwear` layer (the feet
+ * `BREATH_VISIBLE` and `STILL_REGIONS_DARK` read); each one's bone is the bone
+ * rig.json's slot of the same name sits on, and "the shin" is whatever bone
+ * that bone hangs from, read off rig.json's `parent` — nothing here knows a
+ * foot or a shin by name. A part on a bone with no parent (`root`, as on every
+ * public example) hangs from nothing, so it is not read; a rig with no such
+ * part, or no animation, writes no line, and its check.json keeps the keys it
+ * always had.
+ *
+ * - **Posed**: a frame on which some bone above the part's bone — its parent,
+ *   or any bone over that up to the root — has a world rotation other than
+ *   its setup pose's, read off the `geometry.json` rig-c's render writes. The
+ *   nearest such bone is named, with its turn. No threshold: a frame is posed
+ *   or it is not.
+ * - **The sole's angle**: the part's drawing has no sole a program can find,
+ *   so what is held is the drawing itself — the turn of the least-squares
+ *   rotation carrying its setup-pose vertices onto the frame's, both centred,
+ *   from the same `geometry.json` ({@link drawingTurn}). For a region, its four
+ *   corners turn rigidly with its bone and this is the bone's turn exactly;
+ *   for a mesh it is the best rotation the skinned vertices admit. Level is
+ *   the setup pose, the painting's own: the check cannot see where the sole is
+ *   drawn, and the setup pose is the art as painted.
+ * - **The bar** is {@link LEVEL_BAR_DEGREES}, HQ's line — not a figure measured
+ *   here, and stated as HQ's wherever it is printed.
+ *
+ * Read off the fold render ({@link FOLD_LINE}), which then also writes
+ * `--geometry`: the same build, with its physics constraints left out, at the
+ * same rate. A part no frame poses says SKIP in its row; a line every row of
+ * which says SKIP says SKIP and is not counted as measured.
+ */
+export const LEVEL_LINE = 'FEET_STAY_LEVEL';
+
+/** Issue #349: every limb part rides its one bone ({@link limbLine}). */
+export const LIMB_LINE = 'LIMB_ONE_BONE';
+
+/** HQ's line (rig-c/parts#347 ruling 4, issue #348): the sole within ±10 degrees of level while the shin is posed. Not measured here. */
+export const LEVEL_BAR_DEGREES = 10;
+
+/** Where the bar comes from, as the line and check.json state it. */
+export const LEVEL_BAR_SOURCE = "HQ's line (rig-c/parts#347 ruling 4), not a figure measured here";
+
+/**
+ * The bar on a sleeve whose mesh is weighted to a bone off its chain (issue
+ * #347). The chain's first link is turned through {@link STRESS_TURNS} on a
+ * throwaway copy of the rig; rigc poses each turn and writes its
+ * `geometry.json`; the part's worst edge, max(ratio, 1/ratio) against the
+ * setup pose ({@link stretchFigures}, the quantity `TEXTURE_STRETCH` reads),
+ * must read {@link STRESS_RIGID} at {@link STRESS_PLACES} places. A part
+ * weighted to its chain alone turns rigidly with the link, so it reads exactly
+ * that; a vertex weighted to a bone the turn does not move is pulled between
+ * the two, and the line names that bone — the segment on it in the config's
+ * `meshes.<part>.segments`.
+ *
+ * - **The bar is the rigid reading, not a margin.** Measured for issue #347
+ *   (rigc 2.47.1, scratch runs, not tracked): the `handwear_*` parts of
+ *   `demo` and of the exam-01 test rig, their chest segment dropped, read
+ *   1.0000038 to 1.0000090 over the three turns of each sleeve — float32 bone
+ *   arithmetic — and 1.0000 at four places; with the segment, 2.41 to 1498.
+ * - **The turns are interim** (issue #347, HQ's ruling 1): ±90° and 180° on
+ *   the first link, the card's arm raised, arm across and arm behind the head,
+ *   until a config block names each limb and its joint's declared range — the
+ *   stress check then poses each limb at its range's ends.
+ * - **Which parts: those from a See-through `handwear` layer**
+ *   ({@link STRESS_TAGS}) whose weights ride exactly one chain the idle keys
+ *   ({@link chainsCarrying}). A part riding two chains (one mesh for both
+ *   sleeves) stretches between them by construction when one turns, and is
+ *   listed as not read with that reason. The scope is the tag and not every
+ *   one-chain part: `reference-demo`'s `hairpin` rides its tassel's chain and
+ *   the pin's bone, a pendant the idle swings a few degrees, and reads 23.7
+ *   with its tassel turned 180° (issue #347, scratch run) — a figure for the
+ *   limbs block to scope, not a defect this line was asked to name.
+ */
+export const STRESS_LINE = 'STRESS_OFF_CHAIN';
+
 /** The bars `PASS` reads, in the order the summary counts them: the gate, the reference's two, then the judgement lines. */
 export const BARS = ['gate', 'loop', 'seam', ...JUDGEMENT_LINES] as const;
 
 /**
  * The bars a character's own check may have failed and `compose --accept`
  * still take (issue #203): every bar of {@link BARS} but the gate, which is
- * rig-c's and never accepted, and {@link FOLD_LINE} (issue #320).
+ * rig-c's and never accepted, {@link FOLD_LINE} (issue #320) and
+ * {@link STRESS_LINE} (issue #347).
  */
-export const ACCEPTABLE_BARS: readonly string[] = [...BARS.filter((b) => b !== 'gate'), FOLD_LINE];
+export const ACCEPTABLE_BARS: readonly string[] = [...BARS.filter((b) => b !== 'gate'), FOLD_LINE, LEVEL_LINE, STRESS_LINE, LIMB_LINE];
 
 /**
  * The bars a `check.json`, as `check` writes it, says were not met, in
@@ -1784,7 +1878,8 @@ export const ACCEPTABLE_BARS: readonly string[] = [...BARS.filter((b) => b !== '
  * loop when `loop_max_diff` is a number other than {@link LOOP_MAX_BAR}, the
  * seam when its figures fail {@link seamFails}, and each judgement line whose
  * status is `FAIL`, then {@link FOLD_LINE} when it is written and `FAIL`
- * (issue #320). A bar that measured nothing (null figures, `SKIP`) is not
+ * (issue #320), then {@link LEVEL_LINE} the same way (issue #348), then {@link STRESS_LINE} likewise (issue #347), then
+ * {@link LIMB_LINE} (issue #349). A bar that measured nothing (null figures, `SKIP`) is not
  * one of them. Read off the file rather than its problems, because the file is
  * all a finished build leaves (issue #203).
  */
@@ -1795,7 +1890,7 @@ export function barsNotMet(fig: Readonly<Record<string, unknown>>): string[] {
   // A check.json written before issue #216 has no seam_frame_scale; it is read by the frame count, the bar it was written under.
   const scale = typeof fig.seam_frame_scale === 'number' ? fig.seam_frame_scale : 1;
   if (typeof fig.seam_mean === 'number' && typeof fig.seam_px_over_40 === 'number' && seamFails(fig.seam_mean, fig.seam_px_over_40, scale)) out.push('seam');
-  for (const n of [...JUDGEMENT_LINES, FOLD_LINE]) {
+  for (const n of [...JUDGEMENT_LINES, FOLD_LINE, LEVEL_LINE, STRESS_LINE, LIMB_LINE]) {
     const l = fig[n];
     if (typeof l === 'object' && l !== null && (l as { status?: unknown }).status === 'FAIL') out.push(n);
   }
@@ -1845,9 +1940,10 @@ export interface CheckReport {
  * idle (issue #183), or null when it holds none, so a rig of the idle alone
  * prints what it printed before.
  */
-export function besideIdleLine(names: readonly string[]): string | null {
+export function besideIdleLine(names: readonly string[], level = false): string | null {
   if (names.length === 0) return null;
-  return `beside the idle: ${names.length} animation(s), ${names.join(', ')} — built and gated by rigc with the rig; ${FOLD_LINE} reads each for folds, every other bar here reads the idle`;
+  const readers = level ? `${FOLD_LINE} reads each for folds and ${LEVEL_LINE} for how far the feet turn` : `${FOLD_LINE} reads each for folds`;
+  return `beside the idle: ${names.length} animation(s), ${names.join(', ')} — built and gated by rigc with the rig; ${readers}, every other bar here reads the idle`;
 }
 
 // ---------------------------------------------------------------------------
@@ -2022,6 +2118,471 @@ export function foldsLine(named: readonly string[], fps: number, physicsLeftOut:
   };
 }
 
+// ---------------------------------------------------------------------------
+// the feet stay level while a bone above them turns (issue #348)
+// ---------------------------------------------------------------------------
+
+/** A `footwear` part on a bone that hangs from another, as rig.json declares it. */
+export interface LevelFoot {
+  part: string;
+  /** The bone the part's slot sits on. */
+  bone: string;
+  /** That bone's parent in rig.json. */
+  hangs_from: string;
+}
+
+/** The frame a foot's drawing turned furthest on, among the frames a bone above it was turned. */
+export interface LevelWorst {
+  animation: string;
+  frame: number;
+  time: number;
+  /** The drawing's turn from its setup pose, degrees, CCW, six places. */
+  degrees: number;
+  /** The nearest bone above the part's bone that is turned on that frame, and its turn. */
+  turned: string;
+  turned_degrees: number;
+  /** The bones from the part's bone up to `turned`, `turned` left out, each with its inherit mode as rig.json writes it ("normal", rig-c's default, where it writes none). */
+  through: Array<{ bone: string; inherit: string }>;
+}
+
+export interface LevelRow extends LevelFoot {
+  status: 'PASS' | 'FAIL' | 'SKIP';
+  /** Frames, over every animation, on which a bone above the part's bone is turned and the part is shown. */
+  frames_posed: number;
+  worst: LevelWorst | null;
+}
+
+/** `check.json`'s `FEET_STAY_LEVEL`. */
+export interface LevelLine {
+  status: 'PASS' | 'FAIL' | 'SKIP';
+  /** Only on a SKIP: why nothing was measured. */
+  reason?: string;
+  animations: string[];
+  fps: number;
+  physics_left_out: number;
+  bar_degrees: number;
+  bar: string;
+  feet: LevelRow[];
+}
+
+/** The `footwear` parts the line reads (module comment above {@link LEVEL_LINE}), in parts.json's order: each on a slot of its name whose bone has a parent. */
+export function levelFeet(parts: PartsFile, rig: Record<string, unknown>): LevelFoot[] {
+  const slots = (Array.isArray(rig.slots) ? rig.slots : []).filter(isRecord);
+  const bones = (Array.isArray(rig.bones) ? rig.bones : []).filter(isRecord);
+  const out: LevelFoot[] = [];
+  for (const p of partsTagged(parts, FEET_TAGS)) {
+    const slot = slots.find((sl) => sl.name === p.name);
+    if (slot === undefined || typeof slot.bone !== 'string') continue;
+    const bone = bones.find((b) => b.name === slot.bone);
+    if (bone === undefined || typeof bone.parent !== 'string') continue;
+    out.push({ part: p.name, bone: slot.bone, hangs_from: bone.parent });
+  }
+  return out;
+}
+
+/**
+ * The turn, in degrees CCW (y up), of the least-squares rotation carrying the
+ * points `rest` onto `posed` (flat `x, y` lists, one point per pair), both
+ * centred on their means: atan2(Σ (r × p), Σ (r · p)). Null when the sums are
+ * both 0 — fewer than two distinct points, so no direction to turn.
+ */
+export function drawingTurn(rest: readonly number[], posed: readonly number[]): number | null {
+  const n = rest.length / 2;
+  let rx = 0;
+  let ry = 0;
+  let px = 0;
+  let py = 0;
+  for (let i = 0; i < n; i++) {
+    rx += rest[2 * i];
+    ry += rest[2 * i + 1];
+    px += posed[2 * i];
+    py += posed[2 * i + 1];
+  }
+  rx /= n;
+  ry /= n;
+  px /= n;
+  py /= n;
+  let cross = 0;
+  let dot = 0;
+  for (let i = 0; i < n; i++) {
+    const ax = rest[2 * i] - rx;
+    const ay = rest[2 * i + 1] - ry;
+    const bx = posed[2 * i] - px;
+    const by = posed[2 * i + 1] - py;
+    cross += ax * by - ay * bx;
+    dot += ax * bx + ay * by;
+  }
+  if (cross === 0 && dot === 0) return null;
+  return (Math.atan2(cross, dot) * 180) / Math.PI;
+}
+
+/** A bone's turn from its setup pose to a frame, degrees CCW in (-180, 180], off the two world matrices. */
+export function boneTurn(setup: BoneWorld, frame: BoneWorld): number {
+  return normaliseDegrees(((Math.atan2(frame.c, frame.a) - Math.atan2(setup.c, setup.a)) * 180) / Math.PI);
+}
+
+/** One animation's frames as the fold render wrote them with `--geometry`: the set and its geometry file. */
+export interface LevelReading {
+  animation: string;
+  set: FrameSet;
+  geometryPath: string;
+}
+
+/**
+ * The line from the feet and the readings (module comment above
+ * {@link LEVEL_LINE}); each FAIL row adds one `CHECK_FEET_STAY_LEVEL` problem
+ * naming the part, its bone, the frame and the bones the turn came through.
+ */
+export function levelLine(feet: readonly LevelFoot[], rig: Record<string, unknown>, readings: readonly LevelReading[], fps: number, physicsLeftOut: number, problems: Problem[]): LevelLine {
+  const bones = (Array.isArray(rig.bones) ? rig.bones : []).filter(isRecord);
+  const parentOf = (n: string): string | null => {
+    const b = bones.find((x) => x.name === n);
+    return b !== undefined && typeof b.parent === 'string' ? b.parent : null;
+  };
+  const inheritOf = (n: string): string => {
+    const b = bones.find((x) => x.name === n);
+    return b !== undefined && typeof b.inherit === 'string' ? b.inherit : 'normal';
+  };
+  const rows: LevelRow[] = feet.map((f) => ({ ...f, status: 'SKIP', frames_posed: 0, worst: null }));
+  for (const r of readings) {
+    const geo = readGeometry(r.geometryPath, r.set.written);
+    if (geo === null) geometryProblem(r.geometryPath, `does not exist; \`rigc render --folds --geometry\` writes it, and ${LEVEL_LINE} is read off it`);
+    const shown = attachmentPoses(r.geometryPath, r.set.written);
+    const tracks = new Map<string, BoneTrack>();
+    const track = (n: string): BoneTrack => {
+      const got = tracks.get(n) ?? boneTrackOf(geo, r.geometryPath, r.set, n);
+      if (typeof got === 'string') return geometryProblem(r.geometryPath, got);
+      tracks.set(n, got);
+      return got;
+    };
+    for (const row of rows) {
+      const above: string[] = [];
+      for (let b: string | null = row.hangs_from; b !== null; b = parentOf(b)) above.push(b);
+      r.set.frames.forEach((_, i) => {
+        const turned = above.find((b) => {
+          const t = track(b);
+          return boneTurn(t.setup, t.frames[i]) !== 0;
+        });
+        if (turned === undefined) return;
+        const at = shown[i].get(row.part);
+        if (at === undefined) return;
+        const deg = drawingTurn(at.rest, at.posed);
+        if (deg === null) return;
+        row.frames_posed++;
+        const degrees = round6(deg);
+        if (row.worst !== null && Math.abs(degrees) <= Math.abs(row.worst.degrees)) return;
+        const t = track(turned);
+        const through: Array<{ bone: string; inherit: string }> = [];
+        for (let b: string | null = row.bone; b !== null && b !== turned; b = parentOf(b)) through.push({ bone: b, inherit: inheritOf(b) });
+        row.worst = { animation: r.animation, frame: r.set.frames[i].index, time: t.times[i], degrees, turned, turned_degrees: round6(boneTurn(t.setup, t.frames[i])), through };
+      });
+    }
+  }
+  for (const row of rows) {
+    if (row.worst === null) continue;
+    row.status = Math.abs(row.worst.degrees) > LEVEL_BAR_DEGREES ? 'FAIL' : 'PASS';
+  }
+  const physics = physicsLeftOut === 0 ? '' : `, its ${physicsLeftOut} physics constraint(s) left out`;
+  for (const row of rows) {
+    if (row.status !== 'FAIL' || row.worst === null) continue;
+    const w = row.worst;
+    const how = w.through.map((x) => `"${x.bone}" (inherit ${x.inherit})`).join(', then ');
+    problems.push({
+      code: `CHECK_${LEVEL_LINE}`,
+      object: `footwear part "${row.part}" on bone "${row.bone}" (hangs from "${row.hangs_from}")`,
+      detail:
+        `in animation "${w.animation}" frame ${w.frame} (t = ${w.time}s, rigc render --folds --geometry at ${fps} fps${physics}), "${w.turned}" is turned ${w.turned_degrees} degrees from its setup pose and the part's drawing ${w.degrees} degrees; ` +
+        `within ±${LEVEL_BAR_DEGREES} degrees of level (its setup pose) is required while a bone above it is turned — ${LEVEL_BAR_SOURCE}. ` +
+        `The turn reaches the drawing through ${how}: config.bones' "inherit" on "${row.bone}" says what it takes from "${row.hangs_from}" (rig-c's modes, as its table spells them: ${RIG_BONE_INHERIT.join(', ')})`,
+    });
+  }
+  const status: LevelLine['status'] = rows.some((r) => r.status === 'FAIL') ? 'FAIL' : rows.some((r) => r.status === 'PASS') ? 'PASS' : 'SKIP';
+  const names = readings.map((r) => r.animation);
+  const line: LevelLine = { status, animations: names, fps, physics_left_out: physicsLeftOut, bar_degrees: LEVEL_BAR_DEGREES, bar: LEVEL_BAR_SOURCE, feet: rows };
+  if (status === 'SKIP') {
+    line.reason = `no frame of ${names.map((n) => `"${n}"`).join(', ')} turns a bone above ${rows.map((r) => `"${r.bone}" (which "${r.part}" rides)`).join(', ')}, so no foot was seen while its leg was posed`;
+  }
+  return line;
+}
+
+// ---------------------------------------------------------------------------
+// a part on one chain, posed large (issue #347)
+// ---------------------------------------------------------------------------
+
+
+/** The first link's turns, degrees from its setup rotation (issue #347's card: ±90° and 180°), interim until limbs are declared. */
+export const STRESS_TURNS: readonly number[] = [90, -90, 180];
+
+/** The parts the line reads (issue #347): from a See-through layer of these tags. */
+export const STRESS_TAGS: readonly BaseTag[] = ['handwear'];
+
+/** The reading a part riding its chain rigidly gives: max(ratio, 1/ratio) of 1. */
+export const STRESS_RIGID = 1;
+
+/** The places the reading is held to {@link STRESS_RIGID} at: four, where the rigid parts' float32 noise (at most 9.0e-6 measured) rounds away. */
+export const STRESS_PLACES = 4;
+
+/** The stress render, under `--out`; removed before the stage returns. */
+const STRESS_SCRATCH = '_stress';
+
+/** The animation one turn of one first link is posed by on the throwaway copy. */
+export function stressAnimationName(link: string, turn: number): string {
+  return `stress ${link} ${turn}`;
+}
+
+/**
+ * The stress render's geometry, by animation: `frames.json` names each set's
+ * directory and how many frames it wrote, and each `geometry.json` is read by
+ * {@link readGeometry}. A set or a file missing is refused
+ * (`CHECK_GEOMETRY_FILE`), every one at once.
+ */
+export function readStressSets(dir: string, named: readonly string[]): Map<string, IdleGeometry> {
+  const problems: Problem[] = [];
+  const sidecar = readJson(join(dir, 'frames.json'), problems);
+  const sets = sidecar !== null && Array.isArray(sidecar.sets) ? sidecar.sets.filter(isRecord) : [];
+  const out = new Map<string, IdleGeometry>();
+  for (const name of named) {
+    const set = sets.find((x) => x.animation === name);
+    if (set === undefined || typeof set.dir !== 'string' || typeof set.written !== 'number') {
+      problems.push({ code: 'CHECK_GEOMETRY_FILE', object: join(dir, 'frames.json'), detail: `names no frame set for animation ${JSON.stringify(name)} with its directory and frame count; \`rigc render --geometry\` over the turned copy writes one per animation` });
+      continue;
+    }
+    const path = join(dir, set.dir, GEOMETRY_FILE);
+    const geo = readGeometry(path, set.written);
+    if (geo === null) problems.push({ code: 'CHECK_GEOMETRY_FILE', object: path, detail: 'does not exist; `rigc render --geometry` writes it, and the stress line reads the part\'s posed mesh from it' });
+    else out.set(name, geo);
+  }
+  refuseIfAny(problems);
+  return out;
+}
+
+/** A part the line reads: its chain's links from the root, and the bones it is weighted to off that chain, each with how many of its vertices carry it and the largest weight. */
+export interface StressPart {
+  part: string;
+  chain: string[];
+  off_chain: Array<{ bone: string; vertices: number; of: number; largest_weight: number }>;
+}
+
+/** The parts a handwear tag names that the line reads, and those it does not with the reason. */
+export interface StressPlan {
+  read: StressPart[];
+  notRead: Array<{ part: string; reason: string }>;
+}
+
+/**
+ * Which handwear parts the line reads (see {@link STRESS_LINE}): a weighted
+ * mesh whose bones ride exactly one chain of the idle; for each, the bones
+ * off that chain — neither a link nor under one — with their vertex counts
+ * and largest weight, read off `rig.json`'s default skin.
+ */
+export function stressPlan(rig: Record<string, unknown>, motion: Record<string, unknown>, parts: readonly PartRecord[]): StressPlan {
+  const read: StressPart[] = [];
+  const notRead: StressPlan['notRead'] = [];
+  const bones = (Array.isArray(rig.bones) ? rig.bones : []).filter(isRecord).filter((b) => typeof b.name === 'string');
+  const parent = new Map(bones.map((b) => [String(b.name), typeof b.parent === 'string' ? b.parent : null]));
+  const skins = isRecord(rig.skins) ? rig.skins : {};
+  const skin = isRecord(skins.default) ? skins.default : {};
+  for (const p of parts) {
+    // Issue #349: a limb segment is held to its one bone by LIMB_ONE_BONE, read off rig.json, so it turns rigidly by construction.
+    if (p.limb !== undefined) {
+      notRead.push({ part: p.name, reason: `a limb segment (config.limbs.${p.limb.name}), held to its one bone "${p.limb.bone}" by ${LIMB_LINE}, so it turns rigidly by construction` });
+      continue;
+    }
+    const onSlot = skin[p.name];
+    const atts: unknown[] = isRecord(onSlot) ? Object.values(onSlot) : [];
+    const weighted = atts.filter((a): a is Record<string, unknown> & { weights: unknown[] } => isRecord(a) && Array.isArray(a.weights));
+    if (weighted.length === 0) {
+      notRead.push({ part: p.name, reason: 'it is not a weighted mesh, so it rides one bone whole and cannot stretch' });
+      continue;
+    }
+    const { found } = chainsCarrying(rig, motion, p.name);
+    if (found.length !== 1) {
+      notRead.push({
+        part: p.name,
+        reason:
+          found.length === 0
+            ? 'its weights ride no chain the idle keys, so there is no chain to turn'
+            : `its weights ride ${found.length} chains (${found.map((c) => `"${c[0]}"`).join(', ')}): turning one stretches the part toward the other by construction; a part riding one chain is read until a limbs block names each limb`,
+      });
+      continue;
+    }
+    const chain = found[0];
+    const onChain = (b: string): boolean => {
+      const seen = new Set<string>();
+      for (let x: string | null = b; x !== null && !seen.has(x); x = parent.get(x) ?? null) {
+        if (chain.includes(x)) return true;
+        seen.add(x);
+      }
+      return false;
+    };
+    const off = new Map<string, { vertices: number; largest: number }>();
+    let of = 0;
+    for (const a of weighted) {
+      for (const v of a.weights) {
+        of++;
+        const ws = (Array.isArray(v) ? v : []).filter(isRecord).filter((w) => typeof w.bone === 'string' && typeof w.weight === 'number') as Array<{ bone: string; weight: number }>;
+        for (const w of ws) {
+          if (onChain(w.bone) || w.weight <= 0) continue;
+          const e = off.get(w.bone) ?? { vertices: 0, largest: 0 };
+          e.vertices++;
+          e.largest = Math.max(e.largest, w.weight);
+          off.set(w.bone, e);
+        }
+      }
+    }
+    read.push({ part: p.name, chain, off_chain: [...off].map(([bone, e]) => ({ bone, vertices: e.vertices, of, largest_weight: e.largest })) });
+  }
+  return { read, notRead };
+}
+
+/** The throwaway copy's animations: one per first link and turn, a single `rotate` key at time 0, duration 0. */
+export function stressAnimations(plan: StressPlan): Record<string, { duration: number; tracks: Array<{ bone: string; property: string; keys: Array<{ t: number; v: number[] }> }> }> {
+  const out: ReturnType<typeof stressAnimations> = {};
+  for (const r of plan.read) {
+    for (const turn of STRESS_TURNS) out[stressAnimationName(r.chain[0], turn)] = { duration: 0, tracks: [{ bone: r.chain[0], property: 'rotate', keys: [{ t: 0, v: [turn] }] }] };
+  }
+  return out;
+}
+
+/** {@link STRESS_PLACES} places. */
+function roundStress(x: number): number {
+  const k = 10 ** STRESS_PLACES;
+  return Math.round(x * k) / k;
+}
+
+/**
+ * The line from the renders: `geometry` maps each stress animation to its
+ * `geometry.json` read by {@link readGeometry}. Per part and turn, the
+ * worst edge of the part's mesh; a reading above {@link STRESS_RIGID} at
+ * {@link STRESS_PLACES} places is a `CHECK_STRESS_OFF_CHAIN` problem naming
+ * the part, the link and turn, the edge, and the bones off the chain. SKIP,
+ * with every part's reason, when no handwear part is read.
+ */
+export function stressLine(plan: StressPlan, geometry: (animation: string) => IdleGeometry, problems: Problem[]): JudgementLine {
+  if (plan.read.length === 0) return skip(plan.notRead.map((n) => `"${n.part}": ${n.reason}`).join('; '));
+  const rows: Array<Record<string, unknown>> = [];
+  let worst: { part: string; link: string; turn: number; reading: number } | null = null;
+  let failed = false;
+  for (const r of plan.read) {
+    const poses: Array<Record<string, unknown>> = [];
+    for (const turn of STRESS_TURNS) {
+      const name = stressAnimationName(r.chain[0], turn);
+      const geo = geometry(name);
+      const m = stretchFigures(
+        geo.meshes.filter((x) => x.slot === r.part),
+        geo.frames,
+      );
+      const seen = m.filter((x) => x.max !== null && x.min !== null);
+      if (seen.length === 0) {
+        poses.push({ turn, unmeasured: `the "${name}" render shows no mesh on slot "${r.part}"` });
+        failed = true;
+        problems.push({ code: `CHECK_${STRESS_LINE}`, object: `mesh "${r.part}" with "${r.chain[0]}" turned ${turn}°`, detail: `the "${name}" render shows no mesh on slot "${r.part}", so its stretch was not read; a part not read is not a pass` });
+        continue;
+      }
+      let at: StretchAt | null = null;
+      let reading = 0;
+      for (const x of seen) {
+        for (const s of [x.max as StretchAt, x.min as StretchAt]) {
+          const v = stretchSeverity(s.ratio);
+          if (v > reading) {
+            reading = v;
+            at = s;
+          }
+        }
+      }
+      const shown = roundStress(reading);
+      const a = at as StretchAt;
+      poses.push({ turn, reading: shown, worst: { triangle: a.triangle, edge: a.edge, ratio: round3(a.ratio) } });
+      if (worst === null || reading > worst.reading) worst = { part: r.part, link: r.chain[0], turn, reading };
+      if (shown > STRESS_RIGID) {
+        failed = true;
+        const bones = r.off_chain.length === 0 ? 'no vertex is weighted off the chain, so a bone under the chain or the render moves it' : r.off_chain.map((o) => `"${o.bone}" (${o.vertices} of ${o.of} vertices, largest weight ${round3(o.largest_weight)})`).join(', ');
+        problems.push({
+          code: `CHECK_${STRESS_LINE}`,
+          object: `mesh "${r.part}" with chain link "${r.chain[0]}" turned ${turn}°`,
+          detail:
+            `its worst edge, triangle ${a.triangle} edge ${a.edge.join('-')}, is ${round3(a.ratio)} times its rest length (max(ratio, 1/ratio) ${shown}); ${STRESS_RIGID.toFixed(STRESS_PLACES)}, the part turning rigidly with its chain, is required — ` +
+            `it is weighted off the chain to ${bones}: a segment on ${r.off_chain.length === 1 ? `"${r.off_chain[0].bone}"` : 'each of those bones'} in meshes.${r.part}.segments pins the part while the chain turns; drop it, so the part rides its chain alone`,
+        });
+      }
+    }
+    rows.push({ part: r.part, link: r.chain[0], links: r.chain.length, off_chain: r.off_chain.map((o) => ({ ...o, largest_weight: round3(o.largest_weight) })), poses });
+  }
+  const w = worst as { part: string; link: string; turn: number; reading: number } | null;
+  return {
+    status: failed ? 'FAIL' : 'PASS',
+    tags: [...STRESS_TAGS],
+    turns: [...STRESS_TURNS],
+    parts_read: plan.read.length,
+    reading: w === null ? null : roundStress(w.reading),
+    worst: w === null ? null : { part: w.part, link: w.link, turn: w.turn },
+    bar: STRESS_RIGID,
+    per_part: rows,
+    not_read: plan.notRead,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// a limb segment rides one bone (issue #349)
+// ---------------------------------------------------------------------------
+
+/**
+ * `LIMB_ONE_BONE` (issue #349): every part a `config.limbs` segment made —
+ * `parts.json`'s records that carry `limb` — is bound in `rig.json` to its
+ * limb bone alone, with weight 1: a region on a slot whose bone is that bone,
+ * or a mesh whose every weight names it. A bend is a rotation at the joint,
+ * never a deformed mesh, and a second bone is the pin (a puff held by the
+ * chest) or the noodle (a forearm blended along a chain) the cut retires.
+ * Under `config.turn` a part rides the leaf twin of its bone
+ * (`turnTwin`), an identity child, and the twin counts as the bone. Read off
+ * `rig.json` and `parts.json` alone: nothing is rendered. Written only when
+ * `parts.json` holds a limb part, so a check with none writes what it wrote.
+ * The name is {@link LIMB_LINE}.
+ */
+
+/** One limb part's row of the line. */
+export interface LimbRow {
+  part: string;
+  limb: string;
+  bone: string;
+  status: 'PASS' | 'FAIL';
+  /** The bones besides its own the part is bound to, in rig.json's order; empty on a PASS. */
+  others: string[];
+}
+
+/** `check.json`'s `LIMB_ONE_BONE`. */
+export interface LimbLine {
+  status: 'PASS' | 'FAIL';
+  parts: LimbRow[];
+}
+
+/** The line from parts.json's limb records and rig.json's slots and skins; each FAIL row adds one `CHECK_LIMB_ONE_BONE` problem naming the part and every second bone. Null when no part is a limb's. */
+export function limbLine(parts: PartsFile, rig: Record<string, unknown>, problems: Problem[]): LimbLine | null {
+  const limbParts = parts.parts.filter((p) => p.limb !== undefined);
+  if (limbParts.length === 0) return null;
+  const slots = (Array.isArray(rig.slots) ? rig.slots : []).filter(isRecord);
+  const rows: LimbRow[] = limbParts.map((p) => {
+    const l = p.limb as NonNullable<PartRecord['limb']>;
+    const own = new Set([l.bone, turnTwin(p.name, l.bone)]);
+    const slot = slots.find((sl) => sl.name === p.name);
+    const bound = slot === undefined ? new Set<string>() : boundBones(rig, p.name);
+    const others = [...bound].filter((b) => !own.has(b));
+    const fail = others.length > 0 || bound.size === 0;
+    if (fail) {
+      problems.push({
+        code: `CHECK_${LIMB_LINE}`,
+        object: `limb part "${p.name}" (config.limbs.${l.name} segment ${l.segment}, bone "${l.bone}")`,
+        detail:
+          bound.size === 0
+            ? `is bound to no bone in rig.json (no slot of its name, or no attachment); its one bone "${l.bone}", with weight 1, is required`
+            : `is weighted to ${others.map((b) => `"${b}"`).join(', ')} besides "${l.bone}"; a limb part rides its one bone with weight 1 — a bend is a rotation at the joint, never a deformed mesh — so a region on "${l.bone}" (config.regions.${p.name}), or a mesh whose segments name "${l.bone}" alone, is required`,
+      });
+    }
+    return { part: p.name, limb: l.name, bone: l.bone, status: fail ? 'FAIL' : 'PASS', others };
+  });
+  return { status: rows.some((r) => r.status === 'FAIL') ? 'FAIL' : 'PASS', parts: rows };
+}
+
 /**
  * One `CHECK_RIGC_GREEN` per line that says why `rigc <what>` was not green:
  * its FAIL and compile-error lines, or, when there are none, {@link causeLines}.
@@ -2159,6 +2720,13 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   const named = animationNames.filter((n) => n !== 'idle');
   let folds: FoldsLine | null = null;
   const foldProblems: Problem[] = [];
+  // Issue #348: the feet the level line reads, off parts.json and rig.json; none, and nothing below moves.
+  const feet = inp.parts === null ? [] : levelFeet(inp.parts, inp.rig);
+  let level: LevelLine | null = null;
+  // Issue #349: the limb parts' bones, off rig.json and parts.json; none, and nothing is written.
+  const limbProblems: Problem[] = [];
+  const limbs = inp.parts === null ? null : limbLine(inp.parts, inp.rig, limbProblems);
+  const levelProblems: Problem[] = [];
   try {
     if (inp.idleDuration !== null) {
       const render = rigc(['render', '--candidate', buildDir, '--animation', 'idle', '--fps', String(IDLE_FPS), '--max', String(IDLE_MAX_PX), '--geometry', '--out', idleDir]);
@@ -2214,10 +2782,22 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     if (animationNames.length > 0) {
       const fps = IDLE_FPS;
       try {
-        const fr = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', foldDir]);
-        if (fr.status !== 0) refuseIfAny(rigcFailed(`render --folds --fps ${fps}${stripped === null ? '' : ' (physics constraint(s) left out)'}`, fr, fr.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
+        // Issue #348: with a foot to read, the same render writes each animation's geometry as well.
+        const geometry = feet.length > 0 ? ['--geometry'] : [];
+        const fr = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', ...geometry, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', foldDir]);
+        if (fr.status !== 0) refuseIfAny(rigcFailed(`render --folds${geometry.map((g) => ` ${g}`).join('')} --fps ${fps}${stripped === null ? '' : ' (physics constraint(s) left out)'}`, fr, fr.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
         const readings = readFoldSets(foldDir, animationNames, fps, fr.out);
         folds = foldsLine(animationNames, fps, stripped === null ? 0 : stripped.physics.length, readings, reqFile === null ? [] : reqFile.may_fold, reqFile === null ? null : reqFile.path, foldProblems);
+        if (feet.length > 0) {
+          const sets = readJson(join(foldDir, 'frames.json'), []);
+          const listed = sets !== null && Array.isArray(sets.sets) ? sets.sets.filter(isRecord) : [];
+          // readFoldSets has refused a missing set by name, so each animation has its directory here.
+          const levelReadings = animationNames.map((name) => {
+            const dir = join(foldDir, String((listed.find((x) => x.animation === name) as Record<string, unknown>).dir));
+            return { animation: name, set: readFrameSet(dir), geometryPath: join(dir, GEOMETRY_FILE) };
+          });
+          level = levelLine(feet, inp.rig, levelReadings, fps, stripped === null ? 0 : stripped.physics.length, levelProblems);
+        }
       } finally {
         rmSync(foldDir, { recursive: true, force: true });
       }
@@ -2257,6 +2837,33 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     if (full !== null) still = stillLine(full, idle, geometry, geometryPath, problems, notPlanted);
   }
 
+  // 3c. a sleeve on one chain, its first link turned large (issue #347): a throwaway copy, physics left out, posed by rigc
+  let stress: JudgementLine | null = null;
+  const stressProblems: Problem[] = [];
+  const stressTagged = full === null || idle === null ? [] : partsTagged(full.parts, STRESS_TAGS);
+  if (stressTagged.length > 0) {
+    const plan = stressPlan(inp.rig, inp.motion, stressTagged);
+    const stressDir = join(out, STRESS_SCRATCH);
+    rmSync(stressDir, { recursive: true, force: true });
+    try {
+      if (plan.read.length > 0) {
+        mkdirSync(stressDir, { recursive: true });
+        const base = stripped === null ? inp.rig : stripped.rig;
+        const images = typeof inp.rig.images === 'string' ? resolve(inp.rigDir, inp.rig.images) : inp.rig.images;
+        writeFileSync(join(stressDir, 'rig.json'), JSON.stringify({ ...base, images }));
+        writeFileSync(join(stressDir, 'motion.json'), JSON.stringify({ ...(stripped === null ? inp.motion : stripped.motion), animations: stressAnimations(plan) }));
+        const sb = rigc(['build', '--rig', join(stressDir, 'rig.json'), '--motion', join(stressDir, 'motion.json'), '--out', join(stressDir, 'build'), '--profile', 'spine']);
+        if (sb.status !== 0) refuseIfAny(rigcFailed(`build (${STRESS_LINE}'s turned copy)`, sb, buildGateLines(sb.out)));
+        const sr = rigc(['render', '--candidate', join(stressDir, 'build'), '--fps', String(IDLE_FPS), '--max', String(FOLD_RENDER_MAX), '--geometry', '--out', join(stressDir, 'render')]);
+        if (sr.status !== 0) refuseIfAny(rigcFailed(`render --geometry (${STRESS_LINE}'s turned copy)`, sr, sr.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
+      }
+      const sets = plan.read.length > 0 ? readStressSets(join(stressDir, 'render'), Object.keys(stressAnimations(plan))) : new Map<string, IdleGeometry>();
+      stress = stressLine(plan, (a) => sets.get(a) as IdleGeometry, stressProblems);
+    } finally {
+      rmSync(stressDir, { recursive: true, force: true });
+    }
+  }
+
   // 4. the setup pose as a one-key throwaway animation — the seam reads it against the parts, the source line against
   // the painting — and, beside it, the same pose with the eyes shut
   let seam: SeamFigures | null = null;
@@ -2365,6 +2972,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     STILL_REGIONS_DARK: still,
     TEXTURE_STRETCH: stretch,
     ...(folds === null ? {} : { [FOLD_LINE]: folds }),
+    ...(level === null ? {} : { [LEVEL_LINE]: level }),
+    ...(stress === null ? {} : { [STRESS_LINE]: stress }),
+    ...(limbs === null ? {} : { [LIMB_LINE]: limbs }),
     RECOMPOSITE_HOLES: inp.parts === null ? { status: 'SKIP', reason: inp.noParts ?? '' } : holesLine(inp.parts),
     ...(sourceRead === null ? {} : { [SOURCE_LINE]: sourceRead }),
     ...(Object.keys(skipped).length === 0 ? {} : { skipped }),
@@ -2396,7 +3006,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   const rank = (q: Problem): number => JUDGEMENT_LINES.findIndex((n) => q.code === `CHECK_${n}`);
   problems.sort((a, b) => rank(a) - rank(b));
   problems.unshift(...barProblems);
-  problems.push(...foldProblems, ...reqProblems);
+  problems.push(...foldProblems, ...levelProblems, ...stressProblems, ...limbProblems, ...reqProblems);
   figures.PASS = problems.length === 0;
   write('check.json', `${JSON.stringify(figures, null, 1)}\n`);
   const bars: CheckReport['bars'] = { measured: ['gate'], skipped: [] };
@@ -2412,6 +3022,12 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   }
   // Issues #320, #333: the fold bar is counted where it is written — on every rig whose motion holds an animation.
   if (folds !== null) tally(FOLD_LINE, null);
+  // Issue #348: the level bar where it is written; a line whose every foot no frame posed says SKIP and is not measured.
+  if (level !== null) tally(LEVEL_LINE, level.status === 'SKIP' ? (level.reason ?? '') : null);
+  // Issue #347: the stress bar is counted where it is written — on every rig with a handwear part and an idle.
+  if (stress !== null) tally(STRESS_LINE, stress.status === 'SKIP' ? stress.reason : null);
+  // Issue #349: the limb bar where it is written; it reads rig.json, so it always measures.
+  if (limbs !== null) tally(LIMB_LINE, null);
   return {
     figures,
     gateHtml,
@@ -2877,6 +3493,11 @@ function tipLine(inp: FullInputs, geometryPath: string, frames: number, problems
       rows.push({ part: p.name, unmeasured: "declared not swinging by the scene file's not_swinging, so it is not held to the bar" });
       continue;
     }
+    // Issue #349: a limb segment is rigid on its one bone and turns at its joint; it does not hang, so no tip trails a root.
+    if (p.limb !== undefined) {
+      rows.push({ part: p.name, unmeasured: `a limb segment (config.limbs.${p.limb.name}), rigid on its one bone "${p.limb.bone}": it turns at its joint and does not hang, so it is not held to the bar` });
+      continue;
+    }
     const rises = excepted.rises.includes(p.name);
     const rests = excepted.rests.includes(p.name);
     const [rootHalf, tipHalf] = rises ? ['lower', 'upper'] : ['upper', 'lower'];