@rig-c/parts 1.9.0 → 1.10.0

package/src/parts.ts

@@ -6,7 +6,9 @@
  * came from (`from` = `<run>:<tag>`, the See-through run and tag — the only
  * thing downstream stages classify a part by — or `painting:<name>` for an
  * `assemble.patches` entry, cut from the painting itself and named for the
- * part it made, which no tag classifies), where it sits in rig pixels
+ * part it made, which no tag classifies; a part from a layer the author made
+ * is `<run>:author:<label>`, issue #256, which no tag classifies either),
+ * where it sits in rig pixels
  * (`x`/`y`/`w`/`h`, y down, origin top-left: the PNG's own box), and what the
  * assembler did to its pixels, counted:
  *
@@ -73,7 +75,7 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { type Problem, refuseIfAny } from './errors.ts';
-import { readTag } from './tags.ts';
+import { readLayerTag } from './tags.ts';
 
 export interface PartRecord {
   name: string;
@@ -134,10 +136,26 @@ export interface PartsFile {
   ghost_px: Record<string, number>;
   /** Absent in a `parts.json` the reference wrote; `assemble` always writes it. */
   recomposite?: RecompositeRecord;
+  /** Written only under `config.scene` (issue #242): the recomposite was read inside this figure; absent otherwise. */
+  scene?: SceneRecord;
 }
 
-const TOP_KEYS = ['rig_size', 'scale_rig_per_source', 'parts', 'ghost_px', 'recomposite'] as const;
-const REQUIRED_TOP_KEYS = TOP_KEYS.filter((k) => k !== 'recomposite');
+/**
+ * `parts.json`'s `scene` block (issue #242): the painting is a scene, so the
+ * `recomposite` block beside it was measured inside the figure — the rig pixels
+ * where a full-run layer's alpha is above `figure_alpha_above` — and `check`
+ * reads `RECOMPOSITE_HOLES` and the seam that way. `figure_px` is the figure's
+ * size; `figure_mask` the image `assemble` wrote of it, beside the recomposite.
+ */
+export interface SceneRecord {
+  figure_alpha_above: number;
+  figure_px: number;
+  figure_mask: string;
+}
+
+const TOP_KEYS = ['rig_size', 'scale_rig_per_source', 'parts', 'ghost_px', 'recomposite', 'scene'] as const;
+const REQUIRED_TOP_KEYS = TOP_KEYS.filter((k) => k !== 'recomposite' && k !== 'scene');
+export const SCENE_KEYS = ['figure_alpha_above', 'figure_px', 'figure_mask'] as const;
 export const RECOMPOSITE_KEYS = ['mean_abs', 'within_limit', 'within_share', 'error_limit', 'error_px', 'covered_alpha', 'uncovered_error_px', 'hole_count', 'holes_listed', 'holes'] as const;
 const RECOMPOSITE_COUNTS = ['within_limit', 'error_limit', 'error_px', 'covered_alpha', 'uncovered_error_px', 'hole_count', 'holes_listed'] as const;
 export const HOLE_KEYS = ['px', 'x', 'y', 'w', 'h', 'borders'] as const;
@@ -170,22 +188,22 @@ const COUNT_KEYS = PART_KEYS.slice(2).filter((k) => k !== FRINGE_KEY && k !== CU
 export const VISIBILITY_KEYS = ['visible_px', 'occluded_px', 'visible_not_projected_px'] as const;
 const REQUIRED_KEYS = PART_KEYS.filter((k) => !(VISIBILITY_KEYS as readonly string[]).includes(k) && k !== FRINGE_KEY && k !== CUT_FROM_KEY);
 
-/** Where a part came from: a See-through run and a v3 tag, or the painting itself for a patch. */
+/** Where a part came from: a See-through run and a v3 tag or an author-made layer's `author:<label>` (issue #256), or the painting itself for a patch. */
 export type From = { run: 'full' | 'head'; tag: string } | { run: 'painting'; patch: string };
 
 /** The `from` a patch's record carries. */
 export const PAINTING_RUN = 'painting';
 
-/** `<run>:<tag>` with run `full` or `head` and a v3 tag, `painting:<patch name>`, or null. */
+/** `<run>:<tag>` with run `full` or `head` and a v3 tag or an `author:<label>` (`full:author:hand`), `painting:<patch name>`, or null. */
 export function readFrom(from: string): From | null {
   const p = /^painting:(.+)$/.exec(from);
   if (p !== null) return { run: 'painting', patch: p[1] };
   const m = /^(full|head):(.+)$/.exec(from);
-  if (m === null || readTag(m[2]) === null) return null;
+  if (m === null || readLayerTag(m[2]) === null) return null;
   return { run: m[1] as 'full' | 'head', tag: m[2] };
 }
 
-/** The See-through tag a part came from, or null for a `painting:` patch (or a `from` that is neither). */
+/** The tag a part came from — a See-through tag, or an author-made layer's `author:<label>`, which no role reader matches — or null for a `painting:` patch (or a `from` that is neither). */
 export function tagOf(from: string): string | null {
   const f = readFrom(from);
   return f === null || f.run === 'painting' ? null : f.tag;
@@ -207,6 +225,7 @@ export function serializeParts(file: PartsFile): string {
             holes: file.recomposite.holes.map((h) => ({ ...Object.fromEntries(HOLE_KEYS.filter((k) => k !== 'borders').map((k) => [k, h[k]])), borders: h.borders.map((b) => ({ part: b.part, px: b.px })) })),
           },
         }),
+    ...(file.scene === undefined ? {} : { scene: Object.fromEntries(SCENE_KEYS.map((k) => [k, (file.scene as SceneRecord)[k]])) }),
   };
   return `${JSON.stringify(ordered, null, 2)}\n`;
 }
@@ -257,7 +276,7 @@ function checkParts(raw: unknown, path: string): PartsFile {
     if (typeof g !== 'object' || g === null || Array.isArray(g)) fail('PARTS_FIELD_TYPE', `${path} field "ghost_px"`, `is ${show(g)}; an object of "<run>:<tag>" -> pixels is required`);
     else {
       for (const [k, v] of Object.entries(g as Record<string, unknown>)) {
-        if (tagOf(k) === null) fail('PARTS_FROM_KNOWN', `${path} ghost_px key "${k}"`, 'is not "<full|head>:<v3 tag>" (a patch has no See-through layer, so no ghost count)');
+        if (tagOf(k) === null) fail('PARTS_FROM_KNOWN', `${path} ghost_px key "${k}"`, 'is not "<full|head>:<v3 tag>" or "<full|head>:author:<label>" (a patch has no See-through layer, so no ghost count)');
         if (!(Number.isInteger(v) && (v as number) >= 0)) fail('PARTS_FIELD_TYPE', `${path} ghost_px "${k}"`, `is ${show(v)}; a pixel count is required`);
       }
     }
@@ -284,7 +303,7 @@ function checkParts(raw: unknown, path: string): PartsFile {
       } else if (seen.has(r.name)) fail('PARTS_NAME_UNIQUE', label, `appears at parts[${seen.get(r.name)}] and parts[${i}]`);
       else seen.set(r.name, i);
       const from = typeof r.from === 'string' ? readFrom(r.from) : null;
-      if (from === null) fail('PARTS_FROM_KNOWN', `${label} field "from"`, `is ${show(r.from)}; "<full|head>:<v3 tag>", or "painting:<the part's own name>" for a patch, is required`);
+      if (from === null) fail('PARTS_FROM_KNOWN', `${label} field "from"`, `is ${show(r.from)}; "<full|head>:<v3 tag>", "<full|head>:author:<label>" for a layer the author made, or "painting:<the part's own name>" for a patch, is required`);
       else if (from.run === 'painting' && from.patch !== r.name) {
         fail('PARTS_FROM_KNOWN', `${label} field "from"`, `is ${show(r.from)}; a patch's provenance names the patch itself, so "painting:${String(r.name)}" is required`);
       }
@@ -355,6 +374,18 @@ function checkParts(raw: unknown, path: string): PartsFile {
       else if (b.from !== r.from) fail('PARTS_CUT_FROM_KNOWN', object, `names "${base}", whose from is ${show(b.from)}; this piece's is ${show(r.from)}, and a piece shares its base's layer`);
     }
   }
+  if ('scene' in o) {
+    const sc = o.scene;
+    if (typeof sc !== 'object' || sc === null || Array.isArray(sc)) fail('PARTS_FIELD_TYPE', `${path} field "scene"`, `is ${show(sc)}; an object is required`);
+    else {
+      const r = sc as Record<string, unknown>;
+      for (const k of Object.keys(r)) if (!(SCENE_KEYS as readonly string[]).includes(k)) fail('PARTS_KEY_KNOWN', `${path} scene key "${k}"`, `is not a scene field; known: ${SCENE_KEYS.join(', ')}`);
+      for (const k of SCENE_KEYS) if (!(k in r)) fail('PARTS_FIELD_PRESENT', `${path} scene field "${k}"`, 'is absent and required');
+      for (const k of ['figure_alpha_above', 'figure_px'] as const) if (k in r && !(Number.isInteger(r[k]) && (r[k] as number) >= 0)) fail('PARTS_FIELD_TYPE', `${path} scene field "${k}"`, `is ${show(r[k])}; a non-negative integer is required`);
+      if ('figure_mask' in r && !(typeof r.figure_mask === 'string' && r.figure_mask !== '')) fail('PARTS_FIELD_TYPE', `${path} scene field "figure_mask"`, `is ${show(r.figure_mask)}; the mask's file name is required`);
+      if (!('recomposite' in o)) fail('PARTS_FIELD_PRESENT', `${path} field "recomposite"`, 'is absent; a scene block says how the recomposite block beside it was measured, so it is required with one');
+    }
+  }
   if ('recomposite' in o && sizeOk) {
     const names = Array.isArray(o.parts) ? new Set(o.parts.map((p) => (typeof p === 'object' && p !== null ? (p as Record<string, unknown>).name : undefined)).filter((n): n is string => typeof n === 'string')) : new Set<string>();
     checkRecomposite(o.recomposite, path, size as [number, number], names, fail);

package/src/propose.ts

@@ -43,7 +43,10 @@
  *   strand and what became of it — a strand left without a chain is never
  *   silent (issue #24).
  * - anything no rule claims rides its nearest trunk bone as a region —
- *   including every `painting:` patch (`assemble.patches`), which has no tag,
+ *   including every part from an author-made layer (`<run>:author:<label>`,
+ *   issue #256), which is no See-through tag and so has no role: no rule
+ *   reads it, and its note says the bone is the config's to name — and
+ *   every `painting:` patch (`assemble.patches`), which has no tag,
  *   so no rule above ever reads it: it is never a mesh or a chain, it moves
  *   no bone the rules place, and the note says the bone is the config's to
  *   name in `regions.<name>`. A cut's piece (`assemble.cuts`, recorded with
@@ -99,8 +102,8 @@
  *
  * 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
+ * with it, and the chest's breath travels {@link BREATH_FRACTION} of the torso's
+ * length, neck to hip ({@link breathTrack}; issue #270), 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
@@ -130,7 +133,9 @@ 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';
-import { TURN_BONE, turnFractions, turnNearest, turnPivot, type TurnSpec } from './turn.ts';
+import { AUTHOR_NO_ROLE, isAuthorTag } from './tags.ts';
+import { TURN_BONE, TURN_CARRIER_TAG, TURN_PLACES, TURN_RIDER_OFFSET, TURN_RIDER_TAGS, turnFractions, turnNearest, turnPivot, turnRiderDepth, type TurnSpec } from './turn.ts';
+import { edgeLength } from './length.ts';
 
 // ---------------------------------------------------------------------------
 // the output shape — config-shaped, key order as the reference writes it
@@ -188,20 +193,60 @@ export const IDLE_SECONDS = IDLE_FRAMES / IDLE_FPS;
  */
 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 %.
+ * The breath's travel, peak to peak, as a fraction of the torso (issue #252):
+ * HQ's calibration, about 2.5 %. Issue #252 took the torso as the `topwear`
+ * part's height; on the trailer's seated character that is 267 px, 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 %. Issue #270 measures the torso as the trunk the rig
+ * has instead — the neck bone to the hip bone, {@link breathTrack} — because a
+ * garment's box is not the body: `scarf`'s sweater runs to the thighs (690 px)
+ * and breathed 2.9 times as deep as `demo`.
  */
 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. */
+/** The breath's amplitude the reference drafted on every figure, kept only where the trunk has no length 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';
+
+/**
+ * How a drafted lattice's spacing (`meshes.<part>.grid`) is chosen (issue #265):
+ *
+ * - `figure`, the default: one spacing for the figure, `round(H / FIGURE_GRID_DIVISOR)` rig px, H the height of the
+ *   union of every part's box in parts.json ({@link figureGrid}); a part whose own spacing (the `part` rule) is
+ *   already coarser keeps its own. `r` is the `part` rule's either way, so the weights a vertex would take at a point
+ *   do not move, only where the vertices are.
+ * - `part`: the reference implementation's rule, a tenth of the part's own short side, clamped to 5..36. The
+ *   oracle examples (`reference-demo`, `reference-sample`) are proposed under it, because their `proposal.json` holds
+ *   this proposer to the reference's.
+ */
+export type GridRule = 'figure' | 'part';
+export const GRID_RULES: readonly GridRule[] = ['figure', 'part'];
+export const DEFAULT_GRID_RULE: GridRule = 'figure';
+
+/**
+ * The divisor of the figure's spacing: Stage A of issue #265 (docs/evidence/density-survey.md) built every lattice
+ * of demo, scarf and the public trailer at round(H / c) for c in {26, 37, 52}; 37 is the coarsest at which every
+ * `check` bar passed on all three (c 26 failed scarf's TIP_OVER_ROOT). Calibrated on those three figures only, all
+ * of similar size (H 1106, 1108 and 1185 rig px).
+ */
+export const FIGURE_GRID_DIVISOR = 37;
+
+/** The largest idle displacement Stage A measured at {@link FIGURE_GRID_DIVISOR} against each example's finer lattice, rig px (the trailer's hairpin), which no `check` bar reads. */
+export const FIGURE_GRID_IDLE_PX = 1.427;
+
+/** The figure's spacing: the union of every part's box in parts.json, its height H, and round(H / {@link FIGURE_GRID_DIVISOR}). */
+export function figureGrid(recs: readonly PartRecord[]): { top: number; bottom: number; height: number; grid: number } {
+  const top = Math.min(...recs.map((r) => r.y));
+  const bottom = Math.max(...recs.map((r) => r.y + r.h));
+  const height = bottom - top;
+  return { top, bottom, height, grid: pyInt(pyRound(height / FIGURE_GRID_DIVISOR)) };
+}
+
+/** The `part` rule's spacing and the weight falloff `r` both rules draft (the reference's). */
+export function partGrid(p: { w: number; h: number }): [number, number] {
+  const g = pyInt(Math.min(36, Math.max(5, pyRound(Math.min(p.w, p.h) / 10))));
+  return [g, Math.max(3, pyInt(pyRound(g * 0.42)))];
+}
 
 export interface Proposal {
   bones: BoneEntry[];
@@ -389,48 +434,57 @@ export type TurnRuns = Partial<Record<'full' | 'head', LayerSet>>;
 
 /**
  * Draft `turn` (issue #251, `src/turn.ts`) from the parts and the See-through
- * runs they came from: each part's depth is its layer's `depth_median` — the
- * layer of its run named by its tag, a cut's piece its base's — and the pivot
- * is {@link turnPivot} over the parts' `opaque_px`. A `painting:` patch has no
- * layer and so no depth: it is not carried, and a note names it. What a depth
- * cannot be read for is refused by name, every one at once:
+ * runs they came from: each carrier's depth is its layer's `depth_median` —
+ * the layer of the run its part was assembled from, named by its tag, a cut's
+ * piece its base's — and the pivot is {@link turnPivot} over the parts'
+ * `opaque_px`. A `painting:` patch has no layer and so no depth: it is not
+ * carried, and a note names it. What a depth cannot be read for is refused by
+ * name, every one at once:
  *
  * - `PROPOSE_TURN_RUN_GIVEN`: a part from a run whose layers were not given.
  * - `PROPOSE_TURN_LAYER_PRESENT`: the run given holds no layer of the part's tag.
  * - `PROPOSE_TURN_DEPTH_PRESENT`: the layer carries no depth (a PSD carries none).
  *
+ * A rider (issue #271, {@link TURN_RIDER_TAGS}: the eye group, nose, mouth)
+ * does not carry its own median: it takes the face part's, offset by
+ * {@link turnRiderDepth} by draw order. With no face part, or more than one,
+ * the riders keep their own medians and a note says so. Every other layer is
+ * its own carrier.
+ *
  * With no part to carry, or every carried part at one depth (nothing nearer
  * than the pivot), no `turn` is drafted and a note says why. Otherwise one note
  * states the pivot and its rule, the law, and every part's fraction with the
- * depth it came from.
+ * depth it came from; one lists where each depth came from; and one line names
+ * each carrier the other run places more than {@link TURN_RUN_APART} of the
+ * span away.
  */
 export function draftTurn(P: PartSet, runs: TurnRuns): { turn: TurnSpec | null; notes: string[] } {
   const problems: Problem[] = [];
-  const rows: Array<{ part: string; depth: number; area: number }> = [];
+  const read: Array<{ part: string; run: 'full' | 'head'; tag: string; base: string | null; own: number; area: number; order: number; piece: boolean }> = [];
   const patches: string[] = [];
   const unread = new Map<string, string[]>();
-  for (const r of P.recs) {
+  P.recs.forEach((r, order) => {
     const [run, tag] = splitFrom(r.from);
     if (run === PAINTING_RUN) {
       patches.push(r.name);
-      continue;
+      return;
     }
     const set = run === 'full' || run === 'head' ? runs[run] : undefined;
     if (set === undefined) {
       unread.set(run, [...(unread.get(run) ?? []), r.name]);
-      continue;
+      return;
     }
     const layer = set.layers.find((l) => l.name === tag);
     if (layer === undefined) {
       problems.push({ code: 'PROPOSE_TURN_LAYER_PRESENT', object: `part "${r.name}" (${r.from})`, detail: `came from the ${run} run's "${tag}" layer, and ${set.source} holds no layer of that name; the run its parts were assembled from is required` });
-      continue;
+      return;
     }
     if (layer.depth === null) {
       problems.push({ code: 'PROPOSE_TURN_DEPTH_PRESENT', object: `part "${r.name}" (${r.from})`, detail: `its layer in ${set.source} carries no depth_median (a ${set.form} input); the turn orders parts by See-through's per-layer depth, so a run that carries one is required` });
-      continue;
+      return;
     }
-    rows.push({ part: r.name, depth: layer.depth, area: r.opaque_px });
-  }
+    read.push({ part: r.name, run: run as 'full' | 'head', tag, base: 'base' in layer.tag ? layer.tag.base : null, own: layer.depth, area: r.opaque_px, order, piece: r.cut_from !== undefined });
+  });
   for (const [run, names] of unread) {
     problems.push({ code: 'PROPOSE_TURN_RUN_GIVEN', object: `the ${run} run`, detail: `part(s) ${names.map((n) => `"${n}"`).join(', ')} came from it and its layers were not given; --${run} <dir | layers.json> is required to read their depth` });
   }
@@ -439,6 +493,22 @@ export function draftTurn(P: PartSet, runs: TurnRuns): { turn: TurnSpec | null;
   if (patches.length > 0) {
     notes.push(`turn: painting patch(es) ${patches.map((n) => `"${n}"`).join(', ')} carry no See-through depth and are not carried — each moves only as its bone does, as the pivot depth does; a value in config.turn.depths carries one`);
   }
+  // Issue #271: the riders take the face's depth; everything else is its own carrier.
+  // An author-made layer (issue #256) has no tag, so it is neither a rider nor the carrier: it carries itself at its own depth.
+  const isRider = (x: { base: string | null }): boolean => x.base !== null && TURN_RIDER_TAGS.includes(x.base);
+  const faces = read.filter((x) => x.base === TURN_CARRIER_TAG && !x.piece);
+  const face = faces.length === 1 ? faces[0] : null;
+  const riders = read.filter(isRider);
+  if (riders.length > 0 && face === null) {
+    notes.push(
+      `turn: rider(s) ${riders.map((x) => `"${x.part}"`).join(', ')} keep their own See-through depth_median: ${faces.length === 0 ? `no part comes from a "${TURN_CARRIER_TAG}" layer` : `${faces.length} parts (${faces.map((x) => `"${x.part}"`).join(', ')}) come from a "${TURN_CARRIER_TAG}" layer, and which one carries them cannot be read off the parts`} — a value in config.turn.depths sets one`,
+    );
+  }
+  const rows = read.map((x) => {
+    if (face === null || !isRider(x)) return { ...x, depth: x.own, source: `own, ${x.run}:${x.tag}` };
+    const above = x.order > face.order;
+    return { ...x, depth: turnRiderDepth(face.own, above), source: `"${face.part}" ${above ? '-' : '+'} ${TURN_RIDER_OFFSET}, drawn ${above ? 'above' : 'under'} it; own ${x.run}:${x.tag} ${x.own}` };
+  });
   const pivot = turnPivot(rows);
   const depths = Object.create(null) as Record<string, number>;
   for (const r of rows) depths[r.part] = r.depth;
@@ -454,17 +524,36 @@ export function draftTurn(P: PartSet, runs: TurnRuns): { turn: TurnSpec | null;
   const turn: TurnSpec = { pivot, depths };
   const fr = turnFractions(turn, rows.map((r) => r.part));
   notes.push(
-    `turn: control "${TURN_BONE}" under root, keyed by nothing — its x is the dial. Pivot depth ${pivot}: the mean of the ${rows.length} carried parts' See-through depth_median weighted by opaque_px, the one depth at which the painted pixels' centroid does not slide (correct it in turn.pivot). ` +
+    `turn: control "${TURN_BONE}" under root, keyed by nothing — its x is the dial. Pivot depth ${pivot}: the mean of the ${rows.length} carried parts' depths weighted by opaque_px, the one depth at which the painted pixels' centroid does not slide (correct it in turn.pivot). ` +
       `Each part travels (pivot - depth) / (pivot - ${nearest.depth}) of the control's x, "${nearest.part}" (nearest) all of it: ${fr.map((f) => `${f.part} ${f.fraction} (depth ${f.depth})`).join(', ')}`,
   );
+  notes.push(`turn: where each depth came from — ${rows.map((r) => `${r.part} ${r.depth} (${r.source})`).join('; ')}`);
+  // Issue #271: a carrier the other run places elsewhere is named; the run read stays the part's own.
+  const span = pivot - nearest.depth;
+  for (const r of rows) {
+    if (isRider(r) && face !== null) continue;
+    const other = r.run === 'full' ? 'head' : 'full';
+    const there = runs[other]?.layers.find((l) => l.name === r.tag);
+    if (there === undefined || there.depth === null || there.opaquePx === 0 || !(there.depth < 1)) continue;
+    if (Math.abs(there.depth - r.own) > TURN_RUN_APART * span) {
+      notes.push(`turn: "${r.part}" reads ${r.own} in the ${r.run} run and ${there.depth} in the ${other} run, more than ${TURN_RUN_APART * 100} % of the span ${roundTo(span, TURN_PLACES)} apart; the ${r.run} run it was assembled from is read`);
+    }
+  }
   notes.push(...TURN_DEPTH_CAVEAT);
   return { turn, notes };
 }
 
-/** The notes beside every drafted turn (issue #251): what a See-through depth is, where it misleads, and that the two runs' axes are not reconciled. */
+/**
+ * The share of the span (`pivot − nearest`) past which a carrier's two runs
+ * are said to disagree: issue #271's judgment line, set before it was measured
+ * (from #251's record). It only writes a note; the run read does not change.
+ */
+export const TURN_RUN_APART = 0.1;
+
+/** The notes beside every drafted turn (issues #251, #271): what a See-through depth is, where it misleads, and that the two runs' axes are not reconciled. */
 export const TURN_DEPTH_CAVEAT: readonly string[] = [
-  "turn: depth is the See-through layer's median and each part takes its own run's axis; a seated or forward-reaching limb can read further back than it is (trailer legwear 0.770 sits behind the pivot)",
-  "turn: the two runs' depth axes are not reconciled (parts#271)",
+  "turn: depth is the See-through layer's median, a carrier's read from the run its part was assembled from and a rider's (eye group, nose, mouth) taken from the face; a seated or forward-reaching limb can read further back than it is (trailer legwear 0.770 sits behind the pivot)",
+  "turn: the two runs' depth axes are not reconciled — a linear map cannot reconcile them, since the runs order the shared layers differently (parts#271)",
 ];
 
 /** The proposal with `turn` written after `motion` and `notes` extended; the proposal itself when `turn` is null. */
@@ -1012,8 +1101,8 @@ const SIDES = [
  * which rule stood in; without it every value and note is the one this
  * function wrote before the parameter existed.
  */
-export function propose(P: PartSet, joints?: RigJoints, wristSnap: number | null = null): Proposal {
-  return proposeWithBasis(P, joints, wristSnap).proposal;
+export function propose(P: PartSet, joints?: RigJoints, wristSnap: number | null = null, gridRule: GridRule = DEFAULT_GRID_RULE): Proposal {
+  return proposeWithBasis(P, joints, wristSnap, gridRule).proposal;
 }
 
 /**
@@ -1026,7 +1115,7 @@ export function propose(P: PartSet, joints?: RigJoints, wristSnap: number | null
  * `joints`: see {@link armsFromJoints}. `null` is the built-in tolerance
  * alone, and every value and note is the one written before it existed.
  */
-export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: number | null = null): { proposal: Proposal; basis: ProposalBasis } {
+export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: number | null = null, gridRule: GridRule = DEFAULT_GRID_RULE): { proposal: Proposal; basis: ProposalBasis } {
   // Issue #230: a piece is not given its base's rule a second time, which
   // needs to know which part is the piece. A file that cannot say is refused
   // here, and only here: every other reader of parts.json still takes it.
@@ -1270,10 +1359,12 @@ 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);
+  // Issue #252: the breath's travel is BREATH_FRACTION of the torso, not the reference's fixed 1.3 px amplitude; issue
+  // #270: the torso is the neck -> hip run as the two bones are written above, not a garment's height. 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 trunk of no length (neck and hip on one point) keeps the reference's amplitude, and a note.
+  const writtenAt = (n: string): Point => (bones.find((b) => 'name' in b && b.name === n) as { at: Point }).at;
+  const breath = breathTrack(writtenAt('neck'), writtenAt('hip'));
   notes.push(breath.note);
   tracks.push(
     breath.track,
@@ -1282,9 +1373,13 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
     { bone: 'neck', prop: 'rotate', amp: 0.35, period: 4.0, phase: 0.08 },
   );
 
+  // Issue #265: the figure's spacing unless the reference's rule is asked for; r is the part rule's either way.
+  const fig = figureGrid(P.recs);
+  const ownGrid = new Map<string, number>();
   const gridR = (p: PartRecord): [number, number] => {
-    const g = pyInt(Math.min(36, Math.max(5, pyRound(Math.min(p.w, p.h) / 10))));
-    return [g, Math.max(3, pyInt(pyRound(g * 0.42)))];
+    const [g, r] = partGrid(p);
+    ownGrid.set(p.name, g);
+    return [gridRule === 'part' ? g : Math.max(g, fig.grid), r];
   };
 
   // ---- back hair
@@ -1680,7 +1775,7 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       const [g, r] = gridR(p);
       const segs: Segment[] = [];
       for (const a of armPlan.arms.filter((q) => q.part === p)) {
-        const len = Math.hypot(a.elbow[0] - a.shoulder[0], a.elbow[1] - a.shoulder[1]);
+        const len = edgeLength(a.elbow[0] - a.shoulder[0], a.elbow[1] - a.shoulder[1]);
         const d: [number, number] = [(a.elbow[0] - a.shoulder[0]) / len, (a.elbow[1] - a.shoulder[1]) / len];
         segs.push(['chest', rnd([a.shoulder[0] - 14 * d[0], a.shoulder[1] - 14 * d[1]]), rnd([a.shoulder[0] + 2 * d[0], a.shoulder[1] + 2 * d[1]])], `sleeve_${a.side}`);
       }
@@ -1919,7 +2014,7 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       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 len = edgeLength(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);
       }
@@ -1937,6 +2032,9 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       regions[p.name] = cy < neckY ? 'head' : cy < hip[1] ? 'chest' : 'hip';
       if (splitFrom(p.from)[0] === PAINTING_RUN) {
         notes.push(`${p.name} (${p.from}): a painting patch has no tag, so no rule -> region on ${regions[p.name]}, the nearest trunk bone; config.regions.${p.name} is the bone it rides`);
+      } else if (isAuthorTag(splitFrom(p.from)[1])) {
+        // Issue #256: no rule reads an author-made layer, and none is guessed for it.
+        notes.push(`${p.name} (${p.from}): ${AUTHOR_NO_ROLE}; no rule reads it -> region on ${regions[p.name]}, the nearest trunk bone, until config.regions.${p.name} names the bone it rides`);
       } else if (p.cut_from !== undefined) {
         notes.push(
           `${p.name} (${p.from}): a piece an assemble.cuts entry took from ${p.cut_from}, so not given that layer's rule a second time (it would name ${p.cut_from}'s bones and chains again) -> region on ${regions[p.name]}, the nearest trunk bone; config.regions.${p.name} is the bone it rides, and a mesh in config.meshes is the author's to give it`,
@@ -1952,6 +2050,10 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
       );
     }
   }
+  if (gridRule === 'figure') {
+    const latt = Object.keys(meshes).filter((m) => 'grid' in meshes[m] && ownGrid.has(m));
+    if (latt.length > 0) notes.push(gridNote(fig, latt.map((m) => [m, ownGrid.get(m) as number])));
+  }
   if (joints !== undefined) {
     notes.push(
       ...jointNotes(joints, {
@@ -1978,31 +2080,45 @@ export function proposeWithBasis(P: PartSet, joints?: RigJoints, wristSnap: numb
 }
 
 /**
- * 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.
+ * The note the `figure` grid rule writes (issue #265): the spacing and where it came from, per lattice part its own
+ * spacing and the one drafted, what it costs and what it was calibrated on.
  */
-export function breathTrack(P: PartSet): { track: ProposedSingleTrack; note: string } {
-  const parts = P.byTag(BREATH_SIZE_TAG, undefined, true);
-  if (parts.length === 0) {
+export function gridNote(fig: { top: number; bottom: number; height: number; grid: number }, parts: ReadonlyArray<readonly [string, number]>): string {
+  const took = parts.filter(([, g]) => g < fig.grid).map(([m, g]) => `${m} ${g} -> ${fig.grid}`);
+  const kept = parts.filter(([, g]) => g >= fig.grid).map(([m, g]) => `${m} ${g}`);
+  return (
+    `mesh spacing: grid ${fig.grid} = round(H / ${FIGURE_GRID_DIVISOR}), H ${fig.height} rig px the height of every part's box together (rows ${fig.top} to ${fig.bottom}), in place of a tenth of each part's short side (${took.length > 0 ? took.join(', ') : 'none'}; kept, already as coarse: ${kept.length > 0 ? kept.join(', ') : 'none'}); r is the part's own. ` +
+    `Calibrated on three figures of similar size (H 1106-1185 rig px, issue #265 Stage A), where every check bar passed at this divisor and the idle moved by up to ${FIGURE_GRID_IDLE_PX} rig px against the finer lattice — no bar reads that. propose --grid-rule part drafts the part's own spacing`
+  );
+}
+
+/**
+ * The drafted breath (issues #252, #270): `chest` `translatey`, its travel peak
+ * to peak {@link BREATH_FRACTION} of the torso's length — the distance from the
+ * `neck` bone's origin to the `hip` bone's, as the proposal writes them (so the
+ * figure can be recomputed from proposal.json): the run the chest is placed
+ * half way along and the trunk segments are laid along (issue #243), whichever
+ * rule placed the two ends (joints, the face and bottomwear, the waist, or the
+ * figure's proportion — the hip's own note names it). Amplitude half of it to
+ * two decimals, and the base the amplitude. When neck and hip are one point the
+ * trunk has no length 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(neck: readonly [number, number], hip: readonly [number, number]): { track: ProposedSingleTrack; note: string } {
+  const length = edgeLength(hip[0] - neck[0], hip[1] - neck[1]);
+  const run = `neck ${pyIntList(neck)} -> hip ${pyIntList(hip)}`;
+  if (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`,
+      note: `breath: ${run} are one point, so the trunk has no length 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(', ');
+  const amp = roundTo((BREATH_FRACTION * length) / 2, 2);
   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`,
+    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 length, ${pyFixed(length, 1)} px (${run}), once per ${IDLE_FRAMES}-frame idle at ${IDLE_FPS} fps`,
   };
 }
 
@@ -2025,7 +2141,7 @@ interface TrunkLine {
 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);
+  const len = edgeLength(dx, dy);
   if (len === 0) return null;
   const u: [number, number] = [dx / len, dy / len];
   return { u, v: [u[1], -u[0]] };
@@ -2418,7 +2534,7 @@ function jointNotes(joints: RigJoints, f: JointNoteFacts): string[] {
     if (j.at === null) return;
     const e = f.eyes[i];
     if (e === null) tell(n, `${said(n, j)}: no bone takes it — an eye bone comes only from an eyewhite part`);
-    else tell(n, `${said(n, j)}: bone ${e.bone} is measured off ${e.part} (its box centre ${fmtAt(e.at)}) and is not moved; the joint is ${pyFixed(Math.hypot(j.at[0] - e.at[0], j.at[1] - e.at[1]), 1)} px from it`);
+    else tell(n, `${said(n, j)}: bone ${e.bone} is measured off ${e.part} (its box centre ${fmtAt(e.at)}) and is not moved; the joint is ${pyFixed(edgeLength(j.at[0] - e.at[0], j.at[1] - e.at[1]), 1)} px from it`);
   });
   const rest = KEYPOINT_NAMES.filter((n) => !told.has(n));
   if (rest.length > 0) out.push(`no rule reads ${rest.map((n) => said(n, J[n])).join(', ')} — no bone is authored from them`);
@@ -2985,8 +3101,8 @@ export function lint(
     if (chest !== null && !(along(chest) > 0 && along(chest) < 1)) findings.push({ kind: 'chest-not-between', chest, t: along(chest), neck: T.neck, hips: T.hips });
     if (hip !== null && chest !== null && along(hip) <= along(chest)) findings.push({ kind: 'hip-not-past-chest', hip, chest, tHip: along(hip), tChest: along(chest) });
     if (hip !== null) {
-      const dNeck = Math.hypot(hip[0] - T.neck[0], hip[1] - T.neck[1]);
-      const dHips = Math.hypot(hip[0] - T.hips[0], hip[1] - T.hips[1]);
+      const dNeck = edgeLength(hip[0] - T.neck[0], hip[1] - T.neck[1]);
+      const dHips = edgeLength(hip[0] - T.hips[0], hip[1] - T.hips[1]);
       if (dNeck < dHips) findings.push({ kind: 'hip-nearer-neck', hip, neck: T.neck, hips: T.hips, dNeck, dHips });
     }
   } else {
@@ -3003,7 +3119,7 @@ export function lint(
     for (const c of basis.chains) {
       if (c.line === null) continue;
       const { from, to } = c.line;
-      const len = Math.hypot(to[0] - from[0], to[1] - from[1]);
+      const len = edgeLength(to[0] - from[0], to[1] - from[1]);
       const e = spec.bones.find((b) => 'chain' in b && b.chain === c.chain);
       if (e === undefined || !('chain' in e)) continue;
       const pts: Array<[string, Point]> = [...e.points.map((q, i): [string, Point] => [`${c.chain}${i}`, q]), [`${c.chain} tip`, e.tip]];
@@ -3215,7 +3331,7 @@ export function compare(proposal: readonly BoneEntry[], config: readonly BoneEnt
   const rows: Array<[string, number]> = [];
   for (const [n, cb] of b) {
     const pb = a.get(n);
-    if (pb !== undefined) rows.push([n, Math.hypot(pb.x - cb.x, pb.y - cb.y)]);
+    if (pb !== undefined) rows.push([n, edgeLength(pb.x - cb.x, pb.y - cb.y)]);
   }
   return { rows, onlyConfig: [...b.keys()].filter((n) => !a.has(n)), onlyProposal: [...a.keys()].filter((n) => !b.has(n)) };
 }
@@ -3284,7 +3400,7 @@ function line(r: Raster, a: readonly [number, number], b: readonly [number, numb
 function dot(r: Raster, cx: number, cy: number): void {
   for (let dy = -4; dy <= 4; dy++) {
     for (let dx = -4; dx <= 4; dx++) {
-      const d = Math.hypot(dx, dy);
+      const d = edgeLength(dx, dy);
       if (d <= 3.5) setPx(r, Math.round(cx) + dx, Math.round(cy) + dy, [255, 0, 0]);
       else if (d <= 4.5) setPx(r, Math.round(cx) + dx, Math.round(cy) + dy, [0, 0, 0]);
     }