@rig-c/parts 1.6.0 → 1.8.0

package/src/propose.ts

@@ -29,7 +29,10 @@
  *   midline, split at the eye axis — unless the blob is clasped hands (at the
  *   axis and at most half the shoulders' width), which ride `hip` as a region.
  * - `front hair` -> three fringe chains + one lock chain per strand that hangs
- *   0.3 face heights below the chin.
+ *   0.3 face heights below the chin. The fringe chains are the reference's
+ *   template turned into the head's frame (issue #249): columns along the
+ *   eye line's perpendicular ({@link headRollOf}), each rooted on the part's
+ *   own art, and a note saying they are a template, not the part's locks.
  * - `back hair` -> one `bun` bone if it ends above the shoulders, else two
  *   hanging chains.
  * - `headwear` / `earwear` -> the biggest layer of the tag gets a rigid bone
@@ -49,7 +52,7 @@
  *   chains a second time. The one exception is the sleeve rule, which names
  *   its chains by side and takes a cut sleeve as a blob of its own (#199). A
  *   `parts.json` sharing a layer between parts with no `cut_from` (an
- *   assemble before 1.5.6) is refused, `PROPOSE_CUT_FROM_RECORDED`.
+ *   assemble before 1.6.0) is refused, `PROPOSE_CUT_FROM_RECORDED`.
  *
  * What it cannot know is written into `notes` when it guessed, and otherwise
  * left to the person correcting: things hidden inside a layer (a sash tail
@@ -79,6 +82,26 @@
  * never moved by a joint. `lint` then reads the torso and the sleeves by the
  * relations the joints declare instead of by screen y. Without joints every
  * value, note and LINT line is the one written before the option existed.
+ * One rule runs only with joints (issue #241): a `legwear` part holding the
+ * ankle of a leg whose hip, knee and ankle are given is meshed on a leg chain
+ * (hip -> knee, tip at the ankle; one per leg, or one through the midpoints
+ * when the part's art does not separate the legs — {@link legsFromJoints}),
+ * where without them it rides `hip` as a region. And with a joint at either
+ * end of the trunk (issue #243), the trunk parts' fixed segments run along
+ * neck -> hip, the line the chest is placed on, instead of down the screen
+ * ({@link trunkLineOf}).
+ * One departure moves every published proposal, the reference's own two
+ * included (issue #249): the reference stood the fringe's three columns on
+ * the page and rooted them 13 px below the part's box, which on a tilted head
+ * put them on a hat above the hair and across the locks; here they stand in
+ * the head's frame and are rooted 13 px below the art on each column, and
+ * `lint` names a fringe link that does not lean with the head.
+ *
+ * The idle departs from the reference's too (issue #252): it is
+ * {@link IDLE_FRAMES} frames at 12 fps rather than 4 s, every period scaled
+ * with it, and the chest's breath travels {@link BREATH_FRACTION} of the torso
+ * part's height ({@link breathTrack}) rather than a fixed 1.3 px amplitude, so
+ * no tracked proposal is the reference's output any more in its `motion`.
  *
  * Issue #86 adds what the proposer and lint looked at, and changes nothing
  * they wrote: {@link proposeWithBasis} records, at each placement, what the
@@ -93,6 +116,7 @@ import { join } from 'node:path';
 import { drawText, GLYPH_H } from 'rig-c/tools/font5x7.ts';
 import { type BoneEntry, type ConfigConstraint, type MeshSpec, parseConfig, type Point, type Segment, type SkeletonSections } from './config.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
+import { eyeLineDegrees, type FrameFeature, headAxes, type HeadAxes, headFrame, type HeadFrame } from './headframe.ts';
 import { OPAQUE_ALPHA_ABOVE } from './layers.ts';
 import { PAINTING_RUN, type PartRecord, type PartsFile, readParts } from './parts.ts';
 import { connectedComponents } from './raster/components.ts';
@@ -102,6 +126,8 @@ import { resize } from './raster/resize.ts';
 import { type Mask, newMask, newRaster, type Raster } from './raster/types.ts';
 import { npMean, npMedian, npPercentile, pyFixed, pyInt, pyIntList, pyRepr, pyRound, pyStrList } from './pyfmt.ts';
 import type { JointState, RigJoint, RigJoints } from './keypoints.ts';
+import { IDLE_FPS } from './motion.ts';
+import { pyRound as roundTo } from './round.ts';
 import { KEYPOINT_NAMES, type KeypointName } from './skeleton.ts';
 import { configRoles, type RoleOf } from './structure.ts';
 
@@ -141,6 +167,41 @@ export const EYE_GROUP_TAGS: readonly string[] = ['eyewhite-r', 'eyewhite-l'];
 /** The tags whose parts make the brow bones, the blink's `brows` group. */
 export const BROW_GROUP_TAGS: readonly string[] = ['eyebrow-r', 'eyebrow-l'];
 
+/**
+ * The drafted idle's length, in frames at {@link IDLE_FPS} (issue #252): 40
+ * frames, 40/12 s. The reference drafted a 4 s idle; HQ calibrated the breath
+ * over 40 frames at 12 fps, and a duration of a whole number of frames is what
+ * `check`'s loop compares frame 0 with (issue #244).
+ */
+export const IDLE_FRAMES = 40;
+/** {@link IDLE_FRAMES} in seconds: 3.3333333333333335 as a double, the time rigc's last frame is read at within `TIME_SLACK`. */
+export const IDLE_SECONDS = IDLE_FRAMES / IDLE_FPS;
+/**
+ * The idle the reference drafted, in seconds. Every drafted track's period is
+ * written against it (4 s: one cycle per idle; 2 s: two) and scaled by
+ * `IDLE_SECONDS / REFERENCE_IDLE_SECONDS` when the proposal is returned, so
+ * each keeps its number of cycles per idle — the loader refuses a period that
+ * does not divide the idle (`CONFIG_PERIOD_DIVIDES_DURATION`). The scale is
+ * 10/12 = 0.8333333333333334, and 4 and 2 times it are 40/12 and 20/12 to the
+ * last bit, since only a power of two multiplies it.
+ */
+export const REFERENCE_IDLE_SECONDS = 4;
+/**
+ * The breath's travel, peak to peak, as a fraction of the torso part's height
+ * (issue #252). The size is the height because the breath is a `translatey`:
+ * its travel is read along y, against the part's extent along y. HQ's
+ * calibration: about 2.5 %. On the trailer's seated character the torso part
+ * (`topwear`) is 267 px tall and the reference's fixed 2.6 px peak to peak
+ * (amplitude 1.3, the base 1.3 so the chest rises from its setup pose and
+ * returns) was 0.97 % of it, read by its owner as a still paper doll; the
+ * production scene rig that replaced it breathes 6.4 px, 2.4 %.
+ */
+export const BREATH_FRACTION = 0.025;
+/** The breath's amplitude the reference drafted on every figure, kept only where there is no torso part to scale by. */
+export const REFERENCE_BREATH_AMP = 1.3;
+/** The See-through tag of the torso part, whose height the breath is a fraction of. */
+export const BREATH_SIZE_TAG = 'topwear';
+
 export interface Proposal {
   bones: BoneEntry[];
   meshes: Record<string, MeshSpec>;
@@ -259,7 +320,7 @@ export function proposalAssemble(P: PartSet): Record<string, unknown> {
   // loader only type-checks like the patches' fields. The piece names its base
   // (`cut_from`, issue #230); file order cannot, as a piece drawn "back" comes
   // before its base. A file with an unmarked shared layer (an assemble before
-  // 1.5.6, which propose refuses) goes back with the first part of the layer
+  // 1.6.0, which propose refuses) goes back with the first part of the layer
   // as the plan part, as it did before the field.
   const run = P.recs.filter((r) => splitFrom(r.from)[0] !== PAINTING_RUN);
   const painted = P.recs.filter((r) => splitFrom(r.from)[0] === PAINTING_RUN);
@@ -349,7 +410,7 @@ export class PartSet {
 
   /**
    * The layers more than one part holds with no `cut_from` to tell the piece
-   * from its base: a `parts.json` an `assemble` before 1.5.6 wrote with
+   * from its base: a `parts.json` an `assemble` before 1.6.0 wrote with
    * `assemble.cuts`. parts.json is in draw order and a piece drawn `"back"`
    * comes before its base, so which part takes the layer's rule cannot be
    * read off the file. Each entry is the layer and its parts, in file order.
@@ -877,7 +938,7 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     P.unmarkedShares().map(({ from, parts }) => ({
       code: 'PROPOSE_CUT_FROM_RECORDED',
       object: `parts ${parts.map((n) => `"${n}"`).join(', ')} (${from})`,
-      detail: `share one layer and none of them records cut_from, so which is the plan part and which the piece an assemble.cuts entry took cannot be read off parts.json (it is in draw order, and a piece drawn "back" comes before its base); re-run assemble (1.5.6+) to record cut_from`,
+      detail: `share one layer and none of them records cut_from, so which is the plan part and which the piece an assemble.cuts entry took cannot be read off parts.json (it is in draw order, and a piece drawn "back" comes before its base); re-run assemble (1.6.0+) to record cut_from`,
     })),
   );
   const bones: BoneEntry[] = [];
@@ -996,6 +1057,13 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
   // down the screen, because the torso need not be upright.
   const chestAlong = neckJ !== null || hipFromJoints;
   const chest: [number, number] = chestAlong ? [(neckAt[0] + hip[0]) / 2, (neckAt[1] + hip[1]) / 2] : [hip[0], neckY + 0.5 * (hip[1] - neckY)];
+  // Issue #243: on that same line, neck -> hip, the trunk parts' fixed segments are laid too (neck, topwear,
+  // bottomwear; {@link trunkSegments}), not down the screen through the bones' x. Without a joint at either end,
+  // today's verticals; with the two ends on one point the line has no direction, and a note says the verticals stay.
+  const trunk = chestAlong ? trunkLineOf(neckAt, hip) : null;
+  if (chestAlong && trunk === null) {
+    notes.push(`trunk segments: neck and hip are one point, ${fmtAt(hip)}, so neck -> hip declares no line; the trunk parts' segments are drafted down the screen, as without keypoints`);
+  }
   // Each placement hands its basis with its value: one record per bone, in the order the bones are written.
   const B = (name: string, parent: string, at: readonly [number, number], why: Placement, tip?: readonly [number, number], tipWhy?: Placement): void => {
     bones.push(tip === undefined ? { name, parent, at: rnd(at) } : { name, parent, at: rnd(at), tip: rnd(tip) });
@@ -1057,6 +1125,9 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       B('mouth', 'head', [cc.stats[best].cx, cc.stats[best].cy], placement('mask', `the centroid of the biggest 8-connected blob of ${mouth[0].name}`, { parts: [mouth[0].name] }));
     } else B('mouth', 'head', center(mouth[0]), placement('mask', `the centre of ${mouth[0].name}'s box`, { parts: [mouth[0].name], fallback: 'its mask has no opaque pixel, so no blob' }));
   }
+  // Issue #250: the head's frame, read off the head run once, written as notes. The bar is the line through the eye
+  // bones' origins as written here: the one roll the rig turns the face bones to (src/headframe.ts).
+  notes.push(...headFrameNotes(P, bones));
   // An eye bone comes only from an eyewhite (EYE_GROUP_TAGS). An iris or a
   // lash on a side with none has no eye bone to ride, and writing its region
   // as `eye_<s>` anyway named a bone that does not exist — refused by the
@@ -1103,8 +1174,13 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     if (Object.keys(still).length > 0) blink.still = still;
     if (browBonesProposed.length === 0) notes.push(`blink without brows: no eyebrow part (looked for: ${BROW_GROUP_TAGS.join(', ')}), so the blink has no brows group and no brow_drop`);
   }
+  // Issue #252: the breath's travel is BREATH_FRACTION of the torso part's height, not the reference's fixed 1.3 px
+  // amplitude. Its base stays its amplitude (the chest rises from the setup pose and returns). The other three tracks
+  // are an angle and a ratio and stay as drafted. A rig with no torso part keeps the reference's amplitude, and a note.
+  const breath = breathTrack(P);
+  notes.push(breath.note);
   tracks.push(
-    { bone: 'chest', prop: 'translatey', amp: 1.3, period: 4.0, phase: 0.0, base: 1.3 },
+    breath.track,
     { bone: 'chest', prop: 'scalex', amp: 0.004, period: 4.0, phase: 0.0, base: 1.004 },
     { bone: 'head', prop: 'rotate', amp: 0.9, period: 4.0, phase: 0.12 },
     { bone: 'neck', prop: 'rotate', amp: 0.35, period: 4.0, phase: 0.08 },
@@ -1155,43 +1231,78 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
   }
 
   // ---- front hair: fringe + locks
+  // Issue #249: the fringe's columns stand in the head's frame — the roll read once, off the eye bones as written
+  // (headRollOf, the one derivation) — and each column's root sits on the part's own art. With no eye pair the
+  // frame is the page's, said in a note.
+  const roll = headRollOf(bones, P.H);
+  const ax = headAxes('none' in roll ? 0 : roll.degrees, P.H);
+  const eyeMid: [number, number] = [axis, eyeY];
+  const turned = 'none' in roll ? 'on the page' : `along the head's down axis (the eye line's perpendicular, roll ${pyFixed(roll.degrees, 3)} degrees)`;
+  const rollBones = 'none' in roll ? [] : ['eye_r', 'eye_l'];
   for (const p of P.headFirst('front hair')) {
     const [g, r] = gridR(p);
     const mask = P.alpha(p);
     const top = p.y;
     const segs: Segment[] = [['head', rnd(head), rnd([axis, top])]];
-    const browY = eyeY - 0.18 * fh;
+    // Depths along the face's down axis from the eye line (through the eye midpoint): the brow line and the tip's.
+    const browD = -0.18 * fh;
+    const tipD = browD + 19;
+    const columns: string[] = [];
     for (const [tag, f, dx] of [
-      ['bang_r', 0.25, -10],
+      ['bang_r', 0.25, -FRINGE_STEP_PX],
       ['bang_c', 0.5, 0],
-      ['bang_l', 0.75, 10],
+      ['bang_l', 0.75, FRINGE_STEP_PX],
     ] as const) {
-      const x0 = fx0 + f * fw;
+      const foot = ax.at(eyeMid, fx0 + f * fw - axis, 0);
+      // The root is 13 px into a run of the column's art and above the brow line: the lowest run that holds such a
+      // point. A strand's end under the fringe (demo's centre column has one, 7 px below it) or a lock that starts
+      // at the brow line is not where the fringe's lock starts.
+      const runs = columnRuns(mask, p, ax, foot);
+      const held = runs.filter(([s0, s1]) => s0 + 13 < browD && s0 + 13 <= s1);
+      const artD = held.length === 0 ? null : held[held.length - 1][0];
+      const d0 = (artD ?? boxEntry(p, ax, foot)) + 13;
+      const d1 = (d0 + browD) / 2 + 6;
+      const rootWhy = placement(
+        'mask',
+        `link 0: on the column at ${f} of the face box's width from its left, ${turned}, 13 px below where ${p.name}'s art starts on that column — the lowest run of its art there that holds a point 13 px in and above the brow line (0.18 face heights above the eye line)`,
+        {
+          parts: [p.name],
+          bones: rollBones,
+          frame: ['face_box', 'eye_axis', 'eye_line'],
+          constants: [konst('of_face_width', f), konst('px_below_art_start', 13)],
+          fallback: artD === null ? `no run of ${p.name}'s art on the column holds a point 13 px in above the brow line: 13 px below the top of its box along the column` : null,
+        },
+      );
       C(
         tag,
         'head',
+        [ax.at(foot, 0, d0), ax.at(foot, dx, d1)],
+        ax.at(foot, dx * 1.8, tipD),
         [
-          [x0, top + 13],
-          [x0 + dx, (top + 13 + browY) / 2 + 6],
-        ],
-        [x0 + dx * 1.8, browY + 19],
-        [
-          placement('ratio', `link 0: ${f} of the face box's width from its left, 13 px below the top of ${p.name}`, { parts: [p.name], frame: ['face_box'], constants: [konst('of_face_width', f), konst('px_below_part_top', 13)] }),
-          placement('ratio', `link 1: ${dx} px across from link 0, 6 px below half way from link 0's row to the brow line (0.18 face heights above the eye line)`, {
+          rootWhy,
+          placement('ratio', `link 1: ${dx} px across the column from link 0, 6 px below half way from link 0 to the brow line (0.18 face heights above the eye line), ${turned}`, {
             parts: [p.name],
+            bones: rollBones,
             frame: ['face_box', 'eye_line'],
             constants: [konst('px_across', dx), konst('px_below_half_way', 6), konst('brow_line_face_heights_above_eye_line', 0.18)],
           }),
         ],
-        placement('ratio', `${dx * 1.8} px across from link 0 (1.8 times link 1's offset), 19 px below the brow line (0.18 face heights above the eye line)`, {
+        placement('ratio', `${dx * 1.8} px across the column (1.8 times link 1's step), 19 px below the brow line (0.18 face heights above the eye line), ${turned}`, {
+          bones: rollBones,
           frame: ['face_box', 'eye_line'],
           constants: [konst('times_link_1_offset', 1.8), konst('px_below_brow_line', 19), konst('brow_line_face_heights_above_eye_line', 0.18)],
         }),
       );
       segs.push(tag);
+      columns.push(tag);
       const a = tag === 'bang_c' ? 0.8 : 1.0;
       tracks.push({ chain: tag, amps: [a, Number((a * 2.2).toFixed(4))], period: 4.0, phase: 0.18, lag: 0.1 });
     }
+    notes.push(
+      `${p.name} (${p.from}): ${columns.join(', ')} are a template, not its locks — columns at 0.25, 0.5 and 0.75 of the face box's width, ${turned}, each rooted on the part's art; ` +
+        `the opaque shape does not separate the locks painted inside one mass of hair, so a lock that runs elsewhere is not followed — move the chains onto the locks` +
+        ('none' in roll ? `; no head frame to turn the columns to: ${roll.none}` : ''),
+    );
     const below = newMask(P.W, P.H);
     below.data.set(mask.data);
     const [c0, c1] = pySlice(0, pyInt(chin) + 4, P.H);
@@ -1428,7 +1539,7 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       grid: g,
       r,
       segments: [
-        ['chest', rnd([axis, neckY + 18]), rnd([axis, chest[1]])],
+        trunk === null ? ['chest', rnd([axis, neckY + 18]), rnd([axis, chest[1]])] : ['chest', rnd(along(neckAt, trunk.u, 18)), rnd(chest)],
         ['head', rnd(head), rnd([axis, head[1] - 50])],
       ],
     };
@@ -1574,10 +1685,17 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     const mask = P.alpha(p);
     const top = chest[1] - 0.3 * fh;
     const bot = p.y + p.h;
-    const segs: Segment[] = [
-      ['chest', rnd([chest[0], p.y]), rnd([chest[0], hip[1] - 20])],
-      ['hip', rnd([chest[0], hip[1] - 20]), rnd([chest[0], hip[1] + 100])],
-    ];
+    const segs: Segment[] =
+      trunk === null
+        ? [
+            ['chest', rnd([chest[0], p.y]), rnd([chest[0], hip[1] - 20])],
+            ['hip', rnd([chest[0], hip[1] - 20]), rnd([chest[0], hip[1] + 100])],
+          ]
+        : [
+            // The part's top read along the trunk: the nearest its art comes to the neck end of the line.
+            ['chest', rnd(along(hip, trunk.u, artExtent(mask, p, hip, trunk.u)[0])), rnd(along(hip, trunk.u, -20))],
+            ['hip', rnd(along(hip, trunk.u, -20)), rnd(along(hip, trunk.u, 100))],
+          ];
     if (bw.length > 0 && bot < hip[1] + 0.25 * fh) {
       // A bodice that stops at the waist: robe chains down to the hem would fall off the art.
       meshes[p.name] = { grid: g, r, segments: segs };
@@ -1631,10 +1749,19 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     const mask = P.alpha(p);
     const bot = p.y + p.h;
     const y0 = hip[1] + 20;
-    const segs: Segment[] = [
+    let segs: Segment[] = [
       ['chest', rnd([chest[0], chest[1] - 30]), rnd([chest[0], hip[1] - 20])],
       ['hip', rnd([p.x + 0.09 * p.w, hip[1] + 5]), rnd([p.x + 0.91 * p.w, hip[1] + 5])],
     ];
+    if (trunk !== null) {
+      // The waist line runs across the trunk, 5 px down it from the hip, over 0.09 to 0.91 of the art's width across it.
+      const [s0, s1] = artExtent(mask, p, hip, trunk.v);
+      const waist = along(hip, trunk.u, 5);
+      segs = [
+        ['chest', rnd(along(chest, trunk.u, -30)), rnd(along(hip, trunk.u, -20))],
+        ['hip', rnd(along(waist, trunk.v, s0 + 0.09 * (s1 - s0))), rnd(along(waist, trunk.v, s0 + 0.91 * (s1 - s0)))],
+      ];
+    }
     for (const [tag, f, ph] of [
       ['skirt_r', 0.3, 0.3],
       ['skirt_c', 0.5, 0.34],
@@ -1658,6 +1785,41 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     meshes[p.name] = { grid: g, r, segments: segs };
   }
 
+  // ---- legs (issue #241)
+  // Only with joints: a legwear part whose art holds the ankle of a leg whose hip, knee and ankle are all given is
+  // meshed on a leg chain hip -> knee, tip at the ankle; without them no line below runs, and the part stays the
+  // region the trunk rule gives it, its note unchanged. No idle track is written for a leg chain: the chain is
+  // drafted whatever the pose, and a standing figure's legs are planted — whether they move is the scene's.
+  const lw = P.byTag('legwear', undefined, true).filter((p) => p.opaque_px > 500);
+  const legPlan = joints !== undefined && lw.length > 0 ? legsFromJoints(P, lw, joints) : null;
+  if (legPlan !== null && legPlan.chains !== null) {
+    for (const c of legPlan.chains) {
+      const J = (joints as RigJoints).joints;
+      const used = (n: KeypointName): Placement => placement('joint', `the ${n} joint, ${usedAs(J[n])}`, { joints: [jointRef(n)] });
+      const mid = (what: string, a: KeypointName, b: KeypointName): Placement => placement('joint', `the midpoint of the ${a} and ${b} joints (${what}) — a point between two joints, not a joint`, { joints: [jointRef(a), jointRef(b)] });
+      const why =
+        c.side === null
+          ? [mid('the hips', 'r_hip', 'l_hip'), mid('the knees', 'r_knee', 'l_knee')]
+          : [used(`${c.side}_hip`), used(`${c.side}_knee`)];
+      const tipWhy = c.side === null ? mid('the ankles', 'r_ankle', 'l_ankle') : used(`${c.side}_ankle`);
+      C(c.chain, 'hip', [c.hip, c.knee], c.ankle, why, tipWhy);
+    }
+    for (const p of lw) {
+      const [g, r] = gridR(p);
+      const segs: Segment[] = [];
+      for (const c of legPlan.chains.filter((q) => q.part === p)) {
+        // The sleeve's chest stub, laid along the thigh from the hip: 14 px above the hip to 2 px below it.
+        const len = Math.hypot(c.knee[0] - c.hip[0], c.knee[1] - c.hip[1]);
+        const d: [number, number] = [(c.knee[0] - c.hip[0]) / len, (c.knee[1] - c.hip[1]) / len];
+        segs.push(['hip', rnd([c.hip[0] - 14 * d[0], c.hip[1] - 14 * d[1]]), rnd([c.hip[0] + 2 * d[0], c.hip[1] + 2 * d[1]])], c.chain);
+      }
+      meshes[p.name] = { grid: g, r, segments: segs };
+    }
+    notes.push(...legPlan.notes);
+  } else if (legPlan !== null && legPlan.why !== null) {
+    notes.push(`${lw.map((p) => p.name).join(', ')}: no leg chain — ${legPlan.why}; the trunk rule places ${lw.length === 1 ? 'it' : 'them'}`);
+  }
+
   // Anything no rule claimed rides its nearest trunk bone rigidly, so the rig stage never meets an unassigned part.
   for (const p of P.recs) {
     if (!(p.name in meshes) && !(p.name in regions)) {
@@ -1672,6 +1834,14 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       } else notes.push(`${p.name} (${p.from}): no rule -> region on ${regions[p.name]}`);
     }
   }
+  if (trunk !== null) {
+    const laid = [...P.headFirst('neck'), ...tw, ...bw].map((p) => p.name);
+    if (laid.length > 0) {
+      notes.push(
+        `trunk segments (${laid.join(', ')}): laid along neck -> hip, the line the chest was placed on (${pyFixed((Math.atan2(trunk.u[0], trunk.u[1]) * 180) / Math.PI, 1)} degrees off the screen's downward vertical, positive towards +x): each [bone, from, to] segment the rule drafts down the screen runs along that line instead, and the waist segment across it`,
+      );
+    }
+  }
   if (joints !== undefined) {
     notes.push(
       ...jointNotes(joints, {
@@ -1680,6 +1850,7 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
         chest: chestAlong ? { neck: neckAt, hip } : null,
         sleeveRule,
         armWhy: armPlan === null ? null : armPlan.why,
+        legs: legPlan === null ? null : legPlan.chains,
         arms: armPlan === null ? null : armPlan.arms,
         wristSnap,
         eyes: (['r', 'l'] as const).map((s) => {
@@ -1689,13 +1860,95 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       }),
     );
   }
-  return { proposal: { bones, meshes, regions, motion: blink === undefined ? { duration: 4.0, tracks } : { duration: 4.0, tracks, blink }, notes }, basis: { frame, bones: records } };
+  // Issue #252: the idle is IDLE_FRAMES long, and every period drafted against the reference's 4 s idle keeps its
+  // cycles per idle (REFERENCE_IDLE_SECONDS).
+  const scale = IDLE_SECONDS / REFERENCE_IDLE_SECONDS;
+  const idleTracks = tracks.map((tr) => ({ ...tr, period: tr.period * scale }));
+  return { proposal: { bones, meshes, regions, motion: blink === undefined ? { duration: IDLE_SECONDS, tracks: idleTracks } : { duration: IDLE_SECONDS, tracks: idleTracks, blink }, notes }, basis: { frame, bones: records } };
+}
+
+/**
+ * The drafted breath (issue #252): `chest` `translatey`, its travel peak to
+ * peak {@link BREATH_FRACTION} of the height of the {@link BREATH_SIZE_TAG}
+ * layer — the box around every part from it, cut pieces included, since a cut
+ * does not shorten the torso — amplitude half of it to two decimals, and the
+ * base the amplitude. With no such part there is no height to take a fraction
+ * of, and inventing one is not done: the track keeps the reference's
+ * amplitude, {@link REFERENCE_BREATH_AMP}, and the note says so.
+ */
+export function breathTrack(P: PartSet): { track: ProposedSingleTrack; note: string } {
+  const parts = P.byTag(BREATH_SIZE_TAG, undefined, true);
+  if (parts.length === 0) {
+    const a = REFERENCE_BREATH_AMP;
+    return {
+      track: { bone: 'chest', prop: 'translatey', amp: a, period: REFERENCE_IDLE_SECONDS, phase: 0.0, base: a },
+      note: `breath: no ${BREATH_SIZE_TAG} part, so no torso height to take a fraction of: chest translatey keeps the reference's amplitude ${a} (${pyFixed(2 * a, 2)} px peak to peak), not ${pyFixed(BREATH_FRACTION * 100, 1)} % of a torso — scale it to the figure`,
+    };
+  }
+  const top = Math.min(...parts.map((p) => p.y));
+  const bottom = Math.max(...parts.map((p) => p.y + p.h));
+  const height = bottom - top;
+  const amp = roundTo((BREATH_FRACTION * height) / 2, 2);
+  const layers = [...new Set(parts.map((p) => p.from))].join(', ');
+  return {
+    track: { bone: 'chest', prop: 'translatey', amp, period: REFERENCE_IDLE_SECONDS, phase: 0.0, base: amp },
+    note: `breath: chest translatey ${pyFixed(2 * amp, 2)} px peak to peak (amp ${pyFixed(amp, 2)}, base ${pyFixed(amp, 2)}) = ${pyFixed(BREATH_FRACTION * 100, 1)} % of the torso's height, ${height} px (layer ${layers}, y ${top}..${bottom}), once per ${IDLE_FRAMES}-frame idle at ${IDLE_FPS} fps`,
+  };
 }
 
 // ---------------------------------------------------------------------------
 // external keypoints (issue #75)
 // ---------------------------------------------------------------------------
 
+/**
+ * The trunk's line (issue #243), from the neck bone's origin to the hip's, when a joint placed either end: `u` is
+ * its unit direction, down the trunk, and `v` the unit across it, `u` turned a quarter (`[u_y, -u_x]`). An upright
+ * trunk's `u` is `[0, 1]` and its `v` `[1, 0]`, the screen's y and x, which is what the vertical drafts read: each
+ * trunk segment is that draft with "down the screen" read as "along `u`" and "across the screen" as "along `v`".
+ * `null` when the two ends are one point: a line through one point has no direction.
+ */
+interface TrunkLine {
+  u: [number, number];
+  v: [number, number];
+}
+
+function trunkLineOf(neck: readonly [number, number], hip: readonly [number, number]): TrunkLine | null {
+  const dx = hip[0] - neck[0];
+  const dy = hip[1] - neck[1];
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return null;
+  const u: [number, number] = [dx / len, dy / len];
+  return { u, v: [u[1], -u[0]] };
+}
+
+/** The point `k` px from `p` along the unit direction `d`. */
+function along(p: readonly [number, number], d: readonly [number, number], k: number): [number, number] {
+  return [p[0] + k * d[0], p[1] + k * d[1]];
+}
+
+/**
+ * The extent of a part's art along the unit direction `d`, measured from `o`: the least and the greatest
+ * projection onto `d` of its opaque pixels, each taken as the unit square it covers. An axis-aligned box tight on
+ * its art therefore projects onto `[1, 0]` as its own left and right edges and onto `[0, 1]` as its top and bottom,
+ * the values the vertical drafts read off the box. A part with no opaque pixel is read as its box.
+ */
+function artExtent(mask: Mask, p: PartRecord, o: readonly [number, number], d: readonly [number, number]): [number, number] {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let y = Math.max(0, p.y); y < Math.min(mask.height, p.y + p.h); y++) {
+    for (let x = Math.max(0, p.x); x < Math.min(mask.width, p.x + p.w); x++) {
+      if (mask.data[y * mask.width + x] !== 1) continue;
+      const t = (x - o[0]) * d[0] + (y - o[1]) * d[1];
+      if (t < lo) lo = t;
+      if (t > hi) hi = t;
+    }
+  }
+  const w = lo === Infinity ? p.w : 1;
+  const h = lo === Infinity ? p.h : 1;
+  if (lo === Infinity) lo = hi = (p.x - o[0]) * d[0] + (p.y - o[1]) * d[1];
+  return [lo + Math.min(0, d[0]) * w + Math.min(0, d[1]) * h, hi + Math.max(0, d[0]) * w + Math.max(0, d[1]) * h];
+}
+
 /**
  * How far a wrist joint may lie from a handwear part's art and still be on
  * it: the LINT's own tolerance, the part's mask dilated this many px each way
@@ -1808,6 +2061,128 @@ function armsFromJoints(P: PartSet, hw: readonly PartRecord[], joints: RigJoints
   return { arms, why: null };
 }
 
+/**
+ * One leg chain drafted from joints (issue #241): its name, the side whose
+ * joints it runs through (`null` for the one chain that carries both legs,
+ * through the midpoints of the two hips, the two knees and the two ankles),
+ * its two links and tip in rig px, and the legwear part it meshes.
+ */
+interface LegChain {
+  chain: string;
+  side: 'r' | 'l' | null;
+  hip: [number, number];
+  knee: [number, number];
+  ankle: [number, number];
+  part: PartRecord;
+}
+
+/**
+ * Whether `m`'s art breaks along the straight line from `a` to `b`: walked
+ * one pixel step at a time (the larger of the x and y gaps, in steps of at
+ * most one pixel, each point read as {@link isOn} reads it), some point with
+ * no art lies between two points with art. Art that only starts or stops
+ * along the line — an end point off the art — is no break.
+ */
+function artBreaks(m: Mask, a: readonly [number, number], b: readonly [number, number]): boolean {
+  const n = Math.ceil(Math.max(Math.abs(b[0] - a[0]), Math.abs(b[1] - a[1])));
+  let seenArt = false;
+  let gapAfterArt = false;
+  for (let i = 0; i <= n; i++) {
+    const t = n === 0 ? 0 : i / n;
+    const on = isOn(m, a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1]));
+    if (on && gapAfterArt) return true;
+    if (on) seenArt = true;
+    else if (seenArt) gapAfterArt = true;
+  }
+  return false;
+}
+
+/**
+ * The leg chains a keypoint file drafts for the legwear parts, or why none
+ * is drafted (issue #241) — the sleeve's {@link armsFromJoints} for the legs.
+ * A leg is complete when its hip, knee and ankle all have a position and the
+ * hip and knee are two points; a legwear part carries a leg when the ankle
+ * lies on its art within the LINT's own tolerance ({@link WRIST_ON_PART_PX}).
+ * The joints are used only when every complete leg's ankle is on exactly one
+ * part and every legwear part carries one, as for the sleeves; when a leg is
+ * complete and they are not, `why` says so. With no complete leg nothing is
+ * drafted and `why` is `null`: the proposal is the one written before the
+ * rule existed.
+ *
+ * One chain or two is read off the part and the joints. A part carrying one
+ * leg gets that leg's chain, `leg_<side>`. A part carrying both gets one
+ * chain per leg only when its art breaks ({@link artBreaks}) along the line
+ * from r_knee to l_knee and along the line from r_ankle to l_ankle — the
+ * legs painted apart at both; otherwise the legs touch, cross or overlap in
+ * its art, two chains would pull one stretch of it two ways, and it gets one
+ * chain, `leg`, through the midpoints of the hips, the knees and the ankles.
+ * Each part gets one note saying which and why.
+ */
+function legsFromJoints(P: PartSet, lw: readonly PartRecord[], joints: RigJoints): { chains: LegChain[] | null; notes: string[]; why: string | null } {
+  const complete: Array<{ side: 'r' | 'l'; hip: [number, number]; knee: [number, number]; ankle: [number, number] }> = [];
+  const gaps: string[] = [];
+  for (const s of ['r', 'l'] as const) {
+    const hp = joints.joints[`${s}_hip`].at;
+    const kn = joints.joints[`${s}_knee`].at;
+    const an = joints.joints[`${s}_ankle`].at;
+    if (hp === null || kn === null || an === null) {
+      const absent = [hp === null ? `${s}_hip` : null, kn === null ? `${s}_knee` : null, an === null ? `${s}_ankle` : null].filter((n): n is string => n !== null);
+      gaps.push(`${absent.join(', ')} ${absent.length === 1 ? 'has' : 'have'} no position`);
+    } else if (hp[0] === kn[0] && hp[1] === kn[1]) gaps.push(`${s}_hip and ${s}_knee are one point, so the thigh has no direction`);
+    else complete.push({ side: s, hip: hp, knee: kn, ankle: an });
+  }
+  // No complete leg is the file before this rule existed: nothing is said, and the part stays the trunk rule's.
+  if (complete.length === 0) return { chains: null, notes: [], why: null };
+  const near = new Map(lw.map((p) => [p, dilate(P.alpha(p), 2 * WRIST_ON_PART_PX + 1)]));
+  const bound: Array<(typeof complete)[number] & { part: PartRecord }> = [];
+  for (const g of complete) {
+    const on = lw.filter((p) => isOn(near.get(p) as Mask, g.ankle[0], g.ankle[1]));
+    if (on.length !== 1) {
+      const where = on.length === 0 ? `the art of no legwear part within ${WRIST_ON_PART_PX} px` : `the art of ${on.length} legwear parts (${on.map((p) => p.name).join(', ')})`;
+      return { chains: null, notes: [], why: `${g.side}_ankle at ${fmtAt(g.ankle)} lies on ${where}, so it does not say which part its leg is` };
+    }
+    bound.push({ ...g, part: on[0] });
+  }
+  const idle = lw.filter((p) => !bound.some((g) => g.part === p));
+  if (idle.length > 0) {
+    const why = gaps.length > 0 ? ` (${gaps.join('; ')})` : '';
+    return { chains: null, notes: [], why: `${idle.map((p) => p.name).join(', ')} ${idle.length === 1 ? 'carries' : 'carry'} the ankle of no leg whose three joints are given${why}` };
+  }
+  const chains: LegChain[] = [];
+  const notes: string[] = [];
+  const still = 'no idle track is written for it: the chain is drafted whatever the pose, and whether the legs move is the scene\'s to key or drive';
+  for (const p of lw) {
+    const on = bound.filter((g) => g.part === p);
+    if (on.length === 1) {
+      const g = on[0];
+      chains.push({ chain: `leg_${g.side}`, side: g.side, hip: g.hip, knee: g.knee, ankle: g.ankle, part: p });
+      const other = g.side === 'r' ? 'l' : 'r';
+      const lack = complete.some((q) => q.side === other) ? `${other}_ankle lies on another part` : gaps.join('; ');
+      notes.push(`${p.name} (${p.from}): one leg chain, leg_${g.side}, hip -> knee -> ankle from the ${g.side} joints — ${g.side}_ankle lies on its art and no ${other} leg is bound to it (${lack}); ${still}`);
+      continue;
+    }
+    const [r, l] = on;
+    const m = P.alpha(p);
+    const kneesBreak = artBreaks(m, r.knee, l.knee);
+    const anklesBreak = artBreaks(m, r.ankle, l.ankle);
+    if (kneesBreak && anklesBreak) {
+      for (const g of on) chains.push({ chain: `leg_${g.side}`, side: g.side, hip: g.hip, knee: g.knee, ankle: g.ankle, part: p });
+      notes.push(
+        `${p.name} (${p.from}): one chain per leg, leg_r and leg_l, sharing its mesh — both ankles lie on its art, and its art breaks along the line from r_knee to l_knee and along the line from r_ankle to l_ankle, so the legs are painted apart; each runs hip -> knee -> ankle from its side's joints, and ${still}`,
+      );
+      continue;
+    }
+    const mid = (a: [number, number], b: [number, number]): [number, number] => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    chains.push({ chain: 'leg', side: null, hip: mid(r.hip, l.hip), knee: mid(r.knee, l.knee), ankle: mid(r.ankle, l.ankle), part: p });
+    const unbroken = [kneesBreak ? null : 'from r_knee to l_knee', anklesBreak ? null : 'from r_ankle to l_ankle'].filter((s): s is string => s !== null);
+    notes.push(
+      `${p.name} (${p.from}): one leg chain, leg, for both legs — both ankles lie on its art, and its art runs unbroken along the line ${unbroken.join(' and along the line ')}, so the legs touch, cross or overlap in it and a chain per leg would pull one stretch of art two ways; ` +
+        `the chain runs hip -> knee -> ankle through the midpoints of the two hips, the two knees and the two ankles, and ${still}`,
+    );
+  }
+  return { chains, notes, why: null };
+}
+
 /** A rig-px point as the notes and LINT lines print it: one decimal place. */
 function fmtAt(p: readonly [number, number]): string {
   return `[${pyFixed(p[0], 1)}, ${pyFixed(p[1], 1)}]`;
@@ -1833,6 +2208,8 @@ interface JointNoteFacts {
   sleeveRule: string;
   armWhy: string | null;
   arms: JointArm[] | null;
+  /** The leg chains drafted (issue #241), or `null` when none was: then no line here names a leg joint. */
+  legs: LegChain[] | null;
   /** `propose --wrist-snap`, or `null` without it. */
   wristSnap: number | null;
   eyes: ReadonlyArray<{ bone: string; part: string; at: [number, number] } | null>;
@@ -1902,6 +2279,29 @@ function jointNotes(joints: RigJoints, f: JointNoteFacts): string[] {
         `to separate them, cut one sleeve out of ${both} with an assemble.cuts entry (a polygon round it) and propose again`,
     );
   }
+  // Issue #241: the knees and ankles a leg chain was drafted from, and the hips as its first link.
+  for (const c of f.legs ?? []) {
+    const on = `the ankle${c.side === null ? 's lie' : ' lies'} on ${c.part.name}`;
+    if (c.side === null) {
+      out.push(`chain leg: link 0 is the midpoint of r_hip and l_hip, ${fmtAt(c.hip)} — the point bone hip stands on`);
+      for (const [joint, role, pair] of [
+        ['r_knee', 'link 1', 'r_knee and l_knee'],
+        ['l_knee', 'link 1', 'r_knee and l_knee'],
+        ['r_ankle', 'the tip', 'r_ankle and l_ankle'],
+        ['l_ankle', 'the tip', 'r_ankle and l_ankle'],
+      ] as const) {
+        tell(joint, `${said(joint, J[joint])}: ${usedAs(J[joint])} for chain leg, ${role}, the midpoint of ${pair} — a point between two joints, not a joint (${on})`);
+      }
+      continue;
+    }
+    out.push(`chain leg_${c.side}: link 0 is the ${c.side}_hip joint, ${fmtAt(c.hip)}`);
+    for (const [joint, role] of [
+      [`${c.side}_knee`, 'link 1'],
+      [`${c.side}_ankle`, 'the tip'],
+    ] as const) {
+      tell(joint, `${said(joint, J[joint])}: ${usedAs(J[joint])} for chain leg_${c.side}, ${role} (${on})`);
+    }
+  }
   (['r', 'l'] as const).forEach((s, i) => {
     const n = `${s}_eye` as const;
     const j = J[n];
@@ -1940,6 +2340,178 @@ function pct(v: number): string {
   return `${Math.round(v * 100)} %`;
 }
 
+/**
+ * The frontal reference the pitch proportions are written beside (issue #250):
+ * each figure's range, `[min, max]`, over three drawn faces that face front —
+ * `demo` and `scarf` as built here, and the seated character of
+ * https://github.com/rig-c/trailer (its `inputs/`, assembled by this port at
+ * the same plan) — read by {@link headFrame} with a `nose` part added to each
+ * plan, which `assemble --propose-plan` never proposes (the reference's rule):
+ * where the nose sits along eye midpoint -> mouth, demo 0.474, scarf 0.564,
+ * trailer 0.630; the stem against the bar, demo 0.629, scarf 0.675, trailer
+ * 0.510 (each on the eye bones `propose` writes). A drawn face does not carry a human face's ratios (the eyes are
+ * larger and lower, the nose a dot), so no published human model's are used.
+ *
+ * The turn is not written (issue #250): on a face painted three-quarter
+ * toward image left, the stem via the nose (skew −45.9 degrees, frontal
+ * −8.2 to 0.8) and via the mouth (−11.1, frontal −5.3 to 3.6) and the face's
+ * halves (image-left over image-right 0.681, frontal 0.839 to 1.032) all read
+ * it beyond the frontal range on the turned side, but the eyewhites' widths
+ * (0.913) read it inside the frontal range (0.898 to 1.000) — the trailer
+ * character, facing front, reads more turned by that figure than the turned
+ * face. Three readings that do not agree in order are not reported as one.
+ */
+export const FRONTAL_REFERENCE = {
+  faces: ['demo', 'scarf', 'the rig-c/trailer character'],
+  noseAlongStem: [0.474, 0.63],
+  stemOverBar: [0.51, 0.675],
+} as const;
+
+/** The centroid of a part's biggest 8-connected blob — the mouth bone's rule — or why it has none. */
+function blobPoint(P: PartSet, tag: string): FrameFeature {
+  const ps = P.headFirst(tag);
+  if (ps.length === 0) return { missing: `no part tagged ${tag}` };
+  const cc = connectedComponents(P.alpha(ps[0]), 8);
+  if (cc.count < 2) return { missing: `${ps[0].name} (${tag}) has no opaque pixel` };
+  let best = 1;
+  for (let i = 2; i < cc.count; i++) if (cc.stats[i].area > cc.stats[best].area) best = i;
+  return { part: ps[0].name, at: [cc.stats[best].cx, cc.stats[best].cy] };
+}
+
+/**
+ * The head's roll as the hair chains and their lint read it (issue #249):
+ * {@link eyeLineDegrees} on the origins of the single bones `eye_r` and
+ * `eye_l` as `bones` writes them — the one derivation of the roll, the one
+ * {@link headFrameNotes} prints and the rig turns the face bones to. With no
+ * such pair, or a pair in one column, why there is none.
+ */
+export function headRollOf(bones: readonly BoneEntry[], H: number): { degrees: number; eyes: [Point, Point] } | { none: string } {
+  const at = (n: string): Point | null => {
+    const e = bones.find((b) => 'name' in b && b.name === n);
+    return e === undefined || 'chain' in e ? null : e.at;
+  };
+  const r = at('eye_r');
+  const l = at('eye_l');
+  if (r === null || l === null) return { none: `no single bone ${[r === null ? 'eye_r' : null, l === null ? 'eye_l' : null].filter((n) => n !== null).join(' or ')}, so there is no eye line to turn to` };
+  if (r[0] === l[0]) return { none: `eye_r ${fmtAt(r)} and eye_l ${fmtAt(l)} share the column x = ${r[0]}, so the eye line has no left-to-right direction` };
+  return { degrees: eyeLineDegrees(r, l, H), eyes: [r, l] };
+}
+
+/**
+ * The px a fringe link of the template steps across its column, image-outward
+ * (issue #249 keeps it; the reference's `dx`): `bang_r`'s first link 10 px
+ * toward image-left, `bang_l`'s toward image-right, each tip 1.8 times that
+ * from its root. It is the widest step across the column the fringe rule
+ * writes in one link (the second steps 0.8 of it), so the off-lock LINT
+ * ({@link lint}) allows a link this much drift across the head's down axis.
+ */
+export const FRINGE_STEP_PX = 10;
+
+/**
+ * The runs of `mask`'s art along a column of the head's frame (issue #249):
+ * the column is the line through `foot` along the face's down axis, and the
+ * pixels it reads are those inside the part's box whose centre lies within
+ * half a pixel of that line. Ordered by the depth of their centre along the
+ * down axis, two pixels whose centres are within sqrt(2) px in depth
+ * (8-connected neighbours at most) are one run. Each run is `[start, end]`:
+ * its first centre's depth less half a pixel and its last's plus half a
+ * pixel — on the page's axes, exactly the top edge of its first row and the
+ * bottom edge of its last. Shallowest first.
+ */
+function columnRuns(mask: Mask, box: PartRecord, ax: HeadAxes, foot: readonly [number, number]): Array<[number, number]> {
+  const ds: number[] = [];
+  for (let y = box.y; y < box.y + box.h; y++) {
+    for (let x = box.x; x < box.x + box.w; x++) {
+      if (mask.data[y * mask.width + x] !== 1) continue;
+      const [a, d] = ax.of(foot, [x + 0.5, y + 0.5]);
+      if (Math.abs(a) <= 0.5) ds.push(d);
+    }
+  }
+  ds.sort((p, q) => p - q);
+  const runs: Array<[number, number]> = [];
+  for (let i = 0; i < ds.length; i++) {
+    if (i === 0 || ds[i] - ds[i - 1] > Math.SQRT2) runs.push([ds[i] - 0.5, ds[i] + 0.5]);
+    else runs[runs.length - 1][1] = ds[i] + 0.5;
+  }
+  return runs;
+}
+
+/**
+ * The depth along the face's down axis at which the column through `foot`
+ * enters the part's box (issue #249): on the page's axes, the box's top row
+ * less the foot's y, which is where the reference rooted the fringe. A column
+ * that misses the box enters it nowhere, and its corners' least depth stands
+ * in.
+ */
+function boxEntry(box: PartRecord, ax: HeadAxes, foot: readonly [number, number]): number {
+  const o = ax.at(foot, 0, 0);
+  const one = ax.at(foot, 0, 1);
+  const n: [number, number] = [one[0] - o[0], one[1] - o[1]];
+  const corners = (): number => Math.min(...[[box.x, box.y], [box.x + box.w, box.y], [box.x, box.y + box.h], [box.x + box.w, box.y + box.h]].map((c) => ax.of(foot, [c[0], c[1]])[1]));
+  let lo = -Infinity;
+  let hi = Infinity;
+  for (const [k, a, b] of [
+    [0, box.x, box.x + box.w],
+    [1, box.y, box.y + box.h],
+  ] as const) {
+    if (n[k] === 0) {
+      if (o[k] < a || o[k] > b) return corners();
+      continue;
+    }
+    const t0 = (a - o[k]) / n[k];
+    const t1 = (b - o[k]) / n[k];
+    lo = Math.max(lo, Math.min(t0, t1));
+    hi = Math.min(hi, Math.max(t0, t1));
+  }
+  return lo <= hi ? lo : corners();
+}
+
+/** `[min, max]` as `a..b` at 3 places. */
+function refRange(r: readonly [number, number] | readonly number[]): string {
+  return `${pyFixed(r[0], 3)}..${pyFixed(r[1], 3)}`;
+}
+
+/**
+ * The head frame's notes (issue #250): the bar through the eye bones'
+ * origins as `bones` writes them, its roll, the eye midpoint and the
+ * inter-eye distance; then the pitch proportions beside their frontal
+ * reference ({@link FRONTAL_REFERENCE}). The turn is read by
+ * {@link headFrame} but not written (the reference says why). A figure whose
+ * part is missing is named, never estimated.
+ * With no pair of eye bones there is no bar, and one note says why.
+ */
+export function headFrameNotes(P: PartSet, bones: readonly BoneEntry[]): string[] {
+  const at = (n: string): Point | null => {
+    const e = bones.find((b) => 'name' in b && b.name === n);
+    return e === undefined || 'chain' in e ? null : e.at;
+  };
+  const r = at('eye_r');
+  const l = at('eye_l');
+  if (r === null || l === null) {
+    const missing = [r === null ? 'eye_r' : null, l === null ? 'eye_l' : null].filter((n) => n !== null).join(' and ');
+    return [`head frame: not read — no ${missing} bone (an eye bone comes only from an eyewhite), so there is no bar to read the roll, the turn or the pitch against`];
+  }
+  if (r[0] === l[0]) return [`head frame: not read — eye_r ${fmtAt(r)} and eye_l ${fmtAt(l)} share the column x = ${r[0]}, so the bar has no left-to-right direction`];
+  const ew = (['eyewhite-r', 'eyewhite-l'] as const).map((t, i) => {
+    const p = P.byTag(t)[0];
+    return { part: p.name, mask: P.alpha(p), eye: i === 0 ? r : l };
+  });
+  const facePart = P.headFirst('face')[0];
+  const hf: HeadFrame = headFrame([r, l], P.H, { nose: blobPoint(P, 'nose'), mouth: blobPoint(P, 'mouth') }, ew, facePart === undefined ? { missing: 'no part tagged face' } : { part: facePart.name, mask: P.alpha(facePart) });
+  const f3 = (v: number): string => pyFixed(v, 3);
+  const [el, er] = hf.eyes;
+  const bar =
+    `head frame: the bar runs through ${el === l ? 'eye_l' : 'eye_r'} ${fmtAt(el)} and ${er === l ? 'eye_l' : 'eye_r'} ${fmtAt(er)}, the eye bones' origins, ${f3(hf.bar)} px; ` +
+    `roll ${f3(hf.roll)} degrees (Spine's, counter-clockwise) — the line the rig turns the face bones to and declares as invariants.axes; eye midpoint ${fmtAt(hf.mid)}`;
+  const ref = FRONTAL_REFERENCE;
+  const nose = hf.nose;
+  const mouth = hf.mouth;
+  const pitch =
+    `head pitch: the nose sits ${hf.noseAlongStem === null ? `— (not read: ${'missing' in nose ? nose.missing : 'missing' in mouth ? mouth.missing : 'the mouth sits on the bar'})` : f3(hf.noseAlongStem)} of the way from the eye midpoint to the mouth (frontal ${refRange(ref.noseAlongStem)}); ` +
+    `the stem, eye midpoint -> mouth, is ${'missing' in mouth ? `— (not read: ${mouth.missing})` : `${f3(mouth.down)} of the bar`} (frontal ${refRange(ref.stemOverBar)}); frontal ranges read on ${ref.faces.join(', ')}; the turn is not reported (src/propose.ts FRONTAL_REFERENCE says why)`;
+  return [bar, pitch];
+}
+
 /**
  * The blink squashes each eye's parts about the eye bone, so anything painted
  * into the eyelash layer above the lid — a double-eyelid crease — is squashed
@@ -2028,6 +2600,26 @@ export interface OffArtFinding {
   at: [number, number];
 }
 
+/**
+ * A link of a lock the head carries whose line leaves the lock's run (issue
+ * #249): it drifts across the head's down axis by more than the fringe
+ * template's widest step, {@link FRINGE_STEP_PX}, plus a pixel's rounding at
+ * each end. `degrees` is the link's angle off that axis and `limit` the angle
+ * that drift allows over the link's reach down the axis; a link that does not
+ * reach down the axis at all has no limit (`null`) and is named whatever its
+ * angle.
+ */
+export interface OffLockFinding {
+  kind: 'off-lock';
+  bone: string;
+  mesh: string;
+  from: [number, number];
+  to: [number, number];
+  degrees: number;
+  limit: number | null;
+  roll: number;
+}
+
 /** The hip at or above the chest: breathing and every skirt chain hang from the wrong end of the torso. */
 export interface HipAboveChestFinding {
   kind: 'hip-not-below-chest';
@@ -2087,7 +2679,7 @@ export interface ChainNotAdvancingFinding {
   toJoint: KeypointName;
 }
 
-export type LintFinding = OffArtFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding;
+export type LintFinding = OffArtFinding | OffLockFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding;
 
 /** Which rule set read the torso and the sleeve chains, under `--keypoints`. */
 export interface LintBasis {
@@ -2101,6 +2693,8 @@ export interface LintResult {
   findings: LintFinding[];
   /** Meshes naming no part in parts.json: nothing to lint them against. */
   unknownMeshes: string[];
+  /** Why the off-lock check (issue #249) read nothing though a head-run front hair mesh names a chain hung from head: no head frame, or no face box to find the chin by. Empty when it ran or had nothing to read. */
+  lockUnread: string[];
   /** Single bones the torso checks read (`hip`, `chest`) that the bones do not hold: those checks did not run. */
   missingTorsoBones: string[];
   /** Present only under `--keypoints`: the rule set that read the torso and the chains. */
@@ -2145,6 +2739,17 @@ export function coverageOutcome(c: BoneCoverage): CoverageOutcome {
  * the links `<segment><digits>`, so a single bone named as a segment has none,
  * and an explicit `[bone, from, to]` segment is a line, not an origin.
  *
+ * Then the fringe (issue #249): every chain hung from `head` that a head-run
+ * `front hair` part's mesh names, its tip no lower than the chin (the face
+ * box's bottom centre) along the head's down axis — the eye line's
+ * perpendicular, read by {@link headRollOf} — is a lock the head carries,
+ * and a link of it that drifts across that axis by more than
+ * {@link FRINGE_STEP_PX} plus sqrt(2) px (the template's widest step, and
+ * each end rounded to whole px) is named, with its angle and the angle its
+ * reach allows. A strand that hangs past the chin hangs with its weight and
+ * is not held to the head. With no head frame or no face box, `lockUnread`
+ * says why nothing was read.
+ *
  * Then the torso, which the reference did not lint: a single bone `hip` that
  * is not below a single bone `chest` (larger y), and a `hip` above
  * `HIP_MIN_FRACTION` of the figure's height (every part's union, top row to
@@ -2203,6 +2808,52 @@ export function lint(
       if (!isOn(mask, x, y)) findings.push({ kind: 'off-art', bone: n, mesh: mname, at: [x, y] });
     }
   }
+  // Issue #249: a lock the head carries runs along the head's down axis. The links read are those of every chain
+  // hung from head that a head-run front hair part's mesh names, when the chain's tip lies no lower along that axis
+  // than the chin (the face box's bottom centre): a strand that hangs past the chin hangs with its weight, not with
+  // the head, and is not held to the head's axis. The roll is headRollOf's, the one derivation.
+  const lockUnread: string[] = [];
+  const lockMeshes = Object.entries(spec.meshes).filter(([mname]) => {
+    const part = parts.get(mname);
+    return part !== undefined && splitFrom(part.from)[0] === 'head' && splitFrom(part.from)[1] === 'front hair';
+  });
+  const lockChains = lockMeshes.flatMap(([mname, m]) =>
+    m.segments.flatMap((sp) => {
+      if (typeof sp !== 'string') return [];
+      const e = spec.bones.find((b) => 'chain' in b && b.chain === sp);
+      return e !== undefined && 'chain' in e && e.parent === 'head' ? [{ mesh: mname, entry: e }] : [];
+    }),
+  );
+  if (lockChains.length > 0) {
+    const roll = headRollOf(spec.bones, P.H);
+    let chin: [number, number] | null = null;
+    try {
+      const [fx0, fy0, fw, fh] = faceBoxOf(P).box;
+      chin = [fx0 + fw / 2, fy0 + fh];
+    } catch (err) {
+      if (!(err instanceof PartsError)) throw err;
+      lockUnread.push(`no face box to find the chin by (${err.message.split('\n')[0]}), so no chain was read as a lock the head carries`);
+    }
+    if ('none' in roll) lockUnread.push(`${roll.none}, so no chain was read against the head's down axis`);
+    else if (chin !== null) {
+      const ax = headAxes(roll.degrees, P.H);
+      const mid: [number, number] = [(roll.eyes[0][0] + roll.eyes[1][0]) / 2, (roll.eyes[0][1] + roll.eyes[1][1]) / 2];
+      const chinD = ax.of(mid, chin)[1];
+      for (const { mesh, entry } of lockChains) {
+        if (ax.of(mid, entry.tip)[1] > chinD) continue;
+        const pts = [...entry.points, entry.tip];
+        entry.points.forEach((q, i) => {
+          const bone = `${entry.chain}${i}`;
+          readBy(bone, `off-lock on mesh ${pyRepr(mesh)}`);
+          const [across, down] = ax.of(q, pts[i + 1]);
+          const degrees = (Math.atan2(Math.abs(across), down) * 180) / Math.PI;
+          // A drift of FRINGE_STEP_PX across, and each end within sqrt(2)/2 px of the point it was rounded from.
+          const limit = down > 0 ? (Math.atan2(FRINGE_STEP_PX + Math.SQRT2, down) * 180) / Math.PI : null;
+          if (limit === null || degrees > limit) findings.push({ kind: 'off-lock', bone, mesh, from: [q[0], q[1]], to: [pts[i + 1][0], pts[i + 1][1]], degrees, limit, roll: roll.degrees });
+        });
+      }
+    }
+  }
   const single = (n: string): [number, number] | null => {
     const e = spec.bones.find((b) => 'name' in b && b.name === n);
     return e !== undefined && 'name' in e ? [e.at[0], e.at[1]] : null;
@@ -2254,13 +2905,14 @@ export function lint(
     }
   }
   const coverage = lintCoverage(spec, byName, read, findings, unknownMeshes, basis);
-  return basis === undefined ? { findings, unknownMeshes, missingTorsoBones, coverage } : { findings, unknownMeshes, missingTorsoBones, basis, coverage };
+  return basis === undefined ? { findings, unknownMeshes, lockUnread, missingTorsoBones, coverage } : { findings, unknownMeshes, lockUnread, missingTorsoBones, basis, coverage };
 }
 
 /** The bones a finding names: the off-art link; hip and chest for a relation between them; a chain's last link for its tip. */
 function findingBones(f: LintFinding, bones: readonly BoneEntry[]): string[] {
   switch (f.kind) {
     case 'off-art':
+    case 'off-lock':
       return [f.bone];
     case 'hip-not-below-chest':
     case 'hip-not-past-chest':
@@ -2417,6 +3069,14 @@ export function lintLine(f: LintFinding): string {
   switch (f.kind) {
     case 'off-art':
       return `LINT ${f.bone} at ${pyIntList(f.at)} is off the art of mesh ${pyRepr(f.mesh)}`;
+    case 'off-lock':
+      return (
+        `LINT ${f.bone} at ${pyIntList(f.from)} runs to ${pyIntList(f.to)} ${pyFixed(f.degrees, 1)} degrees off the head's down axis (the eye line's perpendicular, roll ${pyFixed(f.roll, 1)}), ` +
+        (f.limit === null
+          ? 'and does not reach down it at all'
+          : `more than the ${pyFixed(f.limit, 1)} its reach allows (a drift of ${FRINGE_STEP_PX} px across, the fringe template's widest step, and a pixel's rounding at each end)`) +
+        `: a lock of mesh ${pyRepr(f.mesh)} the head carries runs along the head, and this link leaves it`
+      );
     case 'hip-not-below-chest':
       return `LINT hip at ${pyIntList(f.hip)} is not below chest at ${pyIntList(f.chest)}: the hip must have the larger y, or breathing and the skirt hang from the shoulders`;
     case 'hip-too-high':