@rig-c/parts 1.12.0 → 1.13.0

package/README.md

@@ -228,7 +228,7 @@ than queueing behind someone else's job.
 ## The loop, for an agent
 
 ```sh
-rig-parts inputs --source painting.png --config config.json --out inputs   # st_input_full.png
+rig-parts inputs --source painting.png --config config.json --out inputs   # st_input_full.png; the config needs assemble.rig_scale
 #    See-through on st_input_full.png (external, or `rig-parts comfy seethrough`) -> layers/full
 rig-parts layers layers/full                      # every layer: box, opaque px, depth, plausibility figures; WARN lines
 rig-parts propose --head-box --full layers/full --canvas 1664x2432
@@ -323,9 +323,13 @@ These are limits of the approach, stated so nobody reads more into a green run:
   existence proof, not a rate.
 - **`loop` writes GIF and APNG (lossless and indexed), not WebP**: an animated WebP needs a VP8/VP8L
   encoder, which this package does not carry.
-- **The proposer assumes a standing figure unless it is told the pose.** Its ratios
-  put the hip below the chest and hang the sleeves from the shoulders. A seated or
-  reclining figure needs `propose --keypoints`, a file of its joints from any pose
+- **The proposer reads the torso by screen y unless it is told the pose.** Its ratios
+  put the hip below `bottomwear`'s top edge and the chest above it, and hang the sleeves
+  from the shoulders. A figure whose joints are not there — reclining, an arm raised, or
+  seated in a skirt that does not start at the hip — needs `propose --keypoints`; sitting
+  alone does not, but a clean LINT does not show the hip is right (it asks only that the
+  hip be below the chest and the shoulders), so read the overlay ([AUTHORING §3](docs/AUTHORING.md)). The
+  file of joints comes from any pose
   estimator or a hand; this package does not estimate a pose itself, and its
   keypoint support has been measured on generated figures and on files read off the
   examples' own configs, never on an estimator's output.

package/cli.ts

@@ -96,8 +96,13 @@ usage:
       link of a fringe chain (hung from head on a head-run front hair mesh, its tip
       no lower than the chin) that drifts more than ${FRINGE_STEP_PX} px plus a pixel's
       rounding across the head's down axis (the eye line's perpendicular), for a
-      hip that is not below the chest, and for a hip above ${HIP_MIN_FRACTION} of the figure's
-      height (the shoulders); the fringe's three chains stand in the head's frame,
+      hip that is not below the chest, for a hip above ${HIP_MIN_FRACTION} of the figure's
+      height (the shoulders), and for two keyed chains on one lattice mesh whose
+      own swing, every other bone held, takes an edge of the rig stage's lattice
+      past check's TEXTURE_STRETCH bar (with each chain alone, the tips'
+      distance, and each remedy's own figure: one sign for opposed amplitudes,
+      dropping a chain; a contour or automatic mesh, or rule "heat", is said in
+      a "squeeze not read" note); the fringe's three chains stand in the head's frame,
       rooted on the part's art, and a note says they are a template, not its
       locks; a headwear/earwear layer with hanging strands
       gets one pendulum chain per strand and a note with each strand's x, rows
@@ -273,8 +278,11 @@ usage:
       than its lattice, and the report records each part's triangle and
       overdraw difference. A part that passes is drafted, its note saying
       what it was measured against; one that fails keeps its entry, and the
-      report names each failed reading and by how much. Written only when the
-      drafted config's check is PASS. --requirements, --idle-keys,
+      report names each failed reading and by how much. An auto or contour
+      entry is neither drafted nor compared with anything: a NOT COMPARED line
+      and the report's not_compared name each, so build it once on a lattice
+      and compare the rig stage's mesh lines (AUTHORING §3, issue #307).
+      Written only when the drafted config's check is PASS. --requirements, --idle-keys,
       --page-edges and --pack-shape are as for rig and check.
 
   rig-parts check --rig <dir> --out <dir> [--parts <dir>] [--source <painting.png>]
@@ -880,6 +888,7 @@ function printLint(P: PartSet, spec: { bones: CharacterConfig['bones']; meshes:
   for (const f of res.findings) console.log(lintLine(f));
   for (const m of res.unknownMeshes) console.log(`note: mesh ${JSON.stringify(m)} names no part in parts.json, so it was not linted`);
   for (const w of res.lockUnread) console.log(`note: off-lock not read: ${w}`);
+  for (const w of res.squeezeUnread) console.log(`note: squeeze not read: ${w}`);
   for (const b of res.missingTorsoBones) {
     console.log(
       res.basis?.torso.read === true

package/docs/AUTHORING.md

@@ -187,10 +187,58 @@ template the proposer wrote before issue #249 fires it on any head tilted more t
 degrees (the trailer character, 23.7 degrees: all six links; `reference-demo`, 3.2
 degrees, and `reference-sample`, -4.9 degrees: one link each).
 
-**A posed figure: `propose --keypoints`.** The proposer's ratios assume a
-standing figure: the hip below the chest, sleeves hanging from the shoulders. A
-seated, reclining or otherwise posed figure is told where its joints are with one
-explicit file (issue #75, `src/keypoints.ts`). A pose file named by
+**Two chains on one lattice (issue #314).** `lint` swings every pair of chains a lattice
+mesh's `segments` both name, both keyed by a chain track, on the rig stage's own lattice and
+weights (`src/squeeze.ts`: the part padded as the rig stage pads it, `latticeMesh`, and
+`influences` under the mesh's `r`, `exponent`, `influences` and `stray`, rounded as the
+lattice rounds — so its vertex and triangle numbers are the ones `rig.json` and `check`
+use). Each link turns as the idle's sine states it at every frame `check` renders, every
+other bone held at the setup pose, and each edge is read by `check`'s own reader. A pair
+whose worst edge is past `TEXTURE_STRETCH`'s bar (max(ratio, 1/ratio) above 1.926544)
+prints
+`LINT <a> and <b> on mesh '<part>' squeeze it: swung together, every other bone held, edge <i>-<j> of triangle <t> closes to <r> times its rest length at idle frame <f> (max(ratio, 1/ratio) <s>; <= 1.926544 is required, check's TEXTURE_STRETCH bar) — vertex <i> rides <bone> <w>, vertex <j> rides <bone> <w>; alone, <a> reads <x> and <b> <y>. Their tips are <d> px apart and …`
+(`stretch it` and `opens` when the edge grows). The end names the amplitudes and the
+remedies whose own figure passes the bar: with the two chains' amplitudes opposed link for
+link, `give both the same sign (then <s'>)` — `<s'>` the same reading with the second
+chain's signs turned; `drop one chain` when each alone passes, or `drop <b>, which alone is
+past the bar too` when only one does; and, when none passes,
+`lower the amplitudes`. A contour or automatic mesh, or `rule: "heat"`, is not rebuilt here:
+a `note: squeeze not read: …` line names the mesh and its pairs. What it predicts is
+`check`'s measurement without the other bones' motion. Measured: on `fixtures/squeeze.ts`
+(two chains 39 px apart at their tips, the proposer's mirrored back-hair amplitudes) it
+names the triangle, edge and frame `check` fails, 2.494 predicted against 2.488 measured,
+and one sign passes both (1.054); on the four public examples it prints nothing; on
+`reference-demo` the back-hair pair reads 1.393 at `hair_back` edge 43-42, frame 26 — the
+edge and frame `check` reports as that example's worst, 1.388, the figure the bar is the
+square of — and 1.075 with one sign; on `reference-sample` the sleeve pair reads 1.230 at
+the edge and frame `check` reads 1.227 at.
+
+**Why the back hair mirrors.** The proposer drafts `hairback_r` with amplitudes
+`[0.6, 1.4, 2.4]` and `hairback_l` with their negatives, while the fringe, lock and skirt chains share one sign (the two sleeve chains are mirrored
+the same way). The mirror is the reference proposer's draft,
+ported as it was (`src/propose.ts`, `SIDES`); no reason is recorded with it. Opposed, the
+two tips swing towards each other and apart on the same beat. On two hanks far apart that
+costs nothing a bar reads (`demo`, tips 371 px apart: 1.050 for the pair, as for either
+alone), and on one mass with the two chains close it squeezes the lattice between them
+(issue #314: tips 39 px apart, an edge at 0.065 of its rest length). Whether the hair is one
+mass is not something the proposer can read off the opaque shape — both chains always hang
+on the one `back hair` part — so the draft is unchanged and the squeeze is measured instead,
+by the lint above.
+
+**A posed figure: `propose --keypoints`.** Without joints the proposer reads the
+torso by screen y: the hip 0.14 face heights below `bottomwear`'s top edge (or below
+the waist: *The hip*, below), the chest half way up to the neck, sleeves hanging from the
+shoulders. A figure whose joints are not where those rules put them — a reclining
+figure, an arm raised or crossed, or a seated figure whose skirt does not start at
+the hip — is told where its joints are with one explicit file (issue #75,
+`src/keypoints.ts`). Sitting alone does not call for it: a seated figure whose skirt
+starts at the waist has its hip there (issue #314: a seated character proposed without
+joints, its hip placed and `lint` clean, built green once its back-hair chains were
+fixed). But a clean `lint` does not say the hip is right: the screen-y rules ask only
+that the hip be below the chest and below 0.25 of the figure's height, and a hip at a
+seated skirt's top passes both (selftest `PR56`: the rule's hip 28 px above where the
+thighs leave the torso, no LINT line) — read the overlay, and where the hip or a sleeve
+is off its joint, give the joints. A pose file named by
 `generation.control.skeleton` is not that file and is not offered as its default:
 the control skeleton is what was asked of the model, not where the joints ended up
 (a consumer measured a generated picture not following the control's raised hand),
@@ -450,6 +498,48 @@ contour region is (each share to 5 places, a 0 dropped, the remainder to the hea
 the cut it is rounded as the lattice always was. In the contour mode a region's bone counts
 toward the cap like any other (*The vertex's weights* in `src/localweights.ts`).
 
+### Which mode comes out smaller (issue #307)
+
+The names suggest that `auto`, the mode that reduces a mesh, is the smallest. Measured on one
+figure, it is not always: a reduction held to a large declared bend keeps many vertices to stay
+near its dense source, and on such a part the outline `mesh-draft` drafts over a coarse grid
+came out two to three times lighter. On parts that bend little, `auto` was far the smallest.
+
+The figure is the trailer's (`rig-c/trailer`, 1108 px tall). Triangles per part, as the rig
+stage's `mesh` lines print them: the kept modes from commit 45becfb; the `auto` counts of the
+three parts that left it from the commit before, 24bd8ec (each `auto` with the film's bends
+declared as `auto.stimulus` and `auto.motion.maxLocalDeformation` 3 px); the lattice column each
+part at `"grid": 30`, the spacing `propose` drafts for this figure, in 45becfb's config
+(`topwear` left on `auto`); and `mesh-draft` run over that lattice config. The bends are the
+largest turns the trailer's `WORKING.md` states for its film, not re-measured here.
+
+| part | the film bends it | `auto`, bends declared, 3 px | `mesh-draft` | lattice at `"grid": 30` |
+| --- | --- | --- | --- | --- |
+| `bottomwear` | 24° | 276 | 132 | 140 |
+| `handwear_r` | 33° | 148 | 49 | 52 |
+| `hairpin` | 95° (refused by `auto`; `contour` at its own spacing 13: 120) | — | 47, kept on its lattice (below) | 46 |
+| `legwear` | 12° | 77 | — | 176 |
+| `hair_back` | a few degrees | 28 | — | 120 |
+| `handwear_l` | 4° | 31 | — | 72 |
+| `neck` | — | 7 | — | 12 |
+| `hair_front` | 11° | 112 | — | 114 |
+
+Every count reproduces with `@rig-c/parts` 1.11.0 and rig-c 2.47.0 (the trailer's pins at
+45becfb, both configs over the same assembled parts), and the lattice and `mesh-draft` columns
+again with this package on rig-c 2.40.0. `mesh-draft` kept the hairpin on its lattice: its
+candidate, 47 triangles, sat 1.055 rig px from the lattice over the idle against a line of 1, and
+had one triangle more than the lattice's 46 (with the hairpin's lattice declaring
+`influences: {floor: "continuous"}`, as 45becfb's contour entry does, the idle reads 0.822 and
+passes, and the triangle line alone keeps it). The trailer's 47 is that candidate, written by
+hand. The film's two cuts were compared at their most different frame, enlarged; no difference
+showed, and every `check` bar passed on both.
+
+So, before keeping an `auto` entry on a part a chain or physics bends far: build the part once on
+a lattice, run `mesh-draft` (§4, step 12), and compare the two `mesh` lines. Nothing else reports
+the difference; `mesh-draft` names every `auto` or `contour` entry as not compared, because it
+drafts lattice entries only. This is one figure, and the two examples here were not measured this
+way.
+
 ### A contour mesh (`meshes.<part>.contour`, issue #84)
 
 The lattice keeps every grid cell that holds an art pixel, so its boundary and its interior
@@ -1425,7 +1515,10 @@ full loader before its assemble stage writes anything.
     The two divisors are calibrated on three figures of similar size (1106 to
     1185 px), and the bend set is a calibration, not your animation: a chain
     your animations or physics bend further than 15° a link was not measured
-    there. An `auto` or `contour` entry is yours and is left as it is. A
+    there. An `auto` or `contour` entry is yours and is left as it is, and it
+    is compared with nothing: a `NOT COMPARED` line and the report's
+    `not_compared` name each such part, since which mode comes out smaller is
+    measured, not named (§3, *Which mode comes out smaller*; issue #307). A
     relative `motion.animations_from` or `generation.control.skeleton` keeps its
     text, so it resolves against `draft/`; the command says so.
 
@@ -1439,7 +1532,7 @@ proposal in as the steps above say (`RL01`); every step must exit 0.
 | --- | --- | --- | --- |
 | `layers` | the table, then one `author-made: layer "author:<label>" — …` line per layer the author made (group `author` in the table; §5, *A layer the author made*), then the `WARN` lines | every tag the plan will need has opaque pixels; one `face` in the head run; `0 WARN line(s)` | a run whose layer PNG is not its box's size (`LAYERS_PNG_MATCHES_BBOX`); a `WARN  PLAN_LAYER_…` line (§6, *Plausibility*) |
 | `sheet` of both runs | the tile list (and the sheet, if you can see) | eyes, irises, lashes and brows as left/right pairs in the head run | a head box that cut off an ornament: move `head_box`, re-run the head crop |
-| `assemble` | one line per part, the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`, then one `uncovered: <n> of the <N> uncovered error px lie on the full run's "<tag>", in a body of <px> px at x,y wxh; <the rule that left it out>` line per full-run layer the plan does not take from the full run whose uncovered error holds a body (5x5-opened, 8-connected, at least 150 full-run px in rig px), then one `drift: "<part>" refuses <n> px of <run>:<tag> (its colour more than 90 off the painting, max channel), in a body of <px> px at x,y wxh (…); by the plan's draw order "<holder>" holds <px> px of it (…), "<holder>" drawn in front of "<part>"` line per part whose drift refusals hold a body (the same opening and bar) that another part holds in the draw order — that layer is not what the painting shows there (none on the five public paintings); and look at `render/recomposite_error_rig.png`. Between the part lines and the totals, one `author-made: part "<part>" (<run>:author:<label>) — …` line per part from a layer the author made (below, *A layer the author made*), then one `cut: "<part>" opaque <n> = "<part>" <kept> + "<piece>" <taken> …` line per part an `assemble.cuts` entry cut (below; it ends `; under <n> px filled, <m> px left empty` when a cut of that part has `under`), then one `fringe pushed back: "<part>" <px> px, where the painting shows "<holder>" <px> px, …` line per part whose fringe was cleared (below) | on the examples: `reference-sample` 0.83 / 98.0 % / 4,359 / 1,185, 259 holes, the largest 94 px; `reference-demo` 2.34 / 95.8 % / 10,340 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (reference-demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
+| `assemble` | one line per part — its counts (`op=` opaque, `vis=` visible, `src=` taken / candidates, `unproj=` visible but not projected, `drift=<n> (<p>% of core)`, `merged=`, `seam=`; *parts.json*, below). `drift=` is `refused_drift_px` in rig px and its share of the part's candidates, `projected_core_px`, which it is a subset of (issue #314); no bar reads either. On the four public examples the share runs to 94.5 % (`scarf` `hair_back`, 479 of 507) and the count to 26,472 (`scarf` `topwear`, 22.3 %), and the seam override repaints refused top-most pixels afterwards, so a large count says where See-through's colour was not taken, not that the part is unlike the painting: the `drift:` line below is the one that names a body of them another part holds. Then the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`, then one `uncovered: <n> of the <N> uncovered error px lie on the full run's "<tag>", in a body of <px> px at x,y wxh; <the rule that left it out>` line per full-run layer the plan does not take from the full run whose uncovered error holds a body (5x5-opened, 8-connected, at least 150 full-run px in rig px), then one `drift: "<part>" refuses <n> px of <run>:<tag> (its colour more than 90 off the painting, max channel), in a body of <px> px at x,y wxh (…); by the plan's draw order "<holder>" holds <px> px of it (…), "<holder>" drawn in front of "<part>"` line per part whose drift refusals hold a body (the same opening and bar) that another part holds in the draw order — that layer is not what the painting shows there (none on the five public paintings); and look at `render/recomposite_error_rig.png`. Between the part lines and the totals, one `author-made: part "<part>" (<run>:author:<label>) — …` line per part from a layer the author made (below, *A layer the author made*), then one `cut: "<part>" opaque <n> = "<part>" <kept> + "<piece>" <taken> …` line per part an `assemble.cuts` entry cut (below; it ends `; under <n> px filled, <m> px left empty` when a cut of that part has `under`), then one `fringe pushed back: "<part>" <px> px, where the painting shows "<holder>" <px> px, …` line per part whose fringe was cleared (below) | on the examples: `reference-sample` 0.83 / 98.0 % / 4,359 / 1,185, 259 holes, the largest 94 px; `reference-demo` 2.34 / 95.8 % / 10,340 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (reference-demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
 | `propose` | `note:` lines, `LINT` lines, the `coverage` lines, `landmarks.png`, `basis.json` | no LINT line: every chain link lies on its mesh's art, and the hip is below the chest and the figure's top quarter; the `coverage:` summary says how many bones that verdict covers — a `not checked` bone was read by no check (its line says why), and a `ratio` or `fallback` bone in `basis.json` is a guess | a link off the art (a bone on the background) — move it onto the layer; `LINT <link> at … runs to … N degrees off the head's down axis …` — a fringe link that does not lean with the head (§3, the fringe in the head's frame): move it along the lock it drives; `LINT hip at [x, y] is not below chest at [x, y]: …` or `LINT hip at [x, y] is above 0.25 of the figure height (figure y T..B, so hip y must be at least L): a hip at the shoulders` — move `hip` down to the waist (and `chest` between it and the neck); a `hanging strand … -- no chain proposed` note — that strand hangs stiff until you add a chain down the x and rows it names (§3); a `no blink: …` or `blink without brows: …` note — the idle will not blink (or its brows will not drop), because no part came from an `eyewhite` (or `eyebrow`) layer; the note names the tags looked for; a `no eyewhite part for eye_<s> …` note — the iris and lash parts it names ride `head` and do not blink, because no `eyewhite-<s>` part made that side's eye bone: take the eyewhite from the other run, or keep them on `head`; a `no face part: face box derived from …` note (always the first) — `head`, `neck` and every face-height scale come from a box guessed off the hair and neck (§3): check `head` and `neck` on `landmarks_head.png` and move them; when it adds `the blink shuts the eyes over no face part`, read `BLINK_NO_HOLE` after `check` — an eye with no face under it can open a hole (the `reference-sample` with only its face removed: 587 px). Under `--keypoints`: the `lint rule set:` line first (joints, or screen and why), then the joint notes — `missing: the rule "…" placed bone X instead` is a bone still guessed; `not used — …` names why an arm's joints did not place its sleeve (for a wrist on no part, the nearest part and the `--wrist-snap` that would bind it); a `wrist snap: …` note is a wrist bound past 15 px by the flag — check that chain's tip on `landmarks.png`; a `one handwear part holds both wrists` note is two chains on one mesh — cut the part with `assemble.cuts` to separate them; `LINT chest at … is not between the neck joint …`, `LINT hip at … is not past chest …`, `LINT hip at … is nearer the neck joint …` and `LINT <chain><i> at … does not advance from <s>_shoulder toward <s>_wrist` are the joint-frame lines: move that bone between, past or along the joints they name |
 | `compare` | one line per pair (origin, parent, tip, length, direction — or SKIP and why), then the per-row summary, the unmapped bones of each side, `required:`, each side's roles and the `controls:` line | proposal against the config you corrected: the rows you changed and no others. Config against the `rig.json` `build` writes for it: measured on both examples, every origin within 6.19e-7 px (the rig's offsets are written to 6 places) and every chain link's tip and length within 4.99e-4 px (`length` is written to 3), printed to three places as `0.000` (a signed figure as `+0.000` or `-0.000`); `parent … is the right's ancestor at depth 2, <bone>_ctl between` for every keyed mesh bone, no `DIFFERENT` and no `NOT MAPPED` | `parent DIFFERENT: left a, right b` — a bone hangs from another parent than the other side's; `frames not related` — a rig with no stage (`skeleton.width`/`height`), two configs at different `rig_scale`: the distance rows SKIP, so declare the frame in a `--map` file if the author knows it; `FAIL  STRUCTURE_REQUIRED_PRESENT` — a bone the map requires is missing through its pairs |
 | `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; the `bones` line; the `idle keys` line; then rigc's gate lines (with A15's declared SKIP under `--idle-keys direct`); in `rig.json`, each chain link's (or its `_ctl`'s) `length` and `rotation` | `cover 1.00000` on every mesh, both gate summaries `0 failed` (the compile and the packed pages); every link's `length` the distance to the next link and `rotation` its direction (Spine degrees, counter-clockwise, y up, local to the parent), every offset under it — a child bone's `x, y`, a weight's bind `x, y`, a region's `x, y` — in that turned frame, and a region on a link carrying `rotation` that turns it back upright. Nothing moved: `flattenRig` (`src/rig.ts`) turns every offset back and gives the unturned numbers | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
@@ -2030,7 +2123,7 @@ exits 0, and `mesh_draft.json` and the console name the reading and the amount.
 | `CHECK_CHAIN_LAG` | a rotate track leads (or does not lag) the keyed bone above it, or a chain link swings less than the link above — or, in a chain that carries a part the scene file declares `rests`, more than the link above (issue #245; the object names the part and the file) | that chain track's `phase`/`lag` (a positive `lag`, a child `phase` above its parent's) or its `amps` (non-decreasing toward the tip; non-increasing on a chain declared resting) |
 | `CHECK_TIP_OVER_ROOT` | a `handwear`/`bottomwear` part's art in the lower half of its box travels less than 1.4725 times as far as in the upper half, measured from the idle's posed geometry (rig px quoted) | the chain track's `amps` (grow toward the tip), or the mesh's `segments` (the chain must be among them), or its mode: on `scarf`'s short skirt the proposal's lattice read 1.207 and the same part in `contour` mode 1.738 with the same segments and idle (issue #118) — both carried the `chest` segment #262 removed, after which the lattice reads 3.487. When the detail says `the root travels with the breath (x px of y px): it is carried by \`<bone>\`` (issue #262) the chain is not the cause: a bone an idle `translate` track moves (the breath) moves the root more than the tip, and with that translate held still (the part posed again without it, in proportion to each vertex's weight on the bone and those under it) the ratio passes — the row adds `carried_by`, `breath_rig_px`, `root_without_breath_rig_px` and `tip_without_breath_rig_px`; take that bone's segment off the mesh, or bind the root to the bone the part hangs from. A part the scene file declares `rests` (issue #245) is held the other way, its tip half's travel at most its root half's (ratio ≤ 1); the detail then reads `the scene file's rests declares its tip at rest, so a ratio <= 1 is required`, and for it the fix is the chain's `amps` (shrinking toward the tip) or the mesh's tip weighted to a bone the idle does not swing |
 | `CHECK_STILL_REGIONS_DARK` | a slot of the face's still set (the `face` slots and every slot drawn over the face that the head bone alone carries) moves relative to the bone the face's slot rides, or a `footwear` slot moves on the screen, by more than the arithmetic's own rounding — measured from the idle's posed geometry (the slot, its largest displacement in rig px, the idle frame and the tolerance quoted) | on the face: a face mesh with a weight on a bone other than the head (`segments`), or one deformed by another bone; on the feet: a mesh weighted to a swinging bone, or a region on the wrong bone. A bang swinging over the face is not this line's failure: its depth is reported (`crossing`), with no bar |
-| `CHECK_TEXTURE_STRETCH` | a mesh triangle's edge, in some idle frame, is more than 1.926544 times its rest length or less than 1/1.926544 of it (the mesh, triangle, its three vertices, the edge and the frame are named); or a rest edge has length 0 | the chain tracks' `amps` on the bones that mesh is weighted to (the stretch grows with them), or the mesh's `segments` — a vertex blending two bones that swing against each other |
+| `CHECK_TEXTURE_STRETCH` | a mesh triangle's edge, in some idle frame, is more than 1.926544 times its rest length or less than 1/1.926544 of it (the mesh, triangle, its three vertices, the edge and the frame are named, and — issue #314 — the bones the edge's two vertices hang on: each vertex's two largest weights from `rig.json`, `vertex <i> is weighted to "<bone>" <w>, …`, then `on the idle's chains, the chain from "<first link>" carries "<bone>", …` — each chain `CHAIN_LAG` reads named once, by its first link — with a bone on no chain said, or `none of these bones hangs on a chain of the idle`); or a rest edge has length 0 | the chain tracks' `amps` on the bones that mesh is weighted to (the stretch grows with them), or the mesh's `segments` — a vertex blending two bones that swing against each other. Two chains named, with opposed amplitudes: give both one sign, or drop one — `propose --from-config` measures the pair before a build (§3, *Two chains on one lattice*) |
 | `CHECK_SEAM_FRAME_SIZE`, `FRAMES_SIDECAR`, `CHECK_GEOMETRY_FILE` | rigc's render is not what its `frames.json` says, or its `geometry.json` is not a whole `rigc-geometry/1` export of the frames beside it (a frame count, a mesh whose vertex count differs from its rest entry; for the face half, another viewport than `frames.json`'s, other frame indices, the head bone or a feature's bone missing from a frame, a non-finite transform or time) | a rigc problem; report it |
 | `LOOP_ENCODE` | the loop encoder refused a frame (translucent pixel in a GIF, a size change) | the frames; for a translucent frame write the lossless or the indexed APNG, which keep alpha |
 | `LOOP_LEAD_IN_IDLE` | `build --lead-in`: the idle cannot be repeated without inventing a value (a track not keyed from 0 to the duration, or ending where it does not start; a field besides `duration`, `loop`, `note`, `tracks`), the motion already has an `idle_lead_in`, or the render did not write whole periods | the refusal names the track or field; the demo's idle, as the rig stage writes it, repeats as written |

package/docs/STABILITY.md

@@ -175,7 +175,7 @@ every number) are AUTHORING §3's tables, and the loader refuses any other by na
 | `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_border` after the seam figures when `parts.json` declares a scene (issue #242), `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `RECOMPOSITE_HOLES` (its first figure `declared_scene` when `parts.json` declares a scene), `SETUP_POSE_VS_SOURCE`, `skipped`, a `requirements` block under `--requirements`, and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
 | `proposal.json`, `render/landmarks*.png` | `propose` | the config's four rig sections, `turn` with `--full`/`--head`, and `notes` |
 | `basis.json` | `propose` | spec `spine-parts-basis/1` |
-| `config.json`, `mesh_draft.json` | `mesh-draft` | `config.json` is the config read, byte for byte, but for each drafted part's `meshes` entry; `mesh_draft.json` is spec `rig-parts-mesh-draft/1`: `rules`, `lattice_check`, `draft_check`, `figure_overdraw`, and per lattice part `part`, `mode`, `lattice`, `candidate`, `delta` (under `--more-triangles` only), `readings`, `gate` (each line's `reading`, `pass`, `text`, `margin`), `note` |
+| `config.json`, `mesh_draft.json` | `mesh-draft` | `config.json` is the config read, byte for byte, but for each drafted part's `meshes` entry; `mesh_draft.json` is spec `rig-parts-mesh-draft/1`: `rules`, `lattice_check`, `draft_check`, `figure_overdraw`, and per lattice part `part`, `mode`, `lattice`, `candidate`, `delta` (under `--more-triangles` only), `readings`, `gate` (each line's `reading`, `pass`, `text`, `margin`), `note`; and `not_compared` (issue #307), only when the config holds an `auto` or `contour` entry: per such entry, in config order, `part`, `mode` and `note` — the part was neither drafted nor compared, and a config of lattices alone writes no such key |
 | the scene report | `compose` | spec `spine-parts-scene-report/1` |
 | `idle.png`, `idle-indexed.png`, `idle.gif` | `loop`, `build --loop` | APNG and GIF encodings of the rendered idle |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/skills/rig-parts/SKILL.md

@@ -82,10 +82,12 @@ stage writes are the whole interface.
    keeps under the piece's edge; 1 px closed the seam on scarf) — and give the piece its own
    `meshes` entry; the `cut:` line gives the split. At overlap 0 a cut through
    opaque art leaves a seam `check` reads (AUTHORING §5).
-   A seated or reclining figure: add `--keypoints <file>` (body-18 joints in
-   painting px, each observed, occluded or missing; AUTHORING §3, *A posed
-   figure*) so the neck, hip, chest and sleeves follow the pose and LINT reads
-   the joints, not screen y. Never write a joint you did not get from an
+   A figure whose joints are not where the screen-y rules put them — reclining,
+   an arm raised, seated in a skirt that does not start at the hip: add
+   `--keypoints <file>` (body-18 joints in painting px, each observed, occluded
+   or missing; AUTHORING §3, *A posed figure*) so the neck, hip, chest and
+   sleeves follow the pose and LINT reads the joints, not screen y. A clean
+   LINT does not show a seated hip is right; the overlay does. Never write a joint you did not get from an
    estimator or the painting: say `missing` and let the rule stand in.
 6. Correct against `render/landmarks.png` and `note:` lines; a
    `coverage … not checked` line is a bone no check read (the line says why),
@@ -109,7 +111,8 @@ stage writes are the whole interface.
 8. Read `out/check/check.json` — the six judgement lines the same way as the seam
    and the loop: a FAIL names the field to change (AUTHORING §6);
    `TEXTURE_STRETCH` names the worst mesh triangle (slot, triangle, vertices, edge,
-   frame), so quote it even on a PASS. Quote
+   frame), so quote it even on a PASS; its FAIL line also names the bones the
+   edge's two vertices are weighted to and the idle chains they hang on. Quote
    `RECOMPOSITE_HOLES` (uncovered px, hole count, the largest hole's box) in the
    report whatever `PASS` says. The artifact is the three paths the build prints
    last: `check/build/skeleton.json`, `skeleton.atlas` and the packed page. Report

package/src/build.ts

@@ -227,7 +227,7 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
     log(
       `  ${p.name.padEnd(11)} ${p.from.padEnd(16)} ${`${p.w}x${p.h}`.padEnd(9)} @${String(p.x).padStart(4)},${String(p.y).padStart(4)} ` +
         `op=${String(p.opaque_px).padStart(6)} vis=${String(p.visible_px).padStart(6)} src=${String(p.source_px_taken).padStart(6)}/${String(p.projected_core_px).padStart(6)} ` +
-        `unproj=${String(p.visible_not_projected_px).padStart(5)} drift=${String(p.refused_drift_px).padStart(5)} merged=${p.merged_px} seam=${p.seam_override_px}`,
+        `unproj=${String(p.visible_not_projected_px).padStart(5)} drift=${String(p.refused_drift_px).padStart(5)} ${driftShare(p.refused_drift_px, p.projected_core_px)} merged=${p.merged_px} seam=${p.seam_override_px}`,
     );
   }
   // Issue #256: one line per part from an author-made layer, so it never reads as See-through's. None without one.
@@ -253,6 +253,16 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   return result;
 }
 
+/**
+ * The scale the per-part line prints `drift=` with (issue #314): `refused_drift_px` counts the part's projection
+ * candidates (`projected_core_px`, the `src=` column's second figure) refused because See-through's colour sits more
+ * than the drift limit off the painting's, so it is read against them — `(<p>% of core)`, one decimal; a part with no
+ * candidate has nothing to refuse and says so. No bar reads either figure (AUTHORING §5, `assemble`).
+ */
+export function driftShare(refused: number, core: number): string {
+  return core === 0 ? '(no core)' : `(${((100 * refused) / core).toFixed(1)}% of core)`;
+}
+
 // ---------------------------------------------------------------------------
 // rig
 // ---------------------------------------------------------------------------

package/src/check.ts

@@ -1948,7 +1948,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     // One reader for the one geometry file: the stretch reads its meshes, the still regions every slot and the head bone.
     const geometryPath = join(idle.dir, GEOMETRY_FILE);
     const geometry = readGeometry(geometryPath, idle.written);
-    stretch = stretchLine(geometry, geometryPath, problems);
+    stretch = stretchLine(geometry, geometryPath, problems, inp);
     if (full !== null) still = stillLine(full, idle, geometry, geometryPath, problems, notPlanted);
   }
 
@@ -3300,15 +3300,76 @@ function stretchAtText(s: { triangle: number; vertices: readonly number[]; edge:
   return `triangle ${s.triangle} (vertices ${s.vertices.join(' ')}), edge ${s.edge.join('-')}, idle frame ${s.frame}`;
 }
 
+/**
+ * Issue #314: what a failing edge's two vertices hang on, read off rig.json and motion.json — so the cause reads off
+ * the line rather than off a hand decoding of the weight runs. Each vertex's bones from the default skin's weights,
+ * the largest two by weight (equal weights in rig.json's order), with how many it has; then every bone named, grouped
+ * by the idle chain it hangs on — the nearest link at or above it of a chain `CHAIN_LAG` reads
+ * ({@link chainFigures}: two or more rotate-keyed links at one period), each chain named once, by its first link — and
+ * the bones on none. A mesh with no weights rides its slot's bone, and an attachment the skin does not hold, or a
+ * vertex its weights do not reach, is said rather than guessed.
+ */
+export function edgeBonesText(rig: Record<string, unknown>, motion: Record<string, unknown>, slot: string, attachment: string, edge: readonly number[]): string {
+  const skins = isRecord(rig.skins) ? rig.skins : {};
+  const skin = isRecord(skins.default) ? skins.default : {};
+  const onSlot = isRecord(skin[slot]) ? skin[slot] : {};
+  const att = onSlot[attachment];
+  if (!isRecord(att)) return `its weights are not read: rig.json's default skin holds no attachment "${attachment}" on slot "${slot}"`;
+  if (!Array.isArray(att.weights)) {
+    const sl = (Array.isArray(rig.slots) ? rig.slots : []).filter(isRecord).find((x) => x.name === slot);
+    return `the mesh carries no weights, so vertex ${edge.join(' and vertex ')} ride slot "${slot}"'s bone ${sl !== undefined && typeof sl.bone === 'string' ? `"${sl.bone}"` : '(rig.json names none)'}`;
+  }
+  const weights = att.weights;
+  const missing = edge.filter((v) => !Array.isArray(weights[v]));
+  if (missing.length > 0) return `its weights are not read: rig.json's mesh "${attachment}" weights ${weights.length} vertices, and vertex ${missing.join(' and ')} is not among them`;
+  const named: string[] = [];
+  const parts = edge.map((v, i) => {
+    const list = (weights[v] as unknown[]).filter(isRecord).filter((w) => typeof w.bone === 'string' && typeof w.weight === 'number') as Array<{ bone: string; weight: number }>;
+    const top = [...list].sort((a, b) => b.weight - a.weight).slice(0, 2);
+    for (const w of top) if (!named.includes(w.bone)) named.push(w.bone);
+    const shown = top.map((w) => `"${w.bone}" ${w.weight}`).join(', ');
+    return `${i === 0 ? `vertex ${v} is weighted to` : `vertex ${v} to`} ${shown}${list.length > 2 ? ` (the largest 2 of ${list.length})` : ''}`;
+  });
+  const bones = (Array.isArray(rig.bones) ? rig.bones : []).filter(isRecord);
+  const parent = new Map(bones.filter((b) => typeof b.name === 'string').map((b) => [String(b.name), typeof b.parent === 'string' ? b.parent : null]));
+  const firstLink = new Map<string, string>();
+  for (const c of chainFigures(rig, motion).chains) if (c.length >= 2) for (const l of c) firstLink.set(l.bone, c[0].bone);
+  const carries = new Map<string, string[]>();
+  const none: string[] = [];
+  for (const b of named) {
+    let chain: string | null = null;
+    const seen = new Set<string>();
+    for (let x: string | null = b; x !== null && !seen.has(x); x = parent.get(x) ?? null) {
+      const f = firstLink.get(x);
+      if (f !== undefined) {
+        chain = f;
+        break;
+      }
+      seen.add(x);
+    }
+    if (chain === null) none.push(b);
+    else carries.set(chain, [...(carries.get(chain) ?? []), b]);
+  }
+  const quoted = (l: readonly string[]): string => l.map((n) => `"${n}"`).join(', ');
+  const chains =
+    carries.size === 0
+      ? 'none of these bones hangs on a chain of the idle'
+      : `on the idle's chains, ${[...carries].map(([c, l]) => `the chain from "${c}" carries ${quoted(l)}`).join(' and ')}${none.length === 0 ? '' : `, and ${quoted(none)} ${none.length === 1 ? 'hangs' : 'hang'} on none`}`;
+  return `${parts.join(' and ')}; ${chains}`;
+}
+
 /**
  * (6) No visible texture stretch: for every mesh triangle, each edge's length
  * in each idle frame over its rest length (the setup pose's bones, no deform —
  * which on both examples is the art's own proportions, the attachment's `uvs`
  * times its size, to 2.4e-5). The figure is the rig's worst max(ratio,
  * 1/ratio); each mesh's largest and smallest ratio, and where, are the detail.
- * SKIP when the render wrote no geometry file or the rig draws no mesh.
+ * SKIP when the render wrote no geometry file or the rig draws no mesh. With
+ * `bound`, the rig and motion `check` read, a failing edge's line also names the
+ * bones its two vertices hang on and their chains ({@link edgeBonesText}, issue
+ * #314).
  */
-export function stretchLine(geo: IdleGeometry | null, path: string, problems: Problem[]): JudgementLine {
+export function stretchLine(geo: IdleGeometry | null, path: string, problems: Problem[], bound?: Pick<CheckInputs, 'rig' | 'motion'>): JudgementLine {
   if (geo === null) return skip(`${path} does not exist; \`rigc render --geometry\` (rig-c ${RIGC_GEOMETRY_VERSION} or later) writes it, and the skinned mesh vertices are read from it`);
   if (geo.meshes.length === 0) return skip('the rig draws no mesh attachment (every slot is a region), so there is no triangle to stretch');
   const figures = stretchFigures(geo.meshes, geo.frames);
@@ -3343,7 +3404,7 @@ export function stretchLine(geo: IdleGeometry | null, path: string, problems: Pr
       problems.push({
         code: 'CHECK_TEXTURE_STRETCH',
         object: `mesh "${m.slot}" ${stretchAtText(at)}`,
-        detail: `the edge is ${round3(at.ratio)} times its rest length (max(ratio, 1/ratio) ${severity}); <= ${TEXTURE_STRETCH_CEILING} is required — the texture on it is ${at.ratio >= 1 ? 'stretched' : 'squeezed'}: the bones this mesh is weighted to move apart (amplitudes too large down a chain), or a vertex blends bones that move against each other`,
+        detail: `the edge is ${round3(at.ratio)} times its rest length (max(ratio, 1/ratio) ${severity}); <= ${TEXTURE_STRETCH_CEILING} is required${bound === undefined ? '' : `; ${edgeBonesText(bound.rig, bound.motion, m.slot, m.attachment, at.edge)}`} — the texture on it is ${at.ratio >= 1 ? 'stretched' : 'squeezed'}: the bones this mesh is weighted to move apart (amplitudes too large down a chain), or a vertex blends bones that move against each other`,
       });
     }
   }

package/src/meshdraft.ts

@@ -118,6 +118,33 @@ export const MORE_TRIANGLES_FLAG = '--more-triangles';
  */
 export const RELATIVE_SENTENCE = 'the gate is a judgment relative to this config\'s lattice, not an absolute quality: when the lattice coarsens, the reference moves with it';
 
+/**
+ * What `mesh-draft` says of a part whose config entry is not a lattice (`contour` or `auto`, issue #307): it drafts
+ * lattice entries only, so such a part was neither drafted nor compared. Said because the answer to "which mode comes
+ * out smaller" is not the one the names suggest: on one figure (rig-c/trailer 45becfb) an `auto` reduction held to a
+ * large declared bend kept two to three times the triangles of the outline this command drafts (AUTHORING §3, *Which
+ * mode comes out smaller*).
+ */
+export const NOT_COMPARED_SENTENCE = 'mesh-draft drafts lattice entries only, so it drafted nothing for this part and compared it with nothing; whether a lattice, or the outline mesh-draft drafts over one, comes out smaller is not known from this run — build the part once on a lattice, run mesh-draft, and compare the rig stage\'s mesh lines before keeping this entry';
+
+/** A config entry `mesh-draft` did not draft because it is not a lattice (issue #307), in config order. */
+export interface NotCompared {
+  part: string;
+  mode: 'contour' | 'auto';
+  note: string;
+}
+
+/** The entries of `meshes` that are not lattices, in config order, each with its note ({@link NOT_COMPARED_SENTENCE}). */
+export function notCompared(meshes: CharacterConfig['meshes']): NotCompared[] {
+  const out: NotCompared[] = [];
+  for (const [part, spec] of Object.entries(meshes)) {
+    if ('grid' in spec) continue;
+    const mode = 'auto' in spec ? 'auto' : 'contour';
+    out.push({ part, mode, note: `its entry is "${mode}", not a lattice: ${NOT_COMPARED_SENTENCE}` });
+  }
+  return out;
+}
+
 /** The five readings, in the order the gate reads them. */
 export const READINGS = ['bars', 'idle', 'bend inverted', 'bend worst', 'triangles'] as const;
 export type Reading = (typeof READINGS)[number];
@@ -534,6 +561,8 @@ export interface PartRow {
 export interface MeshDraftResult {
   rules: FigureRules;
   rows: PartRow[];
+  /** The entries not drafted because they are not lattices (issue #307), in config order. */
+  notCompared: NotCompared[];
   written: string[];
 }
 
@@ -810,6 +839,7 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
   }
   const configText = splicedConfig(text, drafted);
   const rowsOut = [...rows.values()];
+  const others = notCompared(cfg.meshes);
   const report = {
     spec: MESH_DRAFT_SPEC,
     rules: {
@@ -834,6 +864,9 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
       gate: r.gate,
       note: r.note,
     })),
+    // Issue #307: present only when the config holds an entry that is not a lattice, so a config of lattices alone
+    // writes the bytes it wrote before the key existed.
+    ...(others.length === 0 ? {} : { not_compared: others }),
   };
   mkdirSync(input.out, { recursive: true });
   const written = [join(input.out, 'config.json'), join(input.out, MESH_DRAFT_REPORT)];
@@ -845,14 +878,15 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
     for (const g of r.gate) log(`    ${g.pass ? 'pass' : 'FAIL'}  ${g.reading}: ${g.text}`);
     if (r.mode === 'grid' && r.gate.length === 0) log(`    ${r.note}`);
   }
+  for (const o of others) log(`  NOT COMPARED  ${o.part}: ${o.note}`);
   const nDrafted = rowsOut.filter((r) => r.mode === 'contour').length;
   const tri = (pick: (r: PartRow) => number): number => rowsOut.reduce((a, r) => a + pick(r), 0);
-  log(`rig-parts mesh-draft: ${nDrafted} of ${rowsOut.length} lattice part(s) drafted; their triangles ${tri((r) => r.lattice.triangles)} -> ${tri((r) => (r.mode === 'contour' && r.candidate !== null ? r.candidate.triangles : r.lattice.triangles))}, the figure's overdraw over them ${report.figure_overdraw.lattice} -> ${report.figure_overdraw.written}${input.moreTriangles === true ? ` (${MORE_TRIANGLES_FLAG}: triangles reported, not a line)` : ''}; the drafted config's check: ${final.report.figures.PASS ? 'PASS' : 'FAIL'}`);
+  log(`rig-parts mesh-draft: ${nDrafted} of ${rowsOut.length} lattice part(s) drafted; their triangles ${tri((r) => r.lattice.triangles)} -> ${tri((r) => (r.mode === 'contour' && r.candidate !== null ? r.candidate.triangles : r.lattice.triangles))}, the figure's overdraw over them ${report.figure_overdraw.lattice} -> ${report.figure_overdraw.written}${input.moreTriangles === true ? ` (${MORE_TRIANGLES_FLAG}: triangles reported, not a line)` : ''}${others.length === 0 ? '' : `; ${others.length} part(s) not a lattice, not drafted and not compared: ${others.map((o) => `${o.part} (${o.mode})`).join(', ')}`}; the drafted config's check: ${final.report.figures.PASS ? 'PASS' : 'FAIL'}`);
   if (resolve(configDir) !== resolve(input.out)) {
     for (const r of relativePaths(raw)) log(`  note: ${r.at} is "${r.value}", relative to the config's directory; the written config keeps the text, so it resolves against ${input.out} — copy the file beside the written config, or the written config beside it`);
   }
   log(`rig-parts mesh-draft: wrote ${written.join(' and ')}`);
-  return { rules, rows: rowsOut, written };
+  return { rules, rows: rowsOut, notCompared: others, written };
 }
 
 /**

package/src/propose.ts

@@ -136,6 +136,8 @@ import { configRoles, type RoleOf } from './structure.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';
+import { chainSqueezes, type SqueezeFinding } from './squeeze.ts';
+import { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
 // the output shape — config-shaped, key order as the reference writes it
@@ -2905,7 +2907,10 @@ export interface ChainNotAdvancingFinding {
   toJoint: KeypointName;
 }
 
-export type LintFinding = OffArtFinding | OffLockFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding;
+/** Issue #314: two chains on one lattice whose own swing closes or opens an edge between them past check's TEXTURE_STRETCH bar (`src/squeeze.ts`). */
+export type SqueezeLintFinding = { kind: 'squeeze' } & SqueezeFinding;
+
+export type LintFinding = OffArtFinding | OffLockFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding | SqueezeLintFinding;
 
 /** Which rule set read the torso and the sleeve chains, under `--keypoints`. */
 export interface LintBasis {
@@ -2923,6 +2928,8 @@ export interface LintResult {
   lockUnread: string[];
   /** Single bones the torso checks read (`hip`, `chest`) that the bones do not hold: those checks did not run. */
   missingTorsoBones: string[];
+  /** Issue #314: the pairs of keyed chains on one mesh the squeeze check could not build a lattice for, and why. Empty when it read every pair or had none. */
+  squeezeUnread: string[];
   /** Present only under `--keypoints`: the rule set that read the torso and the chains. */
   basis?: LintBasis;
   /** One record per bone of the spec, in its bone order (chain links as `<chain><i>`): which checks read it, or why none did (issue #86). */
@@ -3130,8 +3137,21 @@ export function lint(
       }
     }
   }
+  // Issue #314: every pair of keyed chains a lattice mesh names, swung on the rig stage's own lattice and weights, held
+  // to check's TEXTURE_STRETCH bar (src/squeeze.ts). Only with a motion: without one nothing swings.
+  const sq = chainSqueezes({ bones: spec.bones, meshes: spec.meshes, motion: spec.motion }, new Map(P.recs.filter((p) => P.images.has(p.name)).map((p) => [p.name, { x: p.x, y: p.y, image: P.images.get(p.name) as Raster }])));
+  for (const { mesh, a, b } of sq.read) {
+    for (const [c, other] of [[a, b], [b, a]]) {
+      const e = spec.bones.find((x) => 'chain' in x && x.chain === c);
+      if (e !== undefined && 'chain' in e) e.points.forEach((_, i) => readBy(`${c}${i}`, `squeeze with ${other} on mesh ${pyRepr(mesh)}`));
+    }
+  }
+  for (const f of sq.findings) findings.push({ kind: 'squeeze', ...f });
+  const squeezeUnread = sq.unread;
   const coverage = lintCoverage(spec, byName, read, findings, unknownMeshes, basis);
-  return basis === undefined ? { findings, unknownMeshes, lockUnread, missingTorsoBones, coverage } : { findings, unknownMeshes, lockUnread, missingTorsoBones, basis, coverage };
+  return basis === undefined
+    ? { findings, unknownMeshes, lockUnread, missingTorsoBones, squeezeUnread, coverage }
+    : { findings, unknownMeshes, lockUnread, missingTorsoBones, squeezeUnread, 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. */
@@ -3148,6 +3168,8 @@ function findingBones(f: LintFinding, bones: readonly BoneEntry[]): string[] {
       return ['hip'];
     case 'chest-not-between':
       return ['chest'];
+    case 'squeeze':
+      return [...new Set(f.vertices.map((v) => v.weights[0]?.bone).filter((n): n is string => n !== undefined))];
     case 'chain-not-advancing': {
       if (!f.point.endsWith(' tip')) return [f.point];
       const chain = f.point.slice(0, -' tip'.length);
@@ -3313,11 +3335,42 @@ export function lintLine(f: LintFinding): string {
       return `LINT hip at ${pyIntList(f.hip)} is not past chest at ${pyIntList(f.chest)} on the way from the neck joint to the hip joints (hip at ${pyFixed(f.tHip, 2)}, chest at ${pyFixed(f.tChest, 2)} of the way): breathing and the skirt hang from the wrong end of the torso`;
     case 'hip-nearer-neck':
       return `LINT hip at ${pyIntList(f.hip)} is nearer the neck joint ${fmtAt(f.neck)} (${pyFixed(f.dNeck, 1)} px) than the midpoint of the hip joints ${fmtAt(f.hips)} (${pyFixed(f.dHips, 1)} px): a hip at the shoulders`;
+    case 'squeeze':
+      return squeezeLine(f);
     case 'chain-not-advancing':
       return `LINT ${f.point} at ${pyIntList(f.at)} does not advance from ${f.fromJoint} toward ${f.toJoint}: it falls ${pyFixed(f.t, 1)} px along that line and ${f.previous} ${pyFixed(f.tPrevious, 1)} px, and each must fall further than the one before`;
   }
 }
 
+/**
+ * The squeeze LINT line (issue #314): the pair and the mesh, the worst edge with both swinging and the bone each of
+ * its two vertices rides most, the bar it is held to (check's), each chain swung alone, the tips' distance and the
+ * amplitudes, and the remedies whose figure passes the bar — one sign when the amplitudes are opposed, dropping a
+ * chain when the other alone passes — or, when none does, that the amplitudes are too large for this lattice.
+ */
+function squeezeLine(f: SqueezeLintFinding): string {
+  const e = f.both.at;
+  const C = TEXTURE_STRETCH_CEILING;
+  const rides = f.vertices.map((v) => (v.weights.length === 0 ? `vertex ${v.vertex} rides no bone` : `vertex ${v.vertex} rides ${v.weights[0].bone} ${v.weights[0].weight}`)).join(', ');
+  const amps = (c: { amps: readonly number[] }): string => `[${c.amps.join(', ')}]`;
+  const remedies: string[] = [];
+  if (f.turned !== null && f.turned <= C) remedies.push(`give both the same sign (then ${pyFixed(f.turned, 3)})`);
+  if (f.aloneA <= C && f.aloneB <= C) remedies.push('drop one chain');
+  else if (f.aloneA <= C) remedies.push(`drop ${f.b.chain}, which alone is past the bar too`);
+  else if (f.aloneB <= C) remedies.push(`drop ${f.a.chain}, which alone is past the bar too`);
+  const said =
+    f.turned !== null
+      ? `their amplitudes are opposed (${f.a.chain} ${amps(f.a)}, ${f.b.chain} ${amps(f.b)}), so their tips swing towards each other and apart`
+      : `their amplitudes are ${f.a.chain} ${amps(f.a)} and ${f.b.chain} ${amps(f.b)}`;
+  const remedy = remedies.length > 0 ? remedies.join(', or ') : 'neither one sign nor either chain alone passes the bar: lower the amplitudes';
+  return (
+    `LINT ${f.a.chain} and ${f.b.chain} on mesh ${pyRepr(f.mesh)} ${e.ratio >= 1 ? 'stretch' : 'squeeze'} it: swung together, every other bone held, ` +
+    `edge ${e.edge.join('-')} of triangle ${e.triangle} ${e.ratio >= 1 ? 'opens' : 'closes'} to ${pyFixed(e.ratio, 3)} times its rest length at idle frame ${e.frame} (max(ratio, 1/ratio) ${pyFixed(f.both.severity, 3)}; ` +
+    `<= ${C} is required, check's TEXTURE_STRETCH bar) — ${rides}; alone, ${f.a.chain} reads ${pyFixed(f.aloneA, 3)} and ${f.b.chain} ${pyFixed(f.aloneB, 3)}. ` +
+    `Their tips are ${pyFixed(f.tipGap, 1)} px apart and ${said}: ${remedy}`
+  );
+}
+
 export interface Comparison {
   rows: Array<[string, number]>;
   onlyConfig: string[];

package/src/squeeze.ts

@@ -0,0 +1,274 @@
+/**
+ * Two chains on one lattice that the idle swings into each other (issue #314).
+ *
+ * A pair of chains a mesh's `segments` both name is a squeeze when their own
+ * swing, every other bone held at the setup pose, closes (or opens) a lattice
+ * edge between the art each one carries past the bar `check`'s
+ * `TEXTURE_STRETCH` holds every edge to ({@link TEXTURE_STRETCH_CEILING}, on
+ * max(ratio, 1/ratio)). Read here from what `propose` and `--from-config` hold —
+ * the parts, the bones, the mesh's spec and the idle's chain tracks — so the
+ * squeeze is named before anything is built.
+ *
+ * What is built is the rig stage's own lattice and weights, by the rig stage's
+ * own functions: the part's image padded by {@link PAD}, its art (alpha above
+ * {@link ART_ALPHA}, less what a declared `stray` leaves out) cut into the
+ * lattice by `latticeMesh`, and each vertex weighted by `influences` under the
+ * mesh's `r`, `exponent` and `influences`, rounded as the lattice rounds — so
+ * the vertex and triangle numbers are the ones `rig.json` and `check` use. Only
+ * the lattice mode under the distance rule is read; a contour or automatic mesh,
+ * or `rule: "heat"`, is said not read, by name.
+ *
+ * Each chain's links are posed as the idle's sine states them —
+ * `amps[i] * sin(2 pi (t / period - (phase + lag * i)))` degrees on link `i`,
+ * `src/motion.ts` — turned down the chain (a link carries every link below it),
+ * at the frames `check` renders: `t = f / IDLE_FPS` for every whole frame up to
+ * the idle's duration. Every other bone stays where the setup pose has it, so a
+ * figure is the pair's own: the head's roll or the breath carry both chains
+ * alike and are not in it. A vertex moves as linear blend skinning moves it,
+ * each weight times where that bone's motion takes the vertex. The edge ratios
+ * are `check`'s own reader on these poses ({@link stretchFigures}).
+ *
+ * The pair is named when both swinging together pass the bar, with each
+ * chain swung alone beside it — so the remedy "drop one chain" carries the
+ * figure the other is left with, and a chain past the bar on its own reads as
+ * that. With the two chains' amplitudes opposed link for link (every `amps[i]`
+ * of one the other sign of the other's), the same reading is taken with the
+ * second chain's signs turned, so the remedy "give both the same sign" carries
+ * its own figure too. A remedy whose figure is past the bar is not offered.
+ */
+import { TEXTURE_STRETCH_CEILING } from './check.ts';
+import type { BoneEntry, MeshSpec, Motion, Point } from './config.ts';
+import { stretchFigures, stretchSeverity, type StretchAt } from './instruments.ts';
+import { edgeLength } from './length.ts';
+import { ART_ALPHA, latticeMesh, latticeStray } from './mesh.ts';
+import { IDLE_FPS, TIME_SLACK } from './motion.ts';
+import { pad } from './raster/composite.ts';
+import { alphaAbove, type Raster } from './raster/types.ts';
+import { latticeShares, PAD, roundShares } from './rig.ts';
+import { DISTANCE_EXPONENT, influences, meshLimits, type Segment } from './weights.ts';
+
+/** One chain of the pair as the finding prints it: its name, its `amps` as written, and its tip. */
+export interface SqueezeChain {
+  chain: string;
+  amps: number[];
+  tip: Point;
+}
+
+/** The worst edge of one reading: where, its ratio, and max(ratio, 1/ratio). */
+export interface SqueezeEdge {
+  at: StretchAt;
+  severity: number;
+}
+
+/** A pair named: both chains, the mesh, the worst edge with both swinging, and each alone (and turned, when opposed). */
+export interface SqueezeFinding {
+  mesh: string;
+  a: SqueezeChain;
+  b: SqueezeChain;
+  /** The two tips' distance at the setup pose, rig px. */
+  tipGap: number;
+  both: SqueezeEdge;
+  /** The two vertices of `both`'s edge, each with its two largest weights (bone, weight as rig.json writes it), and how many it has. */
+  vertices: Array<{ vertex: number; weights: Array<{ bone: string; weight: number }>; of: number }>;
+  /** The worst edge with the first chain swung alone, and with the second. */
+  aloneA: number;
+  aloneB: number;
+  /** Both opposed link for link: the worst edge with the second chain's signs turned. Null when they are not opposed. */
+  turned: number | null;
+}
+
+export interface SqueezeResult {
+  findings: SqueezeFinding[];
+  /** Pairs on one mesh this did not read, and why. */
+  unread: string[];
+  /** Every pair read: the mesh and the two chains. */
+  read: Array<{ mesh: string; a: string; b: string }>;
+}
+
+type ChainTrackLike = { chain: string; amps: number[]; period: number; phase: number; lag: number };
+
+/** Each frame's time, as `check` renders them: every whole frame at {@link IDLE_FPS} up to the idle's duration. */
+function frameTimes(duration: number): number[] {
+  const out: number[] = [];
+  for (let f = 0; f / IDLE_FPS <= duration + TIME_SLACK; f++) out.push(f / IDLE_FPS);
+  return out;
+}
+
+/**
+ * A chain's posed links at time `t`: per link, its setup origin, its posed origin, and the turn it carries (degrees,
+ * the sum of its own and every link above it). Positive is Spine's counter-clockwise (y up), which on the crop's y-down
+ * page turns a vector (dx, dy) to (dx cos + dy sin, -dx sin + dy cos).
+ */
+function posedLinks(pts: readonly Point[], track: ChainTrackLike, sign: 1 | -1, t: number): Array<{ rest: Point; at: [number, number]; turn: number }> {
+  const out: Array<{ rest: Point; at: [number, number]; turn: number }> = [];
+  let at: [number, number] = [pts[0][0], pts[0][1]];
+  let turn = 0;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const amp = i < track.amps.length ? track.amps[i] : 0;
+    turn += sign * amp * Math.sin(2 * Math.PI * (t / track.period - (track.phase + track.lag * i)));
+    out.push({ rest: pts[i], at, turn });
+    const rad = (turn * Math.PI) / 180;
+    const dx = pts[i + 1][0] - pts[i][0];
+    const dy = pts[i + 1][1] - pts[i][1];
+    at = [at[0] + dx * Math.cos(rad) + dy * Math.sin(rad), at[1] - dx * Math.sin(rad) + dy * Math.cos(rad)];
+  }
+  return out;
+}
+
+/** Where a bone's motion takes the point `v`: a link turns it about its origin and carries it to the link's posed origin. */
+function moved(link: { rest: Point; at: [number, number]; turn: number }, v: readonly [number, number]): [number, number] {
+  const rad = (link.turn * Math.PI) / 180;
+  const dx = v[0] - link.rest[0];
+  const dy = v[1] - link.rest[1];
+  return [link.at[0] + dx * Math.cos(rad) + dy * Math.sin(rad), link.at[1] - dx * Math.sin(rad) + dy * Math.cos(rad)];
+}
+
+/**
+ * Every pair of chains a lattice mesh's `segments` name, both keyed by a chain track, read as the module doc says.
+ * `images` holds each part's PNG by name, its `box` its parts.json box (rig px).
+ */
+export function chainSqueezes(
+  spec: { bones: readonly BoneEntry[]; meshes: Readonly<Record<string, MeshSpec>>; motion?: Motion },
+  parts: ReadonlyMap<string, { x: number; y: number; image: Raster }>,
+): SqueezeResult {
+  const findings: SqueezeFinding[] = [];
+  const unread: string[] = [];
+  const read: SqueezeResult['read'] = [];
+  const motion = spec.motion;
+  if (motion === undefined) return { findings, unread, read };
+  const tracks = new Map<string, ChainTrackLike>();
+  for (const t of motion.tracks) if ('chain' in t) tracks.set(t.chain, t);
+  const chains = new Map<string, { points: Point[]; tip: Point; parent: string }>();
+  for (const e of spec.bones) if ('chain' in e) chains.set(e.chain, { points: e.points, tip: e.tip, parent: e.parent });
+  // Every bone's parent, chain links as <chain><i>, so a bone under a link is carried by it.
+  const parent = new Map<string, string>();
+  for (const e of spec.bones) {
+    if ('chain' in e) e.points.forEach((_, i) => parent.set(`${e.chain}${i}`, i === 0 ? e.parent : `${e.chain}${i - 1}`));
+    else parent.set(e.name, e.parent);
+  }
+  const linkOf = new Map<string, [string, number]>();
+  for (const [c, e] of chains) e.points.forEach((_, i) => linkOf.set(`${c}${i}`, [c, i]));
+  // The nearest link at or above a bone, among the chains in `moving`.
+  const carrier = (bone: string, moving: ReadonlySet<string>): [string, number] | null => {
+    const seen = new Set<string>();
+    for (let b: string | undefined = bone; b !== undefined && !seen.has(b); b = parent.get(b)) {
+      const l = linkOf.get(b);
+      if (l !== undefined && moving.has(l[0])) return l;
+      seen.add(b);
+    }
+    return null;
+  };
+  const times = frameTimes(motion.duration);
+
+  for (const [mname, m] of Object.entries(spec.meshes)) {
+    const keyed = m.segments.filter((s): s is string => typeof s === 'string' && chains.has(s) && tracks.has(s));
+    if (keyed.length < 2) continue;
+    const pairs: Array<[string, string]> = [];
+    for (let i = 0; i < keyed.length; i++) for (let j = i + 1; j < keyed.length; j++) pairs.push([keyed[i], keyed[j]]);
+    const names = pairs.map(([a, b]) => `${a} and ${b}`).join(', ');
+    if ('contour' in m || 'auto' in m) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}) is a ${'contour' in m ? 'contour' : 'automatic'} mesh; only a lattice is built here`);
+      continue;
+    }
+    if (m.rule === 'heat') {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}) is weighted by rule "heat"; only the distance rule is read here`);
+      continue;
+    }
+    const part = parts.get(mname);
+    if (part === undefined) continue;
+    // The rig stage's segments: a chain is its links, each from its origin to the next link or the tip.
+    const segs: Segment[] = [];
+    let unresolved: string | null = null;
+    for (const sp of m.segments) {
+      if (typeof sp !== 'string') {
+        segs.push({ bone: sp[0], a: [sp[1][0], sp[1][1]], b: [sp[2][0], sp[2][1]] });
+        continue;
+      }
+      const c = chains.get(sp);
+      if (c !== undefined) {
+        const line = [...c.points, c.tip];
+        c.points.forEach((q, i) => segs.push({ bone: `${sp}${i}`, a: [q[0], q[1]], b: [line[i + 1][0], line[i + 1][1]] }));
+        continue;
+      }
+      const single = spec.bones.find((e) => 'name' in e && e.name === sp);
+      if (single === undefined || !('name' in single) || single.tip === undefined) {
+        unresolved = `its segment "${sp}" is not a chain or a single bone with a tip`;
+        break;
+      }
+      segs.push({ bone: sp, a: [single.at[0], single.at[1]], b: [single.tip[0], single.tip[1]] });
+    }
+    if (unresolved !== null) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}): ${unresolved}, so it has no weights to read`);
+      continue;
+    }
+    const img = pad(part.image, PAD, PAD, PAD, PAD, [0, 0, 0, 0]);
+    const allArt = alphaAbove(img, ART_ALPHA);
+    const art = m.stray === undefined ? allArt : latticeStray(allArt, m.stray).art;
+    const lm = latticeMesh(mname, art, m.grid);
+    if ('code' in lm) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}): its lattice is refused (${lm.code}), so there is no triangle to read`);
+      continue;
+    }
+    const ox = part.x - PAD;
+    const oy = part.y - PAD;
+    const limits = meshLimits(m.influences);
+    const rest: Array<[number, number]> = lm.vertices.map(([x, y]) => [x + ox, y + oy]);
+    const weights = rest.map((p) => {
+      const shares = influences(p, segs, m.r, limits, m.exponent ?? DISTANCE_EXPONENT);
+      return shares.length === 0 ? [] : limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares);
+    });
+    const restFlat = rest.flatMap(([x, y]) => [x, y]);
+    const worst = (moving: ReadonlyMap<string, 1 | -1>): SqueezeEdge | null => {
+      const set = new Set(moving.keys());
+      const frames = times.map((t, index) => {
+        const posed = new Map<string, ReturnType<typeof posedLinks>>();
+        for (const [c, sign] of moving) {
+          const e = chains.get(c) as { points: Point[]; tip: Point };
+          posed.set(c, posedLinks([...e.points, e.tip], tracks.get(c) as ChainTrackLike, sign, t));
+        }
+        const vertices: number[] = [];
+        rest.forEach((v, vi) => {
+          let x = 0;
+          let y = 0;
+          for (const { bone, weight } of weights[vi]) {
+            const l = carrier(bone, set);
+            const to = l === null ? v : moved((posed.get(l[0]) as ReturnType<typeof posedLinks>)[l[1]], v);
+            x += weight * to[0];
+            y += weight * to[1];
+          }
+          vertices.push(x, y);
+        });
+        return { index, attachments: [{ slot: mname, attachment: mname, vertices }] };
+      });
+      const [fig] = stretchFigures([{ slot: mname, attachment: mname, vertices: restFlat, triangles: lm.triangles }], frames);
+      if (fig.max === null || fig.min === null) return null;
+      const sMax = stretchSeverity(fig.max.ratio);
+      const sMin = stretchSeverity(fig.min.ratio);
+      return sMin > sMax ? { at: fig.min, severity: sMin } : { at: fig.max, severity: sMax };
+    };
+    for (const [a, b] of pairs) {
+      read.push({ mesh: mname, a, b });
+      const both = worst(new Map([[a, 1], [b, 1]]));
+      if (both === null || both.severity <= TEXTURE_STRETCH_CEILING) continue;
+      const aloneA = (worst(new Map([[a, 1]])) as SqueezeEdge).severity;
+      const aloneB = (worst(new Map([[b, 1]])) as SqueezeEdge).severity;
+      const ta = tracks.get(a) as ChainTrackLike;
+      const tb = tracks.get(b) as ChainTrackLike;
+      const opposed = ta.amps.length === tb.amps.length && ta.amps.every((v, i) => v * tb.amps[i] < 0);
+      const ca = chains.get(a) as { tip: Point };
+      const cb = chains.get(b) as { tip: Point };
+      findings.push({
+        mesh: mname,
+        a: { chain: a, amps: [...ta.amps], tip: ca.tip },
+        b: { chain: b, amps: [...tb.amps], tip: cb.tip },
+        tipGap: edgeLength(ca.tip[0] - cb.tip[0], ca.tip[1] - cb.tip[1]),
+        both,
+        vertices: both.at.edge.map((vertex) => ({ vertex, weights: [...weights[vertex]].sort((p, q) => q.weight - p.weight).slice(0, 2), of: weights[vertex].length })),
+        aloneA,
+        aloneB,
+        turned: opposed ? (worst(new Map<string, 1 | -1>([[a, 1], [b, -1]])) as SqueezeEdge).severity : null,
+      });
+    }
+  }
+  return { findings, unread, read };
+}