@rig-c/parts 1.22.0 → 1.24.0

package/README.md

@@ -107,7 +107,7 @@ page** (issue #2):
 
 | path under `--out` | what |
 | --- | --- |
-| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack --page-edges free --pack-shape polygon` and gated under `spine-html`, which holds every rule `spine` measures (on reference-demo, rigc 2.1.3 and 2.10.1: the 14 rules `validate --profile spine` measures are among the build's 24; 16 are not in `spine`) |
+| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack --page-edges free --pack-shape polygon` and gated under `rig-play` (named `spine-html` before rig-c 2.50.0), which holds every rule `spine` measures (on reference-demo, rigc 2.1.3 and 2.10.1: the 14 rules `validate --profile spine` measures are among the build's 24; 16 are not in `spine`) |
 | `parts/*.png`, `parts.json`, `recomposite_rig.png`, `recomposite_error_rig.png` | the loose parts, each cropped to its alpha box; the record of where every part came from, how many of its pixels were re-taken from the painting, and the recomposite's uncovered holes with their boxes; the flat stack of parts; its error map — red where no part covers a pixel the painting has, blue where a part covers it in the wrong colour |
 | `rig/` | `rig.json` and `motion.json` in rig-c's spec, `mesh_report.json`, the padded `images/` |
 | `check/` | both gate files verbatim, the idle's frames and their `geometry.json` (skinned vertices per frame), `contact.png`, `motion_heat.png`, `check.json` (with `pack_mode`, the `--page-edges` and `--pack-shape` the page was packed under) |
@@ -155,7 +155,7 @@ atlas written by anything else would have no oracle behind it.
 | --- | --- | --- |
 | painting + See-through layers → parts and specs | **rig-parts** (npm `@rig-c/parts`) | the merge of two runs, the measurements, the rig spec and motion spec |
 | specs → Spine skeleton data | **[rig-c](https://github.com/rig-c/core)** (npm `rig-c`) | compile, the gate (rigc's own validator in an install; the round trip through `spine-core` where the runtime is beside it, as in this repository's CI), the named assertions, the packer, the renderer |
-| skeleton data → a page | **[rig-play](https://github.com/rig-c/play)** (npm `@rig-c/play`; formerly spine-html), a sibling project | a DOM renderer; rigc's `spine-html` profile is its policy, and every build here is gated under that profile as well as under `spine` |
+| skeleton data → a page | **[rig-play](https://github.com/rig-c/play)** (npm `@rig-c/play`; formerly spine-html), a sibling project | a DOM renderer; rigc's `rig-play` profile is its policy, and every build here is gated under that profile as well as under `spine` |
 
 rig-parts never writes Spine data itself. Everything on disk under `check/build/`
 was written by rig-c after its own gate passed.
@@ -305,7 +305,7 @@ agent skill.
 | `propose … --from-config <config>` | draw and LINT the config's current bones (by the joints too, given `--keypoints`) |
 | `compare --left <file> --right <file> [--map <bonemap.json>]` | compare two skeletons — a config, a proposal or a `rig.json` — bone by bone: origin, parent, tip, length and direction per pair, the bones neither side pairs, the required ones missing, and each side's roles read off the spec; no frame is guessed, and nothing pairs by resemblance (`propose --compare` reads origins only) |
 | `rig --config --parts --out [--idle-keys ctl\|direct]` | author `rig.json` + `motion.json`, written only after rig-c's gate is green; each mesh is in the mode its config entry names — `grid` (the lattice, what `propose` writes), `contour` (the traced outline with declared interior points) or `auto` (the contour mesh at alpha 1 and above, reduced and locally refined by rig-c's `reduceMesh` under the author's declared bounds, written only when its motion against the unreduced source on the idle passes the author's `motion` bounds through rig-c's `compareMeshesInMotion`; [AUTHORING §3](docs/AUTHORING.md)); every chain link is turned along its chain and carries its `length`, so a physics constraint added later has a lever, with every offset under it in the turned frame so nothing moves; `--idle-keys` says whether the idle's keys on mesh-driving bones go through `<bone>_ctl` parents (default) or stay on the bones with `invariants.idleDrivesMeshes` declared; the config's `constraints` go to rigc as written, and a two-bone ik over keyed links needs `--idle-keys direct` (on `rig` or `build`) |
-| `check --rig --out [--parts] [--source] [--requirements]` | build packed, gated under `spine-html`, render the idle, measure seam, loop and the six judgement lines (mesh texture stretch among them, from the idle's `render --geometry`), and report the recomposite's holes from `parts.json`; on a rig spec with no `parts.json` or no `idle` (a merged rig, issue #77) the gate still runs and every line that needs the missing input says SKIP by name; `--source <painting.png>` adds `SETUP_POSE_VS_SOURCE`, the setup pose against the painting by assemble's recomposite figures; `--requirements <scene.json>` measures what a scene declares of the motion — a contact, a follow fraction, an aim, a joint range, a mesh's stretch, the seam between two parts over the motion — each against the author's own bar, from rig-c's posed frames, one line each, PASS, FAIL or NOT MEASURABLE (AUTHORING §7, *Declared requirements*) |
+| `check --rig --out [--parts] [--source] [--requirements]` | build packed, gated under `rig-play`, render the idle, measure seam, loop and the six judgement lines (mesh texture stretch among them, from the idle's `render --geometry`), and report the recomposite's holes from `parts.json`; on a rig spec with no `parts.json` or no `idle` (a merged rig, issue #77) the gate still runs and every line that needs the missing input says SKIP by name; `--source <painting.png>` adds `SETUP_POSE_VS_SOURCE`, the setup pose against the painting by assemble's recomposite figures; `--requirements <scene.json>` measures what a scene declares of the motion — a contact, a follow fraction, an aim, a joint range, a mesh's stretch, the seam between two parts over the motion — each against the author's own bar, from rig-c's posed frames, one line each, PASS, FAIL or NOT MEASURABLE (AUTHORING §7, *Declared requirements*) |
 | `loop --frames <dir> --out <file.gif \| file.png> [--palette]` | encode a rendered idle as a looping GIF, lossless APNG, or indexed APNG (`--palette`) |
 | `build --config --source --full --head --out [--seam] [--project] [--loop] [--lead-in <periods>] [--requirements] [--seam-pairs] [--keep-stills] [--idle-keys ctl\|direct]` | assemble, rig and check in one process, stopping at the first refusal; `--requirements`, `--seam-pairs` and `--keep-stills` are forwarded to check, `--idle-keys` to rig; `--lead-in` (with `--loop`) encodes the loop from the last of n + 1 idle periods played back to back, for a rig whose physics does not end where the render starts it |
 | `compose --scene <scene.json> --out [--requirements] [--accept]` | bind several characters' green builds into one rig (or, under `--accept`, builds failing only the bars named — for looking, not shipping): every name prefixed `<id>:` under one shared root, each character's offset added at its first-level bones, an optional background plate (its provenance recorded, judged by nothing) drawn first, and the draw order between the characters' slots as the scene file declares it — nothing inferred, nothing scaled; gated through rig-c as `rig` is, then checked ([AUTHORING §7](docs/AUTHORING.md), *Composing several characters*) |

package/cli.ts

@@ -209,7 +209,10 @@ usage:
       of the consumer's environment — no direction is drafted), and drafts no
       idle key on them. A bottomwear recipe's "swing" drives each tree's
       first link from one shared pendulum. A recipe that drafts nothing is
-      refused (PROPOSE_CLOTH_DRAFTED). Without --cloth nothing changes.
+      refused (PROPOSE_CLOTH_DRAFTED). A topwear part shaped like a skirt (a
+      dress) is named in a note, never drafted on its shape; a bottomwear
+      recipe's "part" declares it, and its trees hang from the hip over the
+      part's art below it (PROPOSE_CLOTH_PART). Without --cloth nothing changes.
 
   rig-parts propose --parts <dir> --source <painting.png> --out <dir> --from-config <config.json>
       Draw the config's CURRENT bones instead (<out>/render/landmarks_config.png

package/docs/AUTHORING.md

@@ -29,6 +29,12 @@ kept as fixtures because their `expected/` is that implementation's own output;
 figure this guide quotes for them was measured on them. `demo` is the painting the
 README shows since issue #227 and `scarf` the hanging-element example; both have
 `expected/` from this port's own build, and a figure quoted for them says so.
+In every example, `expected/rig.json` is the flat form: every bone unturned, which is
+`flattenRig` (`src/rig.ts`) of the built rig. A build's `rig/rig.json` carries
+`rotation` and `length` on its chain links, and the offsets under them in the turned
+frame (§5, the `rig` row), where that file holds unturned offsets only, so the two
+differ as text and not as a rig: the chain suite (`CH03`) compares `expected/rig.json`
+with `flattenRig(built)`, not with the built file.
 
 ## 1. Prerequisites
 
@@ -117,7 +123,7 @@ read by no CPU stage).
 | `constraints` | rig (handed to rig-c as `rig.json`'s `constraints`); `compare` and the coverage lines (roles) | **authored**, optional; `propose` writes none, but with `--cloth` (issue #364), where it writes the recipe's physics and swing transforms (*Recipe: cloth and hair that answer the world*, below). A list of constraints in **rig-c's own rig-spec shape** (`RigConstraint`: `ik`, `transform`, `path`, `physics`, `slider` — rig-c's `src/rig.ts` documents every field), in the order rigc applies them. The loader checks only what this package owns: each entry is an object with a `type` rigc names (`CONFIG_CONSTRAINT_TYPE_KNOWN`) and a non-empty `name`, unique within its kind as rigc finds constraints (`CONFIG_CONSTRAINT_NAME_UNIQUE`; an ik and a transform may share one); every bone it names — `bones`, an ik's `target`, a transform's `source`, a physics or slider constraint's `bone` — is a bone `bones` declares, a chain link as `<chain><i>` (`CONFIG_NAME_RESOLVES`); the bone a constraint follows does not sit under a bone it drives (`CONFIG_CONSTRAINT_TARGET_DETACHED`). Every other field (`mix`, `softness`, `properties`, a path's `slot`, a slider's `animation`) and every value is rigc's to accept or refuse at the rig stage's gate, in rigc's words (`RIG_RIGC_GREEN`) — an ik's `bones` as a shape too: from rig-c 2.15.0 rigc refuses an ik over more than two bones, or over a pair whose second bone is not the first's child (issue #103; this loader refused both itself until then). A note and an `x-` record may ride on an entry; the rig stage leaves them out of what it hands rigc. Under the default `--idle-keys ctl` a two-bone ik whose child link the idle keys is split by that link's control, and rigc refuses the pair: run `rig --idle-keys direct` or `build --idle-keys direct` (the rig stage adds that sentence, naming the flag on the command that ran, to rigc's line; `build` forwards it to its rig stage, issue #95). Each bone a constraint follows is declared to rigc as `invariants.detached` from every bone it drives, which rigc's gate rule `A25` checks |
 | `turn` | rig (adds the turn control) | **proposed** only with `propose --full`/`--head` (issue #251), then corrected: `{pivot, depths}`. `depths` holds, per part, the See-through layer's `depth_median` the part came from (larger = further back), read from the run the part was assembled from; a `painting:` patch has none and is not carried. A rider (issue #271) — a part from an `eyewhite`, `irides`, `eyelash`, `eyebrow`, `nose` or `mouth` layer — is drafted at the `face` part's depth, 0.001 nearer when parts.json draws it after the face and 0.001 further when before: See-through makes no depth of its own for the eye group (it cuts them from one depth map of the combined eyes) and clamps nose and mouth to the face's median − 0.001, and the two runs' own medians for these layers disagreed by up to 0.47 and swapped their order against the face. Every other layer — ears, headwear and earwear included — keeps its own median. With no `face` part, or more than one, the riders keep their own and a note says so. One note lists each part's depth and where it came from; a carrier the other run places more than 10 % of `pivot − nearest` away gets a note naming both values and the run read — the two runs are not reconciled. `pivot` is the depth that stays put; `propose` drafts the mean of the parts' depths weighted by `opaque_px`, the one depth at which the painted pixels' centroid does not slide under the dial. The rig stage adds a bone `turn` under `root` at its origin that nothing keys — its local x is the dial, in rig px — and carries each part by `(pivot − depth) / (pivot − nearest depth)` of it: the nearest part all of it, a part behind the pivot the other way, a part at the pivot not at all. Each part rides leaf twins (`turn_<part>_<bone>`, an identity child of every bone its slot and weights bind) moved by one `transform` constraint (`turn_<part>`, after the config's own); the idle's keys, the `<bone>_ctl` controls and a physics constraint stay on the bones, and the dial moves none of them. At rest: with `turn` declared, no pixel differs by more than 1 level at dial 0 (not byte-identical; the cause is float noise in the identity child bones, and the constraints add nothing); without `turn`, byte-identical. Neither field has a default (`CONFIG_FIELD_PRESENT`); the pivot must lie behind the nearest part (`CONFIG_TURN_PIVOT_BEHIND_NEAREST`). Absent, no control is added and no byte of any output moves |
 | `scene` | assemble (the recomposite, its holes and the figure's mask); check, through `parts.json`'s `scene` block (`RECOMPOSITE_HOLES`, the seam) | **authored**, optional; `propose` writes none (issue #242). `{}` declares the painting a scene: the figure and its surroundings in one image, See-through's full run holding only the figure. With it, `assemble` reads the recomposite figures, the hole list and the `uncovered:` lines inside the figure — the rig pixels where any full-run layer's alpha is above 8 (`OPAQUE_ALPHA_ABOVE`, the cut every layer's painted pixels are read by) — each line starting `inside the figure (config.scene: …, <n> of <m> rig px)`; writes that figure as `figure_rig.png` (white on black) beside the recomposite, and a `scene` block in `parts.json`; flags error pixels on the error map inside it only (outside, the painting grey); and `check` leaves out of the seam every frame pixel whose composite sample reaches the painting's outermost row or column, saying how many (`seam_border` in `check.json`, and on the seam line). It takes no field: the figure and its threshold are derived. A key in it other than a record or an annotation is `CONFIG_KEY_KNOWN`. Absent, no byte of any output moves |
-| `cloth` | `propose --cloth` only; no other stage reads it, so it moves no byte of any build | **authored**, optional (issue #364): one recipe per tag, `{"bottomwear": {…}, "back hair": {…}, "front hair": {…}}`, each `{chains, links, wind, gravity, split?, length_ratio?, strength?, damping?, alternate_damping?, translate?, swing?}`. `chains` — trees across the piece (for `back hair`, per side of the eye axis), a whole number, 1 or more; `links` — links from root to tip on every path, 1 or more; `split` — `{at, into}`: the first `at` links are the trunk, which forks into `into` (2 or more) branches; `at` below `links` (`CONFIG_CLOTH_SPLIT_BEFORE_TIP`); `length_ratio` — a path's last link over its first, above 0, default 0.5; `strength` — `{trunk, branch, edge}`, each above 0 and below the spring's stability bound (`CONFIG_CLOTH_SPRING_STABLE`), default 100 / 100 / 50; `damping` — in [0, 1], absent: rig-c's default; `alternate_damping` — the odd trees' damping, in [0, 1], beside `damping` and different from it (`CONFIG_CLOTH_ALTERNATE_DIFFERS`); `wind`, `gravity` — `[root, tip]`, each 0 or more, tip at or above root (`CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP`); `translate` — the x and y mix of a dangling end's flutter, above 0 and at most 1; `swing` — `bottomwear` only, `{scales}`, one positive scale per tree (`CONFIG_CLOTH_SWING_SCALE_PER_TREE`). The two defaults are the recipe's own, measured on its synthetic fixture (the recipe below). The recipe below says what each field drafts |
+| `cloth` | `propose --cloth` only; no other stage reads it, so it moves no byte of any build | **authored**, optional (issue #364): one recipe per tag, `{"bottomwear": {…}, "back hair": {…}, "front hair": {…}}`, each `{chains, links, wind, gravity, split?, length_ratio?, strength?, damping?, alternate_damping?, translate?, swing?, part?}`. `chains` — trees across the piece (for `back hair`, per side of the eye axis), a whole number, 1 or more; `links` — links from root to tip on every path, 1 or more; `split` — `{at, into}`: the first `at` links are the trunk, which forks into `into` (2 or more) branches; `at` below `links` (`CONFIG_CLOTH_SPLIT_BEFORE_TIP`); `length_ratio` — a path's last link over its first, above 0, default 0.5; `strength` — `{trunk, branch, edge}`, each above 0 and below the spring's stability bound (`CONFIG_CLOTH_SPRING_STABLE`), default 100 / 100 / 50; `damping` — in [0, 1], absent: rig-c's default; `alternate_damping` — the odd trees' damping, in [0, 1], beside `damping` and different from it (`CONFIG_CLOTH_ALTERNATE_DIFFERS`); `wind`, `gravity` — `[root, tip]`, each 0 or more, tip at or above root (`CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP`); `translate` — the x and y mix of a dangling end's flutter, above 0 and at most 1; `swing` — `bottomwear` only, `{scales}`, one positive scale per tree (`CONFIG_CLOTH_SWING_SCALE_PER_TREE`); `part` — `bottomwear` only (`CONFIG_CLOTH_PART_ON_BOTTOMWEAR`), a non-empty part name: the `topwear` part that holds a skirt See-through returned inside it (a dress), which takes the skirt's trees as well (issue #402, *A skirt inside topwear* below; the part is checked by `propose`, `PROPOSE_CLOTH_PART`). The two defaults are the recipe's own, measured on its synthetic fixture (the recipe below). The recipe below says what each field drafts |
 
 **A scene target is an ordinary bone.** A target the scene places — a point a hand
 reaches for, a face something turns toward — is a single bone parented to `root`,
@@ -1583,6 +1589,7 @@ What each rule drafts (`src/cloth.ts` holds them):
 | response | link j of an n-link path takes `wind` and `gravity` at j/(n − 1) of the way from the root value to the tip value; a single-link path takes the tip value. Each is a scalar **multiplier** of the environment the consumer sets (spine-core's skeleton `windX, windY`, `gravityX, gravityY`; rig-c 2.52.0's live track `setEnvironment`, rig-play 1.10.0's `environment()`): no direction is drafted | `wind`, `gravity` |
 | out of phase | the odd trees take `alternate_damping`, the even ones `damping` | `damping`, `alternate_damping` |
 | flutter | the last link of every path gets a second physics constraint, `<bone>_translate`, moving x and y by `translate`, with the link's stiffness and damping and **no** wind or gravity response. spine-core scales a translate spring's response by the skeleton's reference scale (100) and a rotation's by the link's length over it, so one response on both pushes an end about 100/length times further than it turns it (the table below) | `translate` |
+| part | `bottomwear` only (issue #402): the named `topwear` part takes the skirt's rule as the `bottomwear` parts do — trees from `hip` over its art below the hip, its waist line, and, as its art reaches above the chest, the chest segment the long-robe `bottomwear` keeps — in place of the two robe chains the topwear rule drafts; the prefix is `skirt` when it is the only skirt, `skirt_<part>` beside another | `part` |
 | swing | `bottomwear` only: a bone `<prefix>_swing` under `hip` at the centre of the root row, one link long, straight down, with physics (the trunk's stiffness, the root's response); each tree's first link takes the swing's rotation times its scale — a transform `<swing>_<k>`, local source and target, additive, the swing's setup rotation in hip's frame (−90: hip is drafted unturned) subtracted — and no physics of its own | `swing.scales` |
 
 Every link but a swing-driven first link gets `<bone>_physics` (`rotate` 1), and no
@@ -1590,6 +1597,51 @@ idle key: the drafted idle keys none of the trees. A recipe that drafts nothing
 its tag on no part, or `back hair` that ends above the shoulders (a bun) — is refused,
 `PROPOSE_CLOTH_DRAFTED`.
 
+**A skirt inside topwear (issue #402).** The recipe finds a skirt by the `bottomwear`
+tag alone. When See-through returns the skirt inside `topwear` (a dress), nothing is
+tagged `bottomwear`, and the proposer does not pick the dress by its shape: with
+`--cloth`, a `topwear` part whose box reaches 0.25 face heights below the hip (the
+topwear rule's own waist line) and whose art is wider across its last 24 rows than in
+the 24-row band at the hip is **named in a note** — the part, its art's rows below the
+hip, and the field — and in `PROPOSE_CLOTH_DRAFTED`'s line when a `bottomwear` recipe
+found no part. The author declares it, `"bottomwear": { …, "part": "<name>" }`, instead
+of moving the layer. Why a name and not a draft, measured on the public examples' builds
+(this port's assemble, the proposer's hip): `scarf`'s `topwear`, an outer robe over a
+separate `bottomwear` skirt, passes the same shape (rows 658 to 890 below the hip at y
+657; 287 px across its last rows against 271 at the hip), so a draft by shape would hang
+a second set of skirt trees on a robe; `wind`'s `topwear`, a blouse whose sleeves reach
+the hip band, does not (350 px against 493). Without `--cloth` nothing is named, so every
+example's proposal is the one it was. What a declared dress drafts, measured on the
+selftest's dress fixture (`fixtures/cloth.ts`, flat colour; RG480 prints the figures):
+one lattice on chest, hip and the trees, built green through the gate with no split of
+the mesh; the bodice is not held wholly to the chest — a vertex above the hip carries up
+to 0.258 of its weight on the trees; and `check`'s `BREATH_VISIBLE`, which reads every
+`topwear` part as the torso, read the dress's idle heat at 1.592 against the floor
+3.809, where the same dress with the robe chains read 3.9 — the half on the trees has
+no idle key. Neither is barred here; both are the dress's to weigh before declaring it.
+Since issue #411 the bar reads the breath alone, and on that fixture the breath moves
+the dress 0.106 and the robe-chained dress 2.62: both fail, and the 3.9 was the robe
+chains' keyed swing below the hip, not the breath (the CK502 and CK503 controls).
+
+**What rides a tail** (issue #391). An accessory wrapped round a tail the `back hair`
+recipe drafts — a ribbon, in See-through's `headwear` or `earwear` layer — rides that
+tail's links, not `head`: under the recipe the tail moves by the world, and a part left on
+`head` stays where the tail was. Which links is read off the overlap, never off the
+part's name: each of the part's pixels over the tail's art is given to the span of the
+back hair's mesh nearest it (its fixed segment on `head`, or one tree link, the distance
+the weights read), and the part rides when one of those spans is a link. Its mesh's
+segments are then the spans it lies on — each link by name, the head's span written
+out — so every vertex weights by the rule the tail's own art does, the pixels off the
+tail (a ribbon's loops) included; no accessory bone, pendant or strand chain is drafted
+for it, and a note names each span with its pixel count. A part over no link keeps the
+accessory rule. It is part of the recipe's drafting, not a field: the rule reads only
+the art, and without the recipe no tail moves by the world and nothing here runs. On
+`wind` (rig-c 2.54.0, `rigc render --environment`, idle frame 200 of 200 at 60 fps,
+0.916 px per rig px), the ribbon pixels painted over the tail that are drawn where the
+tail has no hair went from 2,429 at calm and 8,363 at wind (10, 0) to 30 and 230; the
+230 all lie within 3.6 px of the hair's edge, where the ribbon's mesh and the hair's are
+two different lattices.
+
 **Every spring is stable at its step (A23's inequality).** Per step spine-core does
 `v += −strength·x·step·massInverse`, `x += v·step`, `v *= d` with d = damping^(60·step);
 in (x, v·step) that is the matrix [[1 − k, 1], [−d·k, d]] with
@@ -2239,8 +2291,8 @@ reference's so the examples stay comparable with it. `build` takes both flags.
 **`rig --idle-keys ctl|direct`** (and `build --idle-keys`, which forwards the
 value to its rig stage; without the flag, or with `ctl`, a build writes and prints
 what it did before `build` took the flag). rig-c's `A15_IDLE_NO_MESH_BONE_KEYS`
-(profile `spine-html`) refuses an idle that keys a bone a mesh is weighted to. `ctl`
-(the default, the reference's answer) gives every such bone a same-origin
+(profile `rig-play`, named `spine-html` before rig-c 2.50.0) refuses an idle that
+keys a bone a mesh is weighted to. `ctl` (the default, the reference's answer) gives every such bone a same-origin
 `<bone>_ctl` parent and moves its keys there, which passes A15 on any rig-c;
 the stage prints `idle keys ctl: N mesh-driving bone(s) keyed …`. `direct` keys the
 bones themselves and writes `invariants.idleDrivesMeshes: { "why": … }` into
@@ -2543,6 +2595,7 @@ See-through with another seed.
 | <a id="CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP"></a>`CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP` | a `cloth` recipe's `wind` or `gravity` is `[root, tip]` with tip below root: the response grows from the root to the tip, where the motion accumulates down the chain | that pair |
 | <a id="CONFIG_CLOTH_ALTERNATE_DIFFERS"></a>`CONFIG_CLOTH_ALTERNATE_DIFFERS` | a `cloth` recipe's `alternate_damping` without `damping`, or equal to it: neighbouring trees are declared out of phase, and an alternate that alternates nothing declares nothing | `damping` beside it, a different value, or leave `alternate_damping` out |
 | <a id="CONFIG_CLOTH_SWING_SCALE_PER_TREE"></a>`CONFIG_CLOTH_SWING_SCALE_PER_TREE` | `swing` on a tag other than `bottomwear`, or `swing.scales` not one scale per tree (`chains`) | one scale per tree, in tree order across the skirt |
+| <a id="CONFIG_CLOTH_PART_ON_BOTTOMWEAR"></a>`CONFIG_CLOTH_PART_ON_BOTTOMWEAR` | `part` on a `cloth` recipe for a tag other than `bottomwear` (issue #402) | leave it out there; `part` hands the skirt's recipe to a `topwear` part that holds a skirt (a dress) |
 | <a id="CONFIG_CLOTH_SPRING_STABLE"></a>`CONFIG_CLOTH_SPRING_STABLE` | a `cloth` recipe's strength — declared, or the default 100 / 100 / 50 — whose spring is unstable at a damping the recipe runs at (`damping`, `alternate_damping`, or rig-c's 0.85 when `damping` is left out): k = strength·massInverse·step² at or past 2(1 + damping^(60·step)), step 1/60 and mass 1 (rig-c's defaults; the recipe sets neither). The detail gives k and the bound | a lower strength, or a higher damping |
 | <a id="CONFIG_TURN_BONE_FREE"></a>`CONFIG_TURN_BONE_FREE` | the config has `turn` and `bones` declares a bone named `turn`, the control the rig stage adds | rename that bone |
 
@@ -2624,7 +2677,8 @@ says why each requirement exists and what breaks without it.
 | <a id="PROPOSE_FACE_PRESENT"></a>`PROPOSE_FACE_PRESENT` | no part comes from a `face` layer, and the face-less fallback cannot derive a face box either: it needs the head run's `neck` and at least one head-run `front hair`/`back hair` part whose top is above the neck's, and the message names the half that is missing. With both, `propose` does not refuse — it derives the box and says so in its first note (§5) | `assemble.plan`: take the face, or the head run's hair and neck |
 | <a id="PROPOSE_CUT_FROM_RECORDED"></a>`PROPOSE_CUT_FROM_RECORDED` | two parts share one layer and none of them records `cut_from`: a `parts.json` an `assemble` before 1.6.0 wrote with `assemble.cuts`. The records are in draw order, so which is the plan part and which the piece cannot be read off the file; the message names the parts and the layer. Every other reader still takes the file | `--parts`: re-run assemble (1.6.0+) to record `cut_from` |
 | <a id="PROPOSE_LIMB_PARTS"></a>`PROPOSE_LIMB_PARTS` | `parts.json` holds parts `config.limbs` cut at their joints (issue #349); the limbs are drafted from the parts before the cut, which the rules read by layer | `--parts` a build assembled with the config's `limbs` left out; keep the block the config holds (its caps and ranges are the author's). `propose --from-config` reads the config's bones on either build |
-| <a id="PROPOSE_CLOTH_DRAFTED"></a>`PROPOSE_CLOTH_DRAFTED` | with `--cloth` (issue #364): the config's `cloth` block holds a recipe for a tag the proposer drafts no chain on — no part has that tag, or every `back hair` part ends above the shoulders (a bun bone, no chain) | leave that recipe out, or assemble the layer it is for |
+| <a id="PROPOSE_CLOTH_DRAFTED"></a>`PROPOSE_CLOTH_DRAFTED` | with `--cloth` (issue #364): the config's `cloth` block holds a recipe for a tag the proposer drafts no chain on — no part has that tag, or every `back hair` part ends above the shoulders (a bun bone, no chain). A `bottomwear` recipe with no `bottomwear` part names every `topwear` part shaped like a skirt (issue #402) | leave that recipe out, or assemble the layer it is for, or declare the named part in `cloth.bottomwear.part` |
+| <a id="PROPOSE_CLOTH_PART"></a>`PROPOSE_CLOTH_PART` | with `--cloth` (issue #402): `cloth.bottomwear.part` names no part, a part that is not `topwear` (a `bottomwear` part takes the recipe by its tag already), a cut piece (`cut_from`), or a `topwear` whose box ends above the hip + 0.25 face heights, the topwear rule's waist line | name the `topwear` part that holds the skirt, or leave `part` out |
 | <a id="PROPOSE_ACCESSORY_BODY"></a>`PROPOSE_ACCESSORY_BODY` | an accessory has nothing above its pendant rows to hang its bone on | that part's plan entry, or author its bones by hand |
 | <a id="PROPOSE_TURN_RUN_GIVEN"></a><a id="PROPOSE_TURN_LAYER_PRESENT"></a><a id="PROPOSE_TURN_DEPTH_PRESENT"></a>`PROPOSE_TURN_RUN_GIVEN`, `PROPOSE_TURN_LAYER_PRESENT`, `PROPOSE_TURN_DEPTH_PRESENT` | with `--full`/`--head` (issue #251): a part came from a run whose layers were not given, the run given holds no layer of the part's tag, or its layer carries no `depth_median` while another part's layer carries one; a run with no depth on any part's layer (a PSD, or an export of one) is not refused — the turn is skipped, and the note says `turn: SKIP` and names the run (issue #359) | give the run the parts were assembled from, as the wrapper's `layers.json` |
 | <a id="BASIS_RECORDS_EVERY_BONE"></a><a id="BASIS_NAMES_RESOLVE"></a><a id="BASIS_KIND_KNOWN"></a><a id="BASIS_KIND_HOLDS"></a>`BASIS_RECORDS_EVERY_BONE`, `BASIS_NAMES_RESOLVE`, `BASIS_KIND_KNOWN`, `BASIS_KIND_HOLDS` | `propose --keypoints`'s record of how it placed each bone, `basis.json`, does not hold to the proposal it was written with: a proposed bone with no record, one recorded twice or out of the proposal's order; a part, bone or frame quantity it names that is not there; a placement kind outside the known ones; or a placement that does not hold what its kind says (a joint placement with no joint, a non-joint one with a joint, a derived one with no bone, a constant that is not finite). Nothing is written | a proposer bug, not an input problem: report it with the line |
@@ -2721,7 +2775,7 @@ documents do not ship). Each is an input this package built; none is an author's
 | <a id="CHECK_LOOP_LAST_FRAME_AT_DURATION"></a>`CHECK_LOOP_LAST_FRAME_AT_DURATION` | the idle's last frame does not sit at `duration` | `motion.duration` — a whole number of 1/12 s |
 | <a id="CHECK_LOOP_CLOSES"></a>`CHECK_LOOP_CLOSES` | frame 0 and the frame at `duration` differ (max and first pixel quoted); with a physics constraint, the frames of the rig with every physics constraint left out, and the object says so (§7, *loop*) | a track whose last key is not its first |
 | <a id="CHECK_SEAM_WITHIN_BAR"></a>`CHECK_SEAM_WITHIN_BAR` | the setup pose does not reproduce the flat stack of parts | read the `seam pair` lines and `check/seam/` pictures (§7; magenta = a counted pixel, cyan = the box round them): the pair, its boxes and the pixels counted. Usually a region or mesh placed off its part; compare with `recomposite_rig.png`. A pair of one layer cut in two with `differing_copies_px` is the cut line: move the polygon's edge, not `overlap` |
-| <a id="CHECK_BREATH_VISIBLE"></a>`CHECK_BREATH_VISIBLE` | the torso (`topwear`), rendered alone, barely moves over the idle — or the feet (`footwear`), rendered alone, move at all | the chest's breath tracks (`motion.tracks` on `chest`), or the torso mesh's `segments`; for the feet, the bone their region rides (`regions.<part>`, `root` in both examples) |
+| <a id="CHECK_BREATH_VISIBLE"></a>`CHECK_BREATH_VISIBLE` | the breath alone barely moves the torso (`topwear`, rendered alone, the idle with and without its breath tracks — issue #411; the whole idle's figure is printed beside it, and motion that is not the breath's is not counted), or the idle has no breath track at all — or the feet (`footwear`), rendered alone, move at all | the chest's breath tracks (`motion.tracks` on `chest`), or the torso mesh's `segments`; for the feet, the bone their region rides (`regions.<part>`, `root` in both examples) |
 | <a id="CHECK_BLINK_NO_HOLE"></a>`CHECK_BLINK_NO_HOLE` | with the blink held shut, the eyewhite box shows the page where the open eye had art | the layer under the eye: the `face` part has no art there. Take the face from the other run, or add a part under the eye; `motion.blink.squash` only hides the hole less |
 | <a id="CHECK_CHAIN_LAG"></a>`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) |
 | <a id="CHECK_TIP_OVER_ROOT"></a>`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 |
@@ -2800,8 +2854,8 @@ implementation's bars) — each one that measured; a rig with no `parts.json` or
 assemble*, at the end of this section):
 
 - `gate_spine-html.txt`: every summary line `(N passed, 0 failed)` — the packed build
-  under the `spine-html` profile, gated once over the compile and once over the packed
-  pages on disk. There is no `spine` gate of its own: `spine-html` holds every rule
+  under the `rig-play` profile, gated once over the compile and once over the packed
+  pages on disk. There is no `spine` gate of its own: `rig-play` holds every rule
   `spine` measures (on reference-demo, rigc 1.5.1 and 2.0.3: `validate --profile spine`'s 14
   measured rules are all among the build's 23, the 15 others not in `spine`; rigc
   2.1.3 and 2.10.1: the same 14 among the build's 24, which adds
@@ -2895,7 +2949,7 @@ the two examples [observed]:
 
 | line | measures | bar | `reference-demo` | `reference-sample` | SKIP when |
 | --- | --- | --- | --- | --- | --- |
-| <a id="BREATH_VISIBLE"></a>`BREATH_VISIBLE` | `topwear` parts rendered alone (`rigc render --slot`): heat mean over their box; `footwear` parts alone: heat max over theirs | torso mean ≥ 3.809; feet max ≤ 0 | 15.251; 0 | 7.617; 0 | no `topwear` and no `footwear` part. One of the two absent (issue #323): the other half is measured and decides the line, which then carries `halves_measured` `"1 of 2"` first, then each half's own status — `torso_status`, `feet_status` — the absent half's `SKIP` with its `torso_reason` or `feet_reason`; a run that measured both halves writes the keys it always wrote |
+| <a id="BREATH_VISIBLE"></a>`BREATH_VISIBLE` | the torso: the breath alone (issue #411). The breath bones are every bone an idle track translates, and the breath tracks every idle track that translates or scales one of them (the drafted breath: `chest` `translatey` and `scalex`). The `topwear` parts are rendered alone (`rigc render --slot`) from one throwaway build that carries, beside every animation, the idle with those tracks held at rest (0 for a translate, 1 for a scale, at each track's first and last key time — the bone as it stands without them, the idle still keyed to its end), so the two idles share a grid; per pixel, the largest \|(with_t − with_0) − (without_t − without_0)\| over the frames and channels, meaned over their box (`torso_heat_mean`). Motion in both renders — a keyed cloth swing, physics answering the world — cancels; physics the breath sets moving counts. Until #411 the figure was the whole idle's heat over the box, which a keyed swing passed for a torso that did not breathe; a refusal still prints that whole-idle figure beside the breath's. An idle with no breath track reads 0 and fails, naming why — a torso that does not breathe is what the bar finds, so it is not a SKIP. The feet: `footwear` parts alone, heat max over theirs | torso mean ≥ 3.809; feet max ≤ 0 | 15.251; 0 | 7.617; 0 | no `topwear` and no `footwear` part. One of the two absent (issue #323): the other half is measured and decides the line, which then carries `halves_measured` `"1 of 2"` first, then each half's own status — `torso_status`, `feet_status` — the absent half's `SKIP` with its `torso_reason` or `feet_reason`; a run that measured both halves writes the keys it always wrote |
 | <a id="BLINK_NO_HOLE"></a>`BLINK_NO_HOLE` | the setup pose with every `scaley` track on the eyewhite slots' bones held at its closed value, against the setup pose, at full size: pixels in the eyewhite box that show the page where the open eye had art | 0 px | 0 | 0 | no `eyewhite` part, or no `scaley` track on its bones goes below its first key |
 | ″ (reported) | the same box: each closed-eye pixel's max-channel distance to the nearest colour the open eye's box holds — max, and pixels over 40 | none | 15; 0 | 11; 0 | as above |
 | <a id="CHAIN_LAG"></a>`CHAIN_LAG` | `motion.json`'s rotate tracks read as sines (DFT of the keys: period, amplitude, phase) and arranged by the bone tree — a keyed bone's parent is its nearest keyed ancestor | every lag ≥ 0.001 cycle; amplitude non-decreasing down each unbranched chain — non-increasing down a chain that carries a part declared `rests` (issue #245) | lags 0.040 (neck to head) to 0.120; 12 chains | lags 0.040 to 0.100; 9 chains | no rotate track under another of the same period |

package/docs/STABILITY.md

@@ -147,7 +147,7 @@ part name, `[i]` an entry of a list):
 - **meshes.<part>.auto.regions[i]** — required: `name`, `shape`, `maxEdgeLength`, `transition`, `grade`, `minArtSamples`, and `cx`, `cy`, `r` for a circle or `points` for a polygon; optional: `bone`, `band` (both or neither; with neither the region is density only)
 - **meshes.<part>.auto.boundaryRuns** — required: `maxVertices`
 - **meshes.<part>.auto.stimulus**, or each entry of it when a list — required: `chain`, `degrees`
-- **cloth.<tag>**, the tag bottomwear, back hair or front hair (issue #364; read by propose --cloth only) — required: `chains`, `links`, `wind`, `gravity`; optional: `split`, `length_ratio`, `strength`, `damping`, `alternate_damping`, `translate`, `swing` (on bottomwear only)
+- **cloth.<tag>**, the tag bottomwear, back hair or front hair (issue #364; read by propose --cloth only) — required: `chains`, `links`, `wind`, `gravity`; optional: `split`, `length_ratio`, `strength`, `damping`, `alternate_damping`, `translate`, `swing` (on bottomwear only), `part` (on bottomwear only)
 - **cloth.<tag>.split** — required: `at`, `into`
 - **cloth.<tag>.strength** — required: `trunk`, `branch`, `edge`
 - **cloth.<tag>.swing** — required: `scales`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.22.0",
+  "version": "1.24.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/src/build.ts

@@ -357,13 +357,13 @@ function gateRun(label: string, rigc: RigcRunner, args: string[]): GateRun {
 
 /**
  * The motion gate's reference build (issue #135): rigc's `build` under the
- * spine-html profile and nothing else — the same gate over the compile that
- * the candidate's build runs, without `--pack`. Its model document is all the
- * comparison reads, and it differs from a packed build's only in where the
- * atlas puts each region (its `pages`), which rig-c's comparison
- * allowlists as atlas layout; the pages a reference would pack are never
- * written anywhere, so packing them was work nobody read. No render is asked
- * of rigc by either build.
+ * `rig-play` profile (named `spine-html` before rig-c 2.50.0) and nothing
+ * else — the same gate over the compile that the candidate's build runs,
+ * without `--pack`. Its model document is all the comparison reads, and it
+ * differs from a packed build's only in where the atlas puts each region (its
+ * `pages`), which rig-c's comparison allowlists as atlas layout; the pages a
+ * reference would pack are never written anywhere, so packing them was work
+ * nobody read. No render is asked of rigc by either build.
  */
 export const REFERENCE_BUILD_ARGS: readonly string[] = ['--profile', GATE_PROFILE];
 
@@ -372,9 +372,9 @@ export const REFERENCE_BUILD_LABEL = `build ${REFERENCE_BUILD_ARGS.join(' ')}`;
 
 /**
  * rig-c's gate over the rig in a scratch directory: `build` under the
- * spine-html profile with `--pack --page-edges <edges> --pack-shape <shape>`, which runs the gate
+ * rig-play profile with `--pack --page-edges <edges> --pack-shape <shape>`, which runs the gate
  * once over the compile and once over the packed pages on disk. There is no
- * second `validate --profile spine` run: spine-html holds every rule spine
+ * second `validate --profile spine` run: rig-play holds every rule spine
  * measures (selftest `CH09`). The files are staged exactly as `--out` will
  * receive them, so what passed is what is written. The scratch directory is
  * the caller's, and is emptied here before and after. `images` are the PNG
@@ -506,7 +506,7 @@ function modelAt(buildDir: string): string | null {
  * The motion gate of every automatic part (issue #126, item 3): for each, the
  * reference rig — `rig` with that part's attachment swapped for its unreduced
  * source and nothing else — through rigc's gate ({@link REFERENCE_BUILD_ARGS}:
- * the stage's `build` under spine-html, without packing, issue #135), then
+ * the stage's `build` under rig-play, without packing, issue #135), then
  * rig-c's comparison of its `skeleton.model.json` with the candidate's
  * (`candidateModel`, the stage's own gate build). A part refused before
  * compiling (no `motion`, no stimulus) costs no build.
@@ -1170,7 +1170,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   log(`  ${rigcIdentity(bin, v)}${entryLine === undefined ? '' : `; ${entryLine}`}`);
   const mode: PackMode = { pageEdges: input.pageEdges ?? DEFAULT_PAGE_EDGES, packShape: input.packShape ?? DEFAULT_PACK_SHAPE };
   const r = runCheck(input.rig, input.out, rigc, input.parts, mode, input.source, input.requirements, input.seamPairs === true, input.keepStills === true);
-  log(`  gate spine-html (rigc ${packedBuildLabel(mode)}), verbatim:`);
+  log(`  gate rig-play (rigc ${packedBuildLabel(mode)}), verbatim:`);
   for (const l of r.gateHtml) log(l);
   for (const l of packLines(r)) log(`  ${l}`);
   const fig = r.figures;
@@ -1206,7 +1206,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
     for (const [name, line] of Object.entries(r.requirements.lines)) log(`  ${requirementText(name, line)}`);
     log(`  ${summaryText(r.requirements.summary)}`);
   }
-  log(`  gate: spine-html ${fig.gate_spine_html_green ? 'green' : 'RED'} (${fig.rigc_entry.entry}${fig.rigc_entry.spine_core === null ? ', rigc\'s own validator' : `, the spine-core ${fig.rigc_entry.spine_core} round trip`})`);
+  log(`  gate: rig-play ${fig.gate_spine_html_green ? 'green' : 'RED'} (${fig.rigc_entry.entry}${fig.rigc_entry.spine_core === null ? ', rigc\'s own validator' : `, the spine-core ${fig.rigc_entry.spine_core} round trip`})`);
   log(`  wrote ${r.written.map((w) => join(input.out, w)).join(', ')}, ${join(input.out, 'build')}/${r.idle === null ? '' : `, ${join(input.out, 'idle_frames')}/`}${r.requirements === null ? '' : `, ${join(input.out, REQUIREMENTS_DIR)}/`}${fig.seam_pairs === undefined ? '' : `, ${join(input.out, SEAM_DIR)}/`}${existsSync(join(input.out, STILL_DIR)) ? `, ${join(input.out, STILL_DIR)}/` : ''}`);
   for (const p of r.problems) log(failLine(p));
   const reqNotPass = r.requirements === null ? 0 : r.requirements.summary.declared - r.requirements.summary.pass;

package/src/check.ts

@@ -31,7 +31,7 @@
  * | output | what |
  * | --- | --- |
  * | `build/` | `rigc build --profile rig-play --pack --page-edges free --pack-shape polygon` (or `pot`, `rect`, when the caller names them; {@link PAGE_EDGES}, {@link PACK_SHAPES}) — the packed atlas is the final artifact |
- * | `gate_spine-html.txt` | that build's gate lines, verbatim — the one gate: rigc's `build` runs it once over the compile and once over the packed pages on disk, and `spine-html` holds every rule `spine` measures (selftest `CH09`) |
+ * | `gate_spine-html.txt` | that build's gate lines, verbatim — the one gate: rigc's `build` runs it once over the compile and once over the packed pages on disk, and `rig-play` holds every rule `spine` measures (selftest `CH09`) |
  * | `idle_frames/` | `rigc render --animation idle --fps 12 --max 640 --geometry`: `frames.json` + `idle/f*.png` + `idle/geometry.json` (each mesh's skinned vertices, which `TEXTURE_STRETCH` reads, every attachment's posed triangles, which `TIP_OVER_ROOT` and both halves of `STILL_REGIONS_DARK` read since issues #118 and #123, and every bone's world transform, which the face half reads its head bone from) |
  * | `contact.png` | rigc's own contact sheet of that render, copied out |
  * | `motion_heat.png` | frame 0 in grey with each pixel's largest change across the idle in red |
@@ -101,6 +101,7 @@ import {
   FACE_FEATURE_TAGS,
   FACE_TAGS,
   FEET_TAGS,
+  breathHeat,
   frameBox,
   heatField,
   partsTagged,
@@ -3133,13 +3134,40 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     if (r.status !== 0) refuseIfAny(rigcFailed(`render --animation idle --slot ${ps.map((p) => p.name).join(',')}`, r, r.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
     return readFrameSet(dir);
   };
+  // Issue #411: the breath alone — a throwaway copy of the build carrying, beside every animation, the idle with its
+  // breath tracks held at rest; the torso rendered alone in both idles, from that one build, so the two share a grid.
+  const breathPair = (ps: readonly PartRecord[]): BreathPair | null => {
+    const tracks = breathTracks(inp.motion);
+    if (tracks.length === 0) return null;
+    const dir = join(isoDir, BREATH_SCRATCH);
+    const anims = isRecord(inp.motion.animations) ? inp.motion.animations : {};
+    const idleAnim = isRecord(anims.idle) ? anims.idle : {};
+    let name = BREATH_ANIMATION;
+    while (name in anims) name = `${name}_`;
+    // Each breath track held at rest over its own span: the idle without the breath, still keyed to its end, which rigc
+    // requires of an animation's last key.
+    const kept = (Array.isArray(idleAnim.tracks) ? idleAnim.tracks : []).map((t) => (isRecord(t) && isBreathTrack(t, tracks) ? heldTrack(t) : t));
+    mkdirSync(dir, { recursive: true });
+    const images = typeof inp.rig.images === 'string' ? resolve(inp.rigDir, inp.rig.images) : inp.rig.images;
+    writeFileSync(join(dir, 'rig.json'), JSON.stringify({ ...inp.rig, images }));
+    writeFileSync(join(dir, 'motion.json'), JSON.stringify({ ...inp.motion, animations: { ...anims, [name]: { ...idleAnim, tracks: kept } } }));
+    const b = rigc(['build', '--rig', join(dir, 'rig.json'), '--motion', join(dir, 'motion.json'), '--out', join(dir, 'build'), ...packedBuildArgs(mode)]);
+    if (b.status !== 0) refuseIfAny(rigcFailed(`${packedBuildLabel(mode)} (BREATH_VISIBLE's copy, the idle beside it with its breath tracks held at rest)`, b, buildGateLines(b.out)));
+    const slots = ps.map((p) => p.name).join(',');
+    const render = (animation: string, label: string): FrameSet => {
+      const r = rigc(['render', '--candidate', join(dir, 'build'), '--animation', animation, '--fps', String(IDLE_FPS), '--max', String(IDLE_MAX_PX), '--slot', slots, '--out', join(dir, label)]);
+      if (r.status !== 0) refuseIfAny(rigcFailed(`render --animation ${animation} --slot ${slots} (BREATH_VISIBLE's copy)`, r, r.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
+      return readFrameSet(join(dir, label));
+    };
+    return { with: render('idle', 'with'), without: render(name, 'without'), tracks: tracks.map((t) => `${t.bone} ${t.property}`) };
+  };
   // Issue #231: the footwear parts the scene file declares not planted; none without --requirements or the field.
   const notPlanted = reqFile === null ? [] : reqFile.not_planted;
   let breath: JudgementLine = skip(lacking);
   let tip: JudgementLine = skip(lacking);
   if (full !== null) {
     try {
-      breath = breathLine(full, isolated, problems, notPlanted);
+      breath = breathLine(full, isolated, breathPair, problems, notPlanted);
       if (idle !== null) tip = tipLine(full, join(idle.dir, GEOMETRY_FILE), idle.written, problems, reqFile === null ? NO_TIP_EXCEPTIONS : { path: reqFile.path, not_swinging: reqFile.not_swinging, rises: reqFile.rises, rests: reqFile.rests });
     } finally {
       rmSync(isoDir, { recursive: true, force: true });
@@ -3701,33 +3729,32 @@ function noneHeldText(declared: readonly string[]): string {
  * `SKIP` with its reason — so a half nobody read never passes by being silent.
  * With neither, the line is the SKIP it was. A run that measured both halves
  * writes the keys it always wrote.
+ *
+ * Issue #411: the torso half reads the breath alone ({@link torsoBreath}):
+ * `torso_heat_mean` is the heat the breath makes, the idle rendered with and
+ * without its breath tracks, on the same box and against the same floor.
+ * Until #411 it was the whole idle's heat over the box, so a keyed cloth swing
+ * or a physics response to the world inside the torso's box passed the bar
+ * for a torso that did not breathe.
  */
-function breathLine(inp: FullInputs, isolated: Isolate, problems: Problem[], notPlanted: readonly string[] = []): JudgementLine {
+function breathLine(inp: FullInputs, isolated: Isolate, pair: BreathPairRender, problems: Problem[], notPlanted: readonly string[] = []): JudgementLine {
   const torso = partsTagged(inp.parts, TORSO_TAGS);
   const { all: allFeet, held: feet, declared } = plantedFeet(inp.parts, notPlanted);
   const noTorso = `no part comes from a See-through ${tagWords(TORSO_TAGS)} layer, so there is no torso to see breathe`;
   const noFeet = `no part comes from a See-through ${tagWords(FEET_TAGS)} layer, so there are no feet to hold still`;
   // Issue #323: a figure without one of the two halves still has the other read; with neither, the SKIP it always was.
   if (torso.length === 0 && feet.length === 0) return skip(`${noTorso}${declared.length === 0 ? '' : `; ${declared.map((n) => `"${n}"`).join(', ')} declared not planted`}`);
-  if (torso.length === 0) return oneHalf(inp, isolated, problems, 'feet', feet, noTorso, declared);
-  if (allFeet.length === 0) return oneHalf(inp, isolated, problems, 'torso', torso, noFeet, []);
+  if (torso.length === 0) return oneHalf(inp, isolated, pair, problems, 'feet', feet, noTorso, declared);
+  if (allFeet.length === 0) return oneHalf(inp, isolated, pair, problems, 'torso', torso, noFeet, []);
   const H = inp.parts.rig_size[1];
-  const ts = isolated('torso', torso);
+  const tr = torsoBreath(inp, torso, pair);
   const fs = feet.length === 0 ? null : isolated('feet', feet);
-  const tb = frameBox(torso, H, inp.stage, ts.viewport);
   const fb = fs === null ? null : frameBox(feet, H, inp.stage, fs.viewport);
-  if (tb === null || (fs !== null && fb === null)) return skip(`the ${tb === null ? 'torso' : 'feet'} box falls outside the idle frame`);
-  const th = regionHeat(heatField(ts.frames.map((f) => f.image)), ts.viewport.pixelWidth, tb);
+  if ('skip' in tr || (fs !== null && fb === null)) return skip(`the ${'skip' in tr ? 'torso' : 'feet'} box falls outside the idle frame`);
   const fh = fs === null || fb === null ? null : regionHeat(heatField(fs.frames.map((f) => f.image)), fs.viewport.pixelWidth, fb);
-  const mean = round3(th.mean);
+  const mean = tr.mean;
   const ok = mean >= BREATH_TORSO_MEAN_FLOOR && (fh === null || fh.max <= BREATH_FEET_MAX_CEILING);
-  if (mean < BREATH_TORSO_MEAN_FLOOR) {
-    problems.push({
-      code: 'CHECK_BREATH_VISIBLE',
-      object: `torso ${quoteParts(torso)} rendered alone, frame box ${boxLabel(tb)}`,
-      detail: `heat mean ${mean}/255 over the idle; >= ${BREATH_TORSO_MEAN_FLOOR} is required — the chest's breath track moves too little, or the torso is not weighted to the bone it keys`,
-    });
-  }
+  if (mean < BREATH_TORSO_MEAN_FLOOR) problems.push(torsoProblem(torso, tr, ''));
   if (fh !== null && fb !== null && fh.max > BREATH_FEET_MAX_CEILING) {
     problems.push({
       code: 'CHECK_BREATH_VISIBLE',
@@ -3755,22 +3782,15 @@ function breathLine(inp: FullInputs, isolated: Isolate, problems: Problem[], not
  * `halves_measured`, says `1 of 2` — after `declared_not_planted` when the scene
  * file declares some of the feet read (issue #231), which stays the first.
  */
-function oneHalf(inp: FullInputs, isolated: Isolate, problems: Problem[], half: 'torso' | 'feet', ps: readonly PartRecord[], reason: string, declared: readonly string[]): JudgementLine {
+function oneHalf(inp: FullInputs, isolated: Isolate, pair: BreathPairRender, problems: Problem[], half: 'torso' | 'feet', ps: readonly PartRecord[], reason: string, declared: readonly string[]): JudgementLine {
   const H = inp.parts.rig_size[1];
-  const fs = isolated(half, ps);
-  const box = frameBox(ps, H, inp.stage, fs.viewport);
-  if (box === null) return skip(`the ${half} box falls outside the idle frame, and ${reason}`);
-  const heat = regionHeat(heatField(fs.frames.map((f) => f.image)), fs.viewport.pixelWidth, box);
   if (half === 'torso') {
-    const mean = round3(heat.mean);
+    // Issue #411: the torso half is the breath alone.
+    const tr = torsoBreath(inp, ps, pair);
+    if ('skip' in tr) return skip(`the ${half} box falls outside the idle frame, and ${reason}`);
+    const mean = tr.mean;
     const ok = mean >= BREATH_TORSO_MEAN_FLOOR;
-    if (!ok) {
-      problems.push({
-        code: 'CHECK_BREATH_VISIBLE',
-        object: `torso ${quoteParts(ps)} rendered alone, frame box ${boxLabel(box)}; the feet half not measured: ${reason}`,
-        detail: `heat mean ${mean}/255 over the idle; >= ${BREATH_TORSO_MEAN_FLOOR} is required — the chest's breath track moves too little, or the torso is not weighted to the bone it keys`,
-      });
-    }
+    if (!ok) problems.push(torsoProblem(ps, tr, `; the feet half not measured: ${reason}`));
     return {
       status: ok ? 'PASS' : 'FAIL',
       halves_measured: '1 of 2',
@@ -3782,6 +3802,10 @@ function oneHalf(inp: FullInputs, isolated: Isolate, problems: Problem[], half:
       feet_reason: reason,
     };
   }
+  const fs = isolated(half, ps);
+  const box = frameBox(ps, H, inp.stage, fs.viewport);
+  if (box === null) return skip(`the ${half} box falls outside the idle frame, and ${reason}`);
+  const heat = regionHeat(heatField(fs.frames.map((f) => f.image)), fs.viewport.pixelWidth, box);
   const ok = heat.max <= BREATH_FEET_MAX_CEILING;
   if (!ok) {
     problems.push({
@@ -3803,6 +3827,130 @@ function oneHalf(inp: FullInputs, isolated: Isolate, problems: Problem[], half:
   };
 }
 
+/** The throwaway animation BREATH_VISIBLE adds beside the idle (issue #411): the idle with its breath tracks held at rest; a trailing `_` is added while the rig already has an animation of the name. */
+export const BREATH_ANIMATION = 'idle_without_breath';
+/** Where BREATH_VISIBLE's copy is built and rendered, under the stage's scratch; removed before the stage returns. */
+const BREATH_SCRATCH = 'breath';
+
+/** The idle track properties that make up the breath on a breath bone (issue #411): it moves and it swells; the drafted breath is `chest` `translatey` and `scalex` (src/propose.ts). */
+const BREATH_TRACK_PROPS: readonly string[] = ['translate', 'translatex', 'translatey', 'scale', 'scalex', 'scaley'];
+
+/**
+ * The breath's tracks (issue #411), in the idle's order: the breath bones are
+ * every bone an idle track translates ({@link BREATH_PROPS}, issue #262), and
+ * their breath tracks every idle track that translates or scales one of them
+ * ({@link BREATH_TRACK_PROPS}). A track that turns a breath bone, a group's
+ * track and every track on another bone are not the breath. Empty when no
+ * idle track translates a bone.
+ */
+export function breathTracks(motion: Record<string, unknown>): Array<{ bone: string; property: string }> {
+  const anims = isRecord(motion.animations) ? motion.animations : {};
+  const idle = isRecord(anims.idle) ? anims.idle : {};
+  const tracks = (Array.isArray(idle.tracks) ? idle.tracks : []).filter(isRecord).filter((t) => typeof t.bone === 'string' && typeof t.property === 'string');
+  const bones = new Set(tracks.filter((t) => BREATH_PROPS.includes(String(t.property))).map((t) => String(t.bone)));
+  return tracks.filter((t) => bones.has(String(t.bone)) && BREATH_TRACK_PROPS.includes(String(t.property))).map((t) => ({ bone: String(t.bone), property: String(t.property) }));
+}
+
+/**
+ * A breath track held at rest (issue #411): the setup pose's value — 0 for a translate, 1 for a scale, one per axis
+ * the track's first key gives — at its first and last key times, no curve. That is the track removed, as the bone
+ * stands without it, while the idle stays keyed to its end: a dropped track could leave the idle's last key before
+ * its duration, which rigc refuses. (Held at its first key instead, the bone would stand offset from frame 0 on and
+ * the physics under it would answer that start, which is not the idle without its breath.)
+ */
+function heldTrack(t: Record<string, unknown>): Record<string, unknown> {
+  const keys = (Array.isArray(t.keys) ? t.keys : []).filter(isRecord);
+  if (keys.length === 0) return t;
+  const first = keys[0];
+  const last = keys[keys.length - 1];
+  const rest = String(t.property).startsWith('scale') ? 1 : 0;
+  const v = (Array.isArray(first.v) ? first.v : [first.v]).map(() => rest);
+  return { ...t, keys: keys.length === 1 ? [{ t: first.t, v }] : [{ t: first.t, v }, { t: last.t, v }] };
+}
+
+function isBreathTrack(t: Record<string, unknown>, tracks: ReadonlyArray<{ bone: string; property: string }>): boolean {
+  return tracks.some((b) => b.bone === t.bone && b.property === t.property);
+}
+
+/** The torso rendered alone twice from one build (issue #411): the idle (`with`) and the idle less its breath tracks (`without`), and those tracks as `bone property`. */
+export interface BreathPair {
+  with: FrameSet;
+  without: FrameSet;
+  tracks: string[];
+}
+
+/** Renders {@link BreathPair} for the torso parts; null when the idle has no breath track. */
+export type BreathPairRender = (ps: readonly PartRecord[]) => BreathPair | null;
+
+/**
+ * Why the two renders of a {@link BreathPair} cannot be compared pixel for
+ * pixel, or null when they can: one grid (the viewport), one background, the
+ * same number of frames, each of one size. Both come from one build, so a
+ * difference is rigc's, refused by name (`CHECK_BREATH_VISIBLE`) rather than
+ * read.
+ */
+export function breathPairProblem(pair: BreathPair): Problem | null {
+  const a = pair.with;
+  const b = pair.without;
+  const size = (s: FrameSet): string => [...new Set(s.frames.map((f) => `${f.image.width}x${f.image.height}`))].join(',');
+  if (sameViewport(a.viewport, b.viewport) && a.background.join(',') === b.background.join(',') && a.frames.length === b.frames.length && size(a) === size(b) && !size(a).includes(',')) return null;
+  return {
+    code: 'CHECK_BREATH_VISIBLE',
+    object: `the torso's two idle renders (with and without the breath tracks ${pair.tracks.join(', ')})`,
+    detail: `are ${a.frames.length} frame(s) of ${size(a)} on ${JSON.stringify(a.viewport)} over ${JSON.stringify(a.background)} and ${b.frames.length} frame(s) of ${size(b)} on ${JSON.stringify(b.viewport)} over ${JSON.stringify(b.background)}; the breath is read pixel for pixel between them, which needs one grid, one background and one frame count`,
+  };
+}
+
+/** The torso half's reading (issue #411): the breath's heat mean over the box, the whole idle's beside it, and the breath tracks; `none` when the idle has no breath track. */
+type TorsoBreath = { box: PixelBox; mean: number; whole: number; tracks: string[] } | { none: string; mean: number } | { skip: true };
+
+/**
+ * `BREATH_VISIBLE`'s torso half (issue #411): the breath alone. The breath
+ * bones are every bone an idle track translates, and the breath tracks every
+ * idle track that translates or scales one of them ({@link breathTracks}).
+ * The torso is rendered alone, idle at its rate and size, from one throwaway
+ * build carrying every animation of the rig and, beside them, the idle with
+ * its breath tracks held at rest ({@link heldTrack}: the bone as it stands
+ * without them, the idle still keyed to its end) — so both renders share a
+ * grid. Per pixel, the largest
+ * |(with_t - with_0) - (without_t - without_0)| over the frames and the RGB
+ * channels ({@link breathHeat}), meaned over the torso's frame box. Motion that
+ * is not the breath's — a keyed cloth swing, physics answering the world, a
+ * head turn — is in both renders and cancels; physics the breath sets moving
+ * is counted. The whole idle's heat over the same box, the reading until #411,
+ * is carried for the refusal's sentence only.
+ *
+ * With no breath track the figure is 0, by the definition (the idle with and
+ * without its breath is one idle), and the bar fails naming why: a torso with
+ * no breath is what the bar exists to find, so it is not a SKIP; nothing is
+ * rendered.
+ */
+function torsoBreath(inp: FullInputs, ps: readonly PartRecord[], pair: BreathPairRender): TorsoBreath {
+  const got = pair(ps);
+  if (got === null) return { none: 'no idle track translates a bone, so the rig has no breath to read (the breath bones are every bone an idle track translates); whatever else the idle moves is not counted', mean: 0 };
+  const grid = breathPairProblem(got);
+  if (grid !== null) refuseIfAny([grid]);
+  const box = frameBox(ps, inp.parts.rig_size[1], inp.stage, got.with.viewport);
+  if (box === null) return { skip: true };
+  const width = got.with.viewport.pixelWidth;
+  const withFrames = got.with.frames.map((f) => f.image);
+  const mean = round3(regionHeat(breathHeat(withFrames, got.without.frames.map((f) => f.image)), width, box).mean);
+  const whole = round3(regionHeat(heatField(withFrames), width, box).mean);
+  return { box, mean, whole, tracks: got.tracks };
+}
+
+/** The torso half's refusal (issue #411): the breath's figure, the tracks it was read from, and the whole idle's beside it. */
+function torsoProblem(ps: readonly PartRecord[], tr: Exclude<TorsoBreath, { skip: true }>, tail: string): Problem {
+  if ('none' in tr) {
+    return { code: 'CHECK_BREATH_VISIBLE', object: `torso ${quoteParts(ps)}${tail}`, detail: `breath heat mean 0/255: ${tr.none}; >= ${BREATH_TORSO_MEAN_FLOOR} is required — key the chest's breath (a translate track on the bone the torso is weighted to)` };
+  }
+  return {
+    code: 'CHECK_BREATH_VISIBLE',
+    object: `torso ${quoteParts(ps)} rendered alone, frame box ${boxLabel(tr.box)}${tail}`,
+    detail: `breath heat mean ${tr.mean}/255 over the idle — the idle with and without its breath tracks (${tr.tracks.join(', ')}), on one grid; the whole idle reads ${tr.whole} over the box, and what is not the breath's is not counted; >= ${BREATH_TORSO_MEAN_FLOOR} is required — the chest's breath track moves too little, or the torso is not weighted to the bone it keys`,
+  };
+}
+
 /** The scene file's exceptions to `TIP_OVER_ROOT` (issues #231, #245), and the file they were read from, which a refusal names. */
 export interface TipExceptions {
   path: string;

package/src/cloth.ts

@@ -42,6 +42,12 @@
  * - **Translate.** `translate`, when declared, is the `x` and `y` mix of a
  *   second physics constraint on the last link of every path, beside its
  *   rotation, with no wind or gravity response ({@link physics} says why).
+ * - **Part** (`bottomwear` only, issue #402). `part` names a `topwear` part
+ *   that takes the skirt's recipe as well: a skirt See-through returned inside
+ *   `topwear` (a dress). Its trees hang from the hip over its art below the
+ *   hip, by the skirt's own rule, in place of the robe chains the topwear rule
+ *   drafts; its art above the hip stays on the chest. The proposer never picks
+ *   such a part by itself: it names a candidate, and the author declares it.
  * - **Swing** (`bottomwear` only). `swing.scales` declares one shared pendulum:
  *   a bone `<prefix>swing` under the attachment at the centre of the root row,
  *   one link long, with physics; each tree's first link takes the swing's
@@ -56,7 +62,9 @@
  * Pure: no clock, no randomness; every value is a function of its inputs.
  */
 import type { ConfigConstraint, Point } from './config.ts';
+import type { Mask } from './raster/types.ts';
 import { pyRound } from './round.ts';
+import { segmentDistance } from './weights.ts';
 
 /** The tags a `cloth` recipe may name: the parts the proposer drafts chains on that hang. */
 export const CLOTH_TARGETS = ['bottomwear', 'back hair', 'front hair'] as const;
@@ -84,6 +92,8 @@ export interface ClothRecipe {
   gravity: [number, number];
   translate?: number;
   swing?: { scales: number[] };
+  /** `bottomwear` only (issue #402): a `topwear` part the skirt's trees are drafted on as well — a dress. */
+  part?: string;
 }
 
 export type ClothRecipes = Partial<Record<ClothTarget, ClothRecipe>>;
@@ -364,15 +374,83 @@ export function chainConstraints(chain: string, links: number, tree: number, edg
   return out;
 }
 
-/** The one note a piece drafted by the recipe gets. */
-export function clothNote(part: string, tag: ClothTarget, trees: readonly TreeChain[], r: ClothRecipe, constraints: number, extra: string): string {
+/**
+ * The one note a piece drafted by the recipe gets. `via` is the part's own
+ * `from` when the recipe reached it by `part` rather than by its tag
+ * (issue #402); absent, the note is the one written before the field existed.
+ */
+export function clothNote(part: string, tag: ClothTarget, trees: readonly TreeChain[], r: ClothRecipe, constraints: number, extra: string, via?: string): string {
   const defaults: string[] = [];
   if (r.length_ratio === undefined) defaults.push(`length_ratio ${RECIPE_LENGTH_RATIO}`);
   if (r.strength === undefined) defaults.push(`strength ${RECIPE_STRENGTH.trunk}/${RECIPE_STRENGTH.branch}/${RECIPE_STRENGTH.edge}`);
   const shape = r.split === undefined ? `${r.links} link(s) each` : `a ${r.split.at}-link trunk forking into ${r.split.into} branches, ${r.links} links root to tip`;
   return (
-    `${part} (${tag}): config.cloth."${tag}" -> ${r.chains} tree(s)${extra}, ${shape} (${trees.map((t) => t.chain).join(', ')}); ` +
+    `${part} (${via === undefined ? tag : `${via}, which config.cloth."${tag}".part names`}): config.cloth."${tag}" -> ${r.chains} tree(s)${extra}, ${shape} (${trees.map((t) => t.chain).join(', ')}); ` +
     `${constraints} constraint(s), physics on every link, wind ${r.wind[0]} -> ${r.wind[1]} and gravity ${r.gravity[0]} -> ${r.gravity[1]} root to tip (multipliers of the consumer's environment; no direction is drafted), no idle key` +
     (defaults.length === 0 ? '' : `; the recipe's own defaults, measured on its synthetic fixture (AUTHORING §3): ${defaults.join(', ')}`)
   );
 }
+
+/**
+ * Issue #391: a part wrapped round a tail the recipe drafted rides that tail's links. One span of the tail: a segment
+ * of the back hair's mesh as the recipe drafts it — the head's fixed segment, or one tree link from its origin to the
+ * next link (the last to the chain's tip), named by the link's bone.
+ */
+export interface TailSpan {
+  bone: string;
+  a: Point;
+  b: Point;
+  /** Whether the span is a tree link (false: the head's fixed segment). */
+  link: boolean;
+}
+
+/** A tail the recipe drafted: the back hair part, its opaque mask on the rig canvas, and its mesh's spans in segment order. */
+export interface Tail {
+  part: string;
+  mask: Mask;
+  spans: TailSpan[];
+}
+
+/** Where a part's opaque pixels lie against a drafted tail. */
+export interface TailOverlap {
+  /** Per span, in the tail's order: the part's pixels over the tail's art whose nearest span it is. */
+  counts: number[];
+  /** The part's pixels over the tail's art (the sum of `counts`). */
+  over: number;
+  /** The part's opaque pixels in all. */
+  total: number;
+}
+
+/**
+ * Which span of the tail each of the part's pixels over the tail's art belongs to: every pixel where both masks are
+ * set is given to the span nearest it — the distance the weights read (`segmentDistance`, `src/weights.ts`), so a
+ * span here is the art the tail's own weights give mostly to that bone — the first in the tail's order on a tie. No
+ * threshold: a span the part touches by one pixel is one the part overlaps, and the counts are said in the note.
+ * Pure; the part's mask and the tail's are on the same canvas.
+ */
+export function tailOverlap(tail: Tail, part: Mask, box: { x: number; y: number; w: number; h: number }): TailOverlap {
+  const counts = tail.spans.map(() => 0);
+  let over = 0;
+  let total = 0;
+  const W = part.width;
+  for (let y = box.y; y < box.y + box.h; y++) {
+    for (let x = box.x; x < box.x + box.w; x++) {
+      const i = y * W + x;
+      if (part.data[i] === 0) continue;
+      total++;
+      if (tail.mask.data[i] === 0) continue;
+      over++;
+      let best = 0;
+      let bd = Infinity;
+      tail.spans.forEach((s, k) => {
+        const d = segmentDistance([x, y], s.a, s.b);
+        if (d < bd) {
+          bd = d;
+          best = k;
+        }
+      });
+      counts[best]++;
+    }
+  }
+  return { counts, over, total };
+}

package/src/config.ts

@@ -2663,6 +2663,11 @@ function attachedParts(meshes: Json, regions: Json): Set<string> {
  *   not a declaration (`CONFIG_CLOTH_ALTERNATE_DIFFERS`);
  * - `swing` on a tag other than `bottomwear`, or `swing.scales` not one per
  *   tree (`CONFIG_CLOTH_SWING_SCALE_PER_TREE`);
+ * - `part` on a tag other than `bottomwear` (`CONFIG_CLOTH_PART_ON_BOTTOMWEAR`):
+ *   the field hands the skirt's recipe to a part of another tag (issue #402),
+ *   and only the skirt has a recipe that part can take; whether the part
+ *   exists, and is a `topwear` that hangs below the hip, is read off the parts
+ *   by `propose` (`PROPOSE_CLOTH_PART`);
  * - a strength, declared or the recipe's default, whose spring is unstable at
  *   a damping the recipe runs at — k = strength·massInverse·step² at or past
  *   2(1 + damping^(60·step)), rig-c's default fps 60 and mass 1, the damping
@@ -2690,7 +2695,7 @@ function checkCloth(c: Check, v: Json): void {
   for (const tag of CLOTH_TARGETS) {
     if (!(tag in v)) continue;
     const path = `${at}.${JSON.stringify(tag)}`;
-    const r = c.object(path, v[tag], ['chains', 'links', 'wind', 'gravity'], ['split', 'length_ratio', 'strength', 'damping', 'alternate_damping', 'translate', 'swing']);
+    const r = c.object(path, v[tag], ['chains', 'links', 'wind', 'gravity'], ['split', 'length_ratio', 'strength', 'damping', 'alternate_damping', 'translate', 'swing', 'part']);
     if (r === null) continue;
     const chains = 'chains' in r && c.int(`${path}.chains`, r.chains, 1) ? (r.chains as number) : null;
     const links = 'links' in r && c.int(`${path}.links`, r.links, 1) ? (r.links as number) : null;
@@ -2743,6 +2748,11 @@ function checkCloth(c: Check, v: Json): void {
     if ('translate' in r && c.number(`${path}.translate`, r.translate, 'unit') && r.translate === 0) {
       c.fail('CONFIG_FIELD_TYPE', `${path}.translate`, 'is 0; a mix above 0 and at most 1 is required (leave translate out for none)');
     }
+    if ('part' in r) {
+      if (tag !== 'bottomwear') {
+        c.fail('CONFIG_CLOTH_PART_ON_BOTTOMWEAR', `${path}.part`, `is declared on "${tag}"; part hands the skirt's recipe (bottomwear) to a topwear part that holds a skirt (a dress) — leave it out here`);
+      } else c.string(`${path}.part`, r.part);
+    }
     if ('swing' in r) {
       if (tag !== 'bottomwear') {
         c.fail('CONFIG_CLOTH_SWING_SCALE_PER_TREE', `${path}.swing`, `is declared on "${tag}"; the shared swing is the skirt's (bottomwear) — leave it out here`);

package/src/instruments.ts

@@ -137,6 +137,38 @@ export function heatField(frames: readonly Raster[]): Uint8Array {
   return d;
 }
 
+/**
+ * The breath alone (issue #411): each pixel's largest per-channel RGB change
+ * that the breath makes, read off the idle rendered twice on one grid — with
+ * its breath tracks (`withBreath`) and without them (`withoutBreath`). At
+ * frame t the breath's own change at a pixel is (with_t - with_0) -
+ * (without_t - without_0): motion that is the same in both renders (a keyed
+ * cloth swing, a physics response to the world, a head turn) cancels, and so
+ * does a constant offset the breath holds from frame 0 on, while physics that
+ * the breath sets moving stays. The field is that change's largest magnitude
+ * over the frames and the three channels, capped at 255 — {@link heatField}'s
+ * reading when the render without the breath does not move. Both lists hold
+ * the same number of frames of one size; the caller holds the grid.
+ */
+export function breathHeat(withBreath: readonly Raster[], withoutBreath: readonly Raster[]): Uint8Array {
+  const w0 = withBreath[0].data;
+  const o0 = withoutBreath[0].data;
+  const n = withBreath[0].width * withBreath[0].height;
+  const d = new Uint8Array(n);
+  withBreath.forEach((f, i) => {
+    const w = f.data;
+    const o = withoutBreath[i].data;
+    for (let p = 0; p < n; p++) {
+      for (let c = 0; c < 3; c++) {
+        const k = p * 4 + c;
+        const v = Math.min(255, Math.abs(w[k] - w0[k] - (o[k] - o0[k])));
+        if (v > d[p]) d[p] = v;
+      }
+    }
+  });
+  return d;
+}
+
 export interface RegionHeat {
   /** Pixels measured. */
   px: number;

package/src/motion.ts

@@ -53,14 +53,15 @@
  *
  * ## Control bones — `A15_IDLE_NO_MESH_BONE_KEYS`
  *
- * rig-c's `spine-html` profile refuses an `idle` that keys a bone a mesh
- * is weighted to (the player skips idle work on meshes). The reference's
- * answer, ported as is and still the default (`rig --idle-keys ctl`): for
- * every keyed bone that some mesh names among its candidates, add a parent
- * `<bone>_ctl` at the SAME origin, re-parent the bone under it, and move the
- * keys to the control. The pose is the same up to float rounding: the
- * extra bone in each chain moves the rendered idle frames by at most one
- * level in a channel (measured on both public examples, rig-parts #13).
+ * rig-c's `rig-play` profile (named `spine-html` before rig-c 2.50.0)
+ * refuses an `idle` that keys a bone a mesh is weighted to (the player skips
+ * idle work on meshes). The reference's answer, ported as is and still the
+ * default (`rig --idle-keys ctl`): for every keyed bone that some mesh names
+ * among its candidates, add a parent `<bone>_ctl` at the SAME origin,
+ * re-parent the bone under it, and move the keys to the control. The pose is
+ * the same up to float rounding: the extra bone in each chain moves the
+ * rendered idle frames by at most one level in a channel (measured on both
+ * public examples, rig-parts #13).
  *
  * ⚠️ **This satisfies the rule's wording only.** The meshes are still
  * deformed every frame — by the control's motion, through the bone they are

package/src/propose.ts

@@ -43,7 +43,12 @@
  *   layer with hanging strands ({@link Strand}) gets one pendulum chain per
  *   strand instead of the single pendant chain, and one note naming every
  *   strand and what became of it — a strand left without a chain is never
- *   silent (issue #24).
+ *   silent (issue #24). Under the `back hair` cloth recipe (issue #391) a
+ *   layer of either tag lying on a drafted tail rides the links it overlaps
+ *   instead: its pixels over the tail's art are each given to the nearest span
+ *   of the back hair's mesh (`tailOverlap`, `src/cloth.ts`), and when one is a
+ *   link the part's mesh takes those spans as its segments and no rule above
+ *   runs for it; a note names each span with its pixel count.
  * - anything no rule claims rides its nearest trunk bone as a region —
  *   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
@@ -139,7 +144,7 @@ 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 { RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, swingName, treeConstraints, type TreeChain, type TreeInput } from './cloth.ts';
+import { RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, swingName, type Tail, tailOverlap, type TailSpan, treeConstraints, type TreeChain, type TreeInput } from './cloth.ts';
 import { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
@@ -820,6 +825,42 @@ export const HIP_MIN_FRACTION = 0.25;
 /** A row is a waist when the torso there is at most this fraction of the shoulders' width (the examples' torsos narrow to 0.648 of their shoulders in `demo` and 0.710 in `sample`). */
 export const WAIST_MAX_OF_SHOULDERS = 0.8;
 
+/**
+ * A `topwear` part hangs below the hip when its box reaches this many face
+ * heights below the hip's y: above it, the topwear rule reads a bodice that
+ * stops at the waist and drafts no robe chains (the reference's line). Issue
+ * #402 reads the same line for a skirt held inside `topwear` (a dress), so
+ * the two rules cannot disagree about which topwear hangs.
+ */
+export const TOPWEAR_HANGS_FACE_HEIGHTS = 0.25;
+
+/**
+ * Issue #402: the note naming a `topwear` part shaped like a skirt — its box
+ * hanging {@link TOPWEAR_HANGS_FACE_HEIGHTS} face heights past the hip, and
+ * its art wider across its last 24 rows than in the 24-row band at the hip
+ * (the band the robe rule reads) — or null when it is not. The cloth recipe
+ * finds a skirt by the `bottomwear` tag alone, and the shape cannot tell a
+ * dress from an outer robe over a skirt, so the proposer drafts nothing on
+ * the strength of it: the note names the part, its art's rows below the hip
+ * and the field, `cloth.bottomwear.part`, by which the author declares it.
+ */
+function skirtInsideNote(p: PartRecord, mask: Mask, hipY: number, fh: number): string | null {
+  const bot = p.y + p.h;
+  const line = hipY + TOPWEAR_HANGS_FACE_HEIGHTS * fh;
+  if (bot < line) return null;
+  const span = (xs: number[]): number => (xs.length === 0 ? 0 : xs[xs.length - 1] - xs[0] + 1);
+  const atHip = span(colsAny(mask, pyInt(hipY) - 12, pyInt(hipY) + 12));
+  const atBottom = span(colsAny(mask, bot - 24, bot));
+  if (!(atBottom > atHip)) return null;
+  const hipRow = pyRound(hipY);
+  let last = bot - 1;
+  while (last > p.y && colsAny(mask, last, last + 1).length === 0) last--;
+  return (
+    `${p.name} (${p.from}): shaped like a skirt — its art's rows ${hipRow + 1} to ${last} lie below hip (y ${hipRow}), past hip + ${TOPWEAR_HANGS_FACE_HEIGHTS} face heights (y ${pyFixed(line, 1)}), and it is wider across its last 24 rows (${atBottom} px) than in the 24-row band at the hip (${atHip} px); ` +
+    `the cloth recipe finds a skirt by the bottomwear tag alone, so it drafted no skirt trees on ${p.name}, and the topwear rule drafts it instead. If See-through returned the skirt inside it (a dress), declare config.cloth.bottomwear.part: "${p.name}", and the bottomwear recipe's trees hang from hip over its art below the hip`
+  );
+}
+
 /**
  * One handwear blob is clasped hands, not two sleeves, when it is at most this
  * fraction of the shoulders' width: two sleeves that hang from the shoulders
@@ -1328,6 +1369,8 @@ export function proposeWithBasis(
   const clothConstraints: ConfigConstraint[] = [];
   const clothUsed = new Set<ClothTarget>();
   const recipeOf = (tag: ClothTarget): ClothRecipe | null => cloth?.[tag] ?? null;
+  // Issue #391: the tails the back hair recipe drafts, each with its mesh's spans, which an accessory wrapped round one rides.
+  const tails: Tail[] = [];
   const T = (p: PartRecord, tag: ClothTarget, r: ClothRecipe, input: TreeInput): TreeChain[] => {
     const trees = draftTrees(input, r);
     const constants = [konst('cloth_chains', r.chains), konst('cloth_links', r.links), konst('length_ratio', roundTo(r.length_ratio ?? RECIPE_LENGTH_RATIO, 6))];
@@ -1512,6 +1555,13 @@ export function proposeWithBasis(
       }
       notes.push(clothNote(p.name, 'back hair', all, rcp, n, ' per side of the eye axis, from head, rooted on the eye line and tipped 4 px above its bottom'));
       meshes[p.name] = { grid: g, r, segments: segs };
+      // Issue #391: the spans are this mesh's segments, the head's fixed one and every tree link, in segment order.
+      const spans: TailSpan[] = [{ bone: 'head', a: rnd(head), b: rnd([axis, top + 13]), link: false }];
+      for (const t of all) {
+        const line = [...t.points, t.tip];
+        t.points.forEach((q, i) => spans.push({ bone: `${t.chain}${i}`, a: q, b: line[i + 1], link: true }));
+      }
+      tails.push({ part: p.name, mask, spans });
     } else {
       const mask = P.alpha(p);
       const segs: Segment[] = [['head', rnd(head), rnd([axis, top + 13])]];
@@ -1690,7 +1740,39 @@ export function proposeWithBasis(
     // gets the bone and chain, the rest ride the head rigidly. A stable sort,
     // as Python's `sorted` is.
     const cands = [...P.byTag(tag)].sort((a, b) => b.opaque_px - a.opaque_px);
+    // Issue #391: a layer of the tag lying on a tail the back hair recipe drafted rides the links it overlaps — the
+    // spans of the tail its pixels over the tail's art fall nearest — and not head: its mesh names those bones and no
+    // others, so every vertex weights by the rule the tail's own art does. The links are read off the overlap, never
+    // off the part's name. A layer over no link keeps its rule below. Only with the recipe: without it no tail moves
+    // by the world, and nothing here runs.
+    const rides = (q: PartRecord): boolean => {
+      const segments: Segment[] = [];
+      const links: string[] = [];
+      const said: string[] = [];
+      for (const tail of tails) {
+        const o = tailOverlap(tail, P.alpha(q), q);
+        if (!tail.spans.some((sp, k) => sp.link && o.counts[k] > 0)) continue;
+        const on: string[] = [];
+        tail.spans.forEach((sp, k) => {
+          if (o.counts[k] === 0) return;
+          on.push(`${sp.link ? sp.bone : `${sp.bone}'s fixed segment`} ${o.counts[k]}`);
+          // A link is named, so its segment is the link as the bones declare it; the head's span is written out, as the tail's mesh writes it.
+          segments.push(sp.link ? sp.bone : [sp.bone, sp.a, sp.b]);
+          if (sp.link) links.push(sp.bone);
+        });
+        said.push(`${o.over} of its ${o.total} px lie over ${tail.part}'s art, nearest ${tail.part}'s spans ${on.join(', ')} px`);
+      }
+      if (links.length === 0) return false;
+      const [g, r] = gridR(q);
+      delete regions[q.name];
+      meshes[q.name] = { grid: g, r, segments };
+      notes.push(
+        `${q.name} (${q.from}): wraps a tail config.cloth."back hair" drafts — ${said.join('; ')} — so its mesh's segments are those spans and it rides the links ${links.join(', ')} with the tail, not head; no ${tag} bone, pendant or strand chain is drafted for it (issue #391)`,
+      );
+      return true;
+    };
     for (const q of cands.slice(1)) {
+      if (rides(q)) continue;
       regions[q.name] = 'head';
       notes.push(`${q.name} (${q.from}): second ${tag} layer, rigid on head`);
       // A region cannot swing, so strands found on it are only said.
@@ -1699,6 +1781,7 @@ export function proposeWithBasis(
       if (strands.length > 0) notes.push(strandNote(q, strands, [], strands, 'it rides the head as a region'));
     }
     for (const p of cands.slice(0, 1)) {
+      if (rides(p)) continue;
       const [g, r] = gridR(p);
       const fullMask = dilate(P.alpha(p), 7);
       const onArt = (pts: ReadonlyArray<readonly [number, number]>): boolean => pts.every((q) => isOn(fullMask, q[0], q[1]));
@@ -2022,8 +2105,42 @@ export function proposeWithBasis(
     if (hw.length === 1) notes.push(`handwear is one blob (${hw[0].name}): both sleeves in one mesh, split at the eye axis x=${pyFixed(axis, 0)}`);
   }
 
+  // Issue #402: the topwear part config.cloth.bottomwear.part names takes the skirt's rule and recipe below; every
+  // other topwear shaped like a skirt is named in a note when a recipe is in play, never drafted on by its shape.
+  const namedSkirt = ((): PartRecord | null => {
+    const name = recipeOf('bottomwear')?.part;
+    if (name === undefined) return null;
+    const refuse = (detail: string): never => {
+      throw new PartsError([{ code: 'PROPOSE_CLOTH_PART', object: 'config.cloth."bottomwear".part', detail }]);
+    };
+    const q = P.recs.find((x) => x.name === name);
+    if (q === undefined) return refuse(`names "${name}", which is no part in parts.json; a topwear part whose art hangs below the hip (a dress) is required`);
+    if (q.cut_from !== undefined) return refuse(`names "${name}", a piece an assemble.cuts entry took from ${q.cut_from}; name the part the plan made, ${q.cut_from}, or leave part out`);
+    if (!tw.includes(q)) {
+      return refuse(
+        `names "${name}", from ${q.from}; ${splitFrom(q.from)[1] === 'bottomwear' ? 'a bottomwear part takes the recipe by its tag already — leave part out' : "only a topwear part takes the skirt's recipe by name (a skirt See-through returned inside topwear, a dress)"}`,
+      );
+    }
+    const line = hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh;
+    if (q.y + q.h < line) {
+      return refuse(`names "${name}", whose box ends at y=${q.y + q.h}, above hip + ${TOPWEAR_HANGS_FACE_HEIGHTS} face heights (y=${pyFixed(line, 1)}), where the topwear rule reads a bodice that stops at the waist: no skirt hangs below the hip to hang trees on`);
+    }
+    return q;
+  })();
+  const skirtHints = new Map<string, string>();
+  if (cloth !== null) {
+    for (const p of tw) {
+      if (p === namedSkirt) continue;
+      const hint = skirtInsideNote(p, P.alpha(p), hip[1], fh);
+      if (hint !== null) skirtHints.set(p.name, hint);
+    }
+  }
+
   // ---- outer robe (topwear)
   for (const p of tw) {
+    if (p === namedSkirt) continue;
+    const hint = skirtHints.get(p.name);
+    if (hint !== undefined) notes.push(hint);
     const [g, r] = gridR(p);
     const mask = P.alpha(p);
     const top = chest[1] - 0.3 * fh;
@@ -2039,7 +2156,7 @@ export function proposeWithBasis(
             ['chest', rnd(along(hip, trunk.u, artExtent(mask, p, hip, trunk.u)[0])), rnd(along(hip, trunk.u, -20))],
             ['hip', rnd(along(hip, trunk.u, -20)), rnd(along(hip, trunk.u, 100))],
           ];
-    if (bw.length > 0 && bot < hip[1] + 0.25 * fh) {
+    if (bw.length > 0 && bot < hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh) {
       // A bodice that stops at the waist: robe chains down to the hem would fall off the art.
       meshes[p.name] = { grid: g, r, segments: segs };
       notes.push(`${p.name} ends at y=${bot} (hip ${pyFixed(hip[1], 0)}): no robe chains -- add a sash chain by hand if one hangs`);
@@ -2086,8 +2203,9 @@ export function proposeWithBasis(
     meshes[p.name] = { grid: g, r, segments: segs };
   }
 
-  // ---- skirt (bottomwear)
-  for (const p of bw) {
+  // ---- skirt (bottomwear, and the topwear part config.cloth.bottomwear.part names: issue #402)
+  const skirts = namedSkirt === null ? bw : [...bw, namedSkirt];
+  for (const p of skirts) {
     const [g, r] = gridR(p);
     const mask = P.alpha(p);
     const bot = p.y + p.h;
@@ -2122,7 +2240,7 @@ export function proposeWithBasis(
     // Issue #364: with config.cloth.bottomwear, the recipe's trees hang from the hip in place of the three keyed chains.
     const skirtRecipe = recipeOf('bottomwear');
     if (skirtRecipe !== null) {
-      const prefix = bw.length === 1 ? 'skirt' : `skirt_${p.name}`;
+      const prefix = skirts.length === 1 ? 'skirt' : `skirt_${p.name}`;
       const trees = T(p, 'bottomwear', skirtRecipe, {
         prefix,
         parent: 'hip',
@@ -2162,6 +2280,7 @@ export function proposeWithBasis(
           skirtRecipe,
           made.length,
           `${swing === null ? '' : ` on one shared swing, ${swing.bone} (each tree's first link takes its rotation times ${skirtRecipe.swing?.scales.join('/')}, its setup rotation ${swing.rest} degrees subtracted)`} from hip, rooted 20 px below its y and tipped 4 px above ${p.name}'s bottom, laid down the screen`,
+          p === namedSkirt ? p.from : undefined,
         ),
       );
       meshes[p.name] = { grid: g, r, segments: segs };
@@ -2316,7 +2435,9 @@ export function proposeWithBasis(
         object: `config.cloth."${t}"`,
         detail:
           P.byTag(t).length === 0 && P.headFirst(t).length === 0
-            ? `declares a recipe for "${t}", and no part is tagged "${t}"; leave the recipe out, or assemble the layer it is for`
+            ? t === 'bottomwear' && skirtHints.size > 0
+              ? `declares a recipe for "${t}", and no part is tagged "${t}"; leave the recipe out, assemble the layer it is for, or name the part that holds the skirt — ${[...skirtHints.values()].join('; ')}`
+              : `declares a recipe for "${t}", and no part is tagged "${t}"; leave the recipe out, or assemble the layer it is for`
             : t === 'back hair'
               ? `declares a recipe for "back hair", and every back hair part ends above the shoulders (0.5 face heights below the neck), which the proposer drafts as a bun bone with no chain; leave the recipe out`
               : `declares a recipe for "${t}", and the proposer drafted no chain on it`,

package/src/rig.ts

@@ -615,7 +615,7 @@ function applyTurn(
  * work. `ctl` stays the default because the examples' expected `rig.json` and
  * `motion.json` are the reference implementation's output, and because the
  * declaration lives in the rig spec only: `rigc validate <build> --profile
- * spine-html`, which has no rig spec to read, refuses a `direct` build once
+ * rig-play`, which has no rig spec to read, refuses a `direct` build once
  * per keyed mesh bone.
  */
 export const IDLE_KEYS = ['ctl', 'direct'] as const;