@rig-c/parts 2.41.0 → 2.42.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/docs/AUTHORING.md CHANGED
@@ -70,6 +70,26 @@ model stack. The wrapper README and the adapter graph use different node names
70
70
  and depth-model identifiers; [the adapter notes](../README.md#the-optional-comfyui-adapter)
71
71
  name the graph actually sent.
72
72
 
73
+ **For a painted source, assemble with `--project visible`** (`assemble.project:
74
+ "visible"`), and add `assemble.ground: "busy"` when the painting's backdrop is a busy,
75
+ opaque ground (a wall, a banner); with `plain` there, backdrop colours land on thin
76
+ outer strands. Under the default `core` rule, parts that overlap yield to each other
77
+ after projection with binary alpha clears (`pushBackFringe`, then the `yield_refused`
78
+ clear), which leaves stepped part edges; `visible` takes coverage from the painting's
79
+ own edges (issue #1275; the two rules are described in §5, at `assemble`). Measured on
80
+ the public example `demo`, the static recomposite against the painting:
81
+
82
+ | `demo`, static recomposite | `core` | `visible` |
83
+ | --- | ---: | ---: |
84
+ | meanAbs | 1.5163 | 0.3223 |
85
+ | errorPx | 14,016 | 712 |
86
+
87
+ Its cost: the hidden margin a part keeps under its neighbours shrinks in places
88
+ (`demo`: `hair_back` under `hair_front`, 13,597 -> 13,128 px), so a part that moves
89
+ may expose less underpaint; this was read at rest only and is not a claim about motion.
90
+ It does not fix a layer whose own colour differs from the painting where the painting
91
+ covers it (a neck under a collar): that layer keeps its colour. The default stays `core`.
92
+
73
93
  ### See-through head-run source reading
74
94
 
75
95
  **The head run is needed on every route that was read.** See-through's model
@@ -148,7 +168,7 @@ read by no CPU stage).
148
168
  | `seethrough.head_box` | inputs (cuts the head image there; optional at the first call); assemble — where the head run sits on the painting | **proposed** by `propose --head-box` from the full run, square, source pixels, shifted inside the painting when needed; the head run must then be fed exactly that crop. With one run (no `--head`, issue #359: an artist's own file, §4 *For artists*) it is left out — there is no crop to place — and a config that sets it is refused (`ASSEMBLE_SINGLE_RUN_HEAD_BOX`) |
149
169
  | `seethrough.arm_split` | assemble, `assemble --propose-plan` — separates a single full-run `handwear-r` or `handwear-l` layer that holds both overlapping arms into both arm tags | **authored**, optional (issue #439): `{x?: number, line?: [[x, y], …], order: ["handwear-r", "handwear-l"] \| ["handwear-l", "handwear-r"]}` in `seethrough.resolution` full-run pixels. Exactly one of `x` (image column, `0 <= x <= resolution`) or `line` (a polyline of two or more `[x, y]` points in `[0, resolution]`, interpolated in x along y and clamped above/below its endpoints) is required (`CONFIG_FIELD_PRESENT`, `CONFIG_FIELD_TYPE`), and `order` is `[back_tag, front_tag]`, the draw order of the two separated arm layers (`CONFIG_FIELD_PRESENT`, `CONFIG_FIELD_TYPE`). Pixels at `< splitX(y)` go to `handwear-r` (image left, the subject's right arm) and pixels at `>= splitX(y)` go to `handwear-l` (image right, the subject's left arm). A split line that cuts a horizontal opaque run of the arm layer into more than two segments is refused (`ASSEMBLE_ARM_SPLIT_CUTS_ARM`). Without the declaration, when one arm layer's 8-connected component reaches both wrists under `propose --keypoints`, `propose` emits an `overlapping-arms` `LINT` naming the part, both wrists and `seethrough.arm_split`; absent, no byte of any output moves |
150
170
  | `assemble.seam` | assemble, build | **authored**, optional `"near-white"` or `"silhouette"` (issue #905). An explicit `--seam` overrides the config; otherwise this field overrides the existing `near-white` default. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.seam`, including when a CLI override is given. Absent, existing build bytes are unchanged. |
151
- | `assemble.project` | assemble, build | **authored**, optional `"core"` or `"visible"` (issue #953): the projection rule for this character. An explicit `--project` overrides the config; otherwise this field overrides the existing `core` default. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.project`, including when a CLI override is given. Absent, existing build bytes are unchanged. |
171
+ | `assemble.project` | assemble, build | **authored**, optional `"core"` or `"visible"` (issue #953): the projection rule for this character. An explicit `--project` overrides the config; otherwise this field overrides the existing `core` default. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.project`, including when a CLI override is given. Absent, existing build bytes are unchanged. For a painted source, `"visible"` is the recommended value, with its measured cost (§1). |
152
172
  | `assemble.ground` | assemble, build | **authored**, optional `"plain"` or `"busy"` (issue #996): what lies behind the figure in the painting. `plain` (the default) is a ground of one colour; `busy` is an opaque ground of many colours (a wall, a banner). Read by `--project visible` only: a busy, opaque ground needs `assemble.ground: busy`; without it, visible takes backdrop pixels. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.ground`. Absent or `plain`, existing build bytes are unchanged. `assemble` warns (`ASSEMBLE_GROUND_PLAIN`, §5), under project: visible, where paintingEdges reads the ground, when a plain ground's border ring is not one colour. |
153
173
  | `assemble.rig_scale` | assemble — the rig is `trunc(w × rig_scale)` x `trunc(h × rig_scale)`, and every rig-px value after it (`bones`, `meshes`, `motion`, `patches`, `cuts`) is in that rig's pixels; `check --source` (`CHECK_SOURCE_SIZE`) and `compose` (`SCENE_RIG_SCALE_AGREES`) read it back off `parts.json` | authored; rig pixels per source pixel. 0.5 in both examples (a 1664x2432 painting makes an 832x1216 rig). **Keep the figure about 1,100 to 1,200 rig px tall** — the `H` of `propose`'s `mesh spacing:` note, the height of the parts' boxes together — so for another painting, about 1,150 over the figure's height in painting px: that is the size the proposer's spacing divisor was calibrated at (H 1106–1185, the `mesh spacing` note says so) and the size of the two examples `check`'s bars are derived from, and the proposer and `check` also hold fixed rig-px values that do not scale with it (the fringe's 10 px step, the trunk segments' 18, 20, 30 and 100 px, the 15 px wrist tolerance, the 10-row pendant floor, the seam bar's 50 rig px over 40). What else it trades, measured on `demo` with the README loop from a fresh config at 0.25, 0.5 and 1 (issue #345, rig-c 2.47.1): the same plan and the same ten chains; every bar but the one the uncorrected `demo` always fails (`bottomwear` `TIP_OVER_ROOT`, the README loop's `RL01`) passing at all three; the atlas page 418x606, 832x1205 and 1825x2047; the figure's mesh spacing 16, 32 and 64, so 830, 868 and 932 triangles; the breath 2.5 % of a torso that scales with it; and the proposed bones, scaled to 0.5, off the 0.5 proposal's by up to 38 px at 0.25 and 22.5 px at 1 (the hairpin's origin; the skirt roots 20 and 10.5) — the fixed-px values above. `propose` records it on the proposal as `proposed_rig_scale` (issue #354), and changing `assemble.rig_scale` after the rig sections are written is refused (`CONFIG_PROPOSED_RIG_SCALE`): without that refusal `demo`'s tracked config built at 0.25 gated green and `check` failed only `TIP_OVER_ROOT` on both sleeves (`propose --from-config` named 54 `LINT` lines, links off the art) — re-run `assemble` and `propose` at the new scale. Absent: `CONFIG_FIELD_PRESENT`; 0, negative or not a number: `CONFIG_FIELD_TYPE`; a rig under 1x1: `ASSEMBLE_RIG_SIZE` |
154
174
  | `assemble.plan` | assemble; also the list every `meshes`/`regions` key must come from | **proposed** by `assemble --propose-plan`. `[part name, "full" \| "head", See-through tag]`, in draw order back to front. Names are free; roles come from the tag. A layer the author made and added to a run takes `author:<label>` in the tag's place, and has no role (§5, *A layer the author made*). When `generation.control.skeleton` is present and a full-run `handwear-r` or `handwear-l` layer merges sleeve, bare hand and overgarment drape into one layer — a skin-coloured hand cluster (`>= 40` run px, `GHOST_MIN_AREA`, measured `516..4,787` run px across the 9-standee corpus) lies within `0.35` forearm lengths of `<s>_wrist` and non-skin pixels reach more than `1.0x` the forearm length (`<s>_elbow -> <s>_wrist`) below `<s>_wrist` (issue #490; measured `-0.15x..0.45x` on the 6 clean standees vs `1.25x..2.02x` on the 3 merged standees, placing `1.0x` inside the `0.45x..1.25x` gap) — the layer is split into `drape-<s>`, `handwear-<s>` and `hand-<s>` (back to front) when the Euclidean RGB distance between the sleeve median colour above `<s>_wrist` and the drape median colour below `<s>_wrist` is at least `80` (`ARM_DRAPE_COLOR_DISTANCE`, measured `103.6..236.0` on the two distinct-colour merged standees vs `20.8..28.2` on the same-colour merged standee, placing `80` between `28.2` and `103.6`), or refused with `SEETHROUGH_ARM_RUN_MERGED` when the distance is under `80` |
@@ -1126,6 +1146,42 @@ the author's non-empty declaration; the tool cannot verify which editor was
1126
1146
  used. The decoded width and height must equal the assembled part's box.
1127
1147
  A changed crop, scale, name or order needs a plan or cut change instead.
1128
1148
 
1149
+ Record a receipt with the shipped writer (issue #1328), after declaring
1150
+ `assemble.edited_parts` with its directory and an empty `receipts` array in
1151
+ each full character config:
1152
+
1153
+ ```sh
1154
+ rig-parts edited-part --config draft/config.json --part sleeve_r --file retouched/sleeve_r.png --from assembled/parts/sleeve_r.png --editor "image editor"
1155
+ # Update a second full config only when explicitly named:
1156
+ rig-parts edited-part --config draft/config.json --part sleeve_r --file retouched/sleeve_r.png --from assembled/parts/sleeve_r.png --editor "image editor" --rig-config rig/config.json
1157
+ ```
1158
+
1159
+ CLI paths resolve from the working directory; the stored `file` resolves from
1160
+ each config's own `edited_parts.dir`. The writer hashes the encoded PNG bytes,
1161
+ checks that both files decode and have equal dimensions, and validates every
1162
+ candidate config before writing either destination. It replaces the existing row for that
1163
+ part or appends at the array's length. New rows use key order `part`, `file`,
1164
+ `sha256`, `from_sha256`, `editor`; other rows and unrelated config bytes retain
1165
+ their original spelling and whitespace. No matching config is discovered.
1166
+
1167
+ The writer never reassembles or certifies the baseline. A wrong same-size
1168
+ `--from` is recorded; the next build refuses `ASSEMBLE_EDITED_PART_BASELINE`,
1169
+ naming the current assembled hash and the recorded hash. Supply the exact PNG
1170
+ from a normal build of this config. A successful writer prints one stdout line
1171
+ with the part, both hashes and the declared editor; it does not prove which
1172
+ editor was used. The shared writer prints `config <path>: added/replaced
1173
+ assemble.edited_parts.receipts[index]` or `config <path>: unchanged` on stderr.
1174
+ Validation refusals leave all named configs byte-identical.
1175
+
1176
+ Receipt updates use the same staged config writer as other config commands.
1177
+ The full loader validates each same-directory staged file, including relative
1178
+ motion sidecars. All configs stage before any commits. The shared batch helper
1179
+ restores earlier original configs if a later commit fails; a restoration
1180
+ failure names the retained original backup. A backup-cleanup failure can be
1181
+ reported after both complete configs are published; inspect its named path.
1182
+
1183
+ Writer refusals are listed in the [refusal ledger](#EDITED_PART_ARGUMENT).
1184
+
1129
1185
  Replacement occurs after projection, drift checks, seam override, ghost
1130
1186
  cleanup, paintingEdge and final region restoration. No automatic pass runs
1131
1187
  on the replacement afterward. The output part PNG is the verified file's
@@ -2053,6 +2109,22 @@ motion along its whole length. A region whose band reaches no outline edge chang
2053
2109
  vertex; one that does keeps every hull vertex in the same order from index 0, and a vertex moves
2054
2110
  up only by the points inserted before it.
2055
2111
 
2112
+ **Generated body-turn winding refusals (issue #1306).** When rigc's
2113
+ `A39_DEFORM_KEEPS_TRIANGLE_WINDING` refuses an actual contour attachment in the
2114
+ `body_turn` generated by `config.turn.body`, the rig stage keeps rigc's original
2115
+ text and adds [`RIG_CONTOUR_BODY_TURN_WINDING`](#RIG_CONTOUR_BODY_TURN_WINDING)
2116
+ inside `RIG_RIGC_GREEN`. The added line names the part, slot/attachment, failure
2117
+ frame, key index and time (or bounding keys and measured time for a span),
2118
+ reversal count, and the triangle indices, vertex triples and signed before/after
2119
+ areas rigc showed. Repeated gate lines get one added line per failure frame.
2120
+ Inspect `meshes.<part>.contour.maxEdge`, `meshes.<part>.contour.margin`,
2121
+ `meshes.<part>.contour.tolerance` and that part's depth sheet together. The outcome
2122
+ is not monotone in any field; no single field is a promised fix. Only rerunning
2123
+ rigc's gate decides whether the candidate passes. This diagnostic changes no mesh,
2124
+ depth sheet or generated key, and adds no winding validator. Lattice meshes,
2125
+ head turns, unrelated animations and attachments absent from the generated
2126
+ body-turn deform get no contour/body-turn advice.
2127
+
2056
2128
  **Weights.** A region's bone takes `g` at a vertex: 1 inside the region (its edge included),
2057
2129
  `1 − d/band` at a distance `d` past it, 0 at `d ≥ band` (with `band` 0, a step) — linear, no
2058
2130
  curve. The rest, `1 − g`, is shared among the segment bones exactly as the lattice shares a
@@ -3723,7 +3795,7 @@ step-up method below.
3723
3795
  | `motion.duration` and `track.period` | `check`'s 12 fps grid (`1/12` s per frame) | Choose `N` frames (e.g. `N = 40`, `duration = 40 / 12 = 3.3333333333333335` s, or `N = 48`, `duration = 4.0` s) and set every body track's `period = duration`. `CHECK_LOOP_LAST_FRAME_AT_DURATION` requires `duration` to land on a `1/12` s tick, and `CONFIG_PERIOD_DIVIDES_DURATION` requires `duration / period` to be an integer. |
3724
3796
  | Torso breath (`chest` `translatey`, `scalex`) | Figure height `H` (`parts.json` union height, kept near `1,100..1,200` rig px via `assemble.rig_scale`), torso span `L_torso = hypot(hip.x - neck.x, hip.y - neck.y)` from `bones`, and `BREATH_VISIBLE`'s `torso_heat_mean` vs `torso_floor` (pictured in `motion_heat.png`) | Floor: peak-to-peak vertical travel at `1.25 %` of `L_torso` (`amp = round2(0.00625 * L_torso)`, `base = amp`, `phase = 0.0`, i.e. `amp = 1.2` rig px on `demo`), paired with `chest` `scalex` `amp = 0.008`, `base = 1.008`, `phase = 0.0`. `check` scales the reference floor (`2.13` at `render_scale = 0.4211`) by `render_scale / 0.4211` and isolates the breath by posing only `chest`/`hip` `translate` and `scale` tracks. |
3725
3797
  | Upper-body sway (`chest` → `neck` → `head` `rotate`) | Shoulder lever arm `R_shoulder = \|sleeve_s0.x - chest.x\|` in `bones`, and `CHAIN_LAG` / `TIP_OVER_ROOT` on `handwear` | Floor: `amp(chest) = 0.7°`, `amp(neck) = 0.85°`, `amp(head) = 1.0°` with lag `0.05` (`phase: 0.25, 0.30, 0.35`). **Set `chest` `rotate` `phase` to `0.25` (quadrature, 90° from `chest` `translatey`'s `phase: 0.0`), never near `0.0`:** at `phase ≈ 0`, vertical breath `y(t)` and shoulder lift `Δx · θ(t)` reinforce on one shoulder and cancel on the other, inflating `root_rig_px` on the reinforced sleeve and dropping `tip_rig_px / root_rig_px` below `1.4725`. At `phase = 0.25`, vertical breath and rotational sway are orthogonal on both shoulders alike. |
3726
- | Sleeve physics (`sleeve_<s>0..2` under `chest`) | `CHECK_TIP_OVER_ROOT` (`ratio >= 1.4725` on each `handwear` part) and `CHECK_ANIMATIONS_DO_NOT_FOLD` | Set `"rotate": 1, "mix": 1, "inertia": 1.0, "damping": 0.75, "mass": 1` and taper `strength` down the chain: `[45, 30, 20]` for a 3-link sleeve (`1 : 0.67 : 0.44`). Stiff follow-through springs (`strength: 200`, `inertia: 0.2`) barely bend under a `3.333` s idle and move the sleeve as a rigid unit (`ratio ≈ 1.19..1.22`, failing `TIP_OVER_ROOT`); tapering `45 → 30 → 20` lets cumulative link rotation amplify cuff travel past `2.0x` the shoulder travel while keeping `0` folded triangles in `wave` and `hop`. Those ratios are the world reading `TIP_OVER_ROOT` took until issue #987; it now reads the halves against `chest`, the bone the sleeves hang from, and this recipe on `demo` (the working build reproduced below) reads `9.383` and `9.952` there (`handwear_l`, `handwear_r`; `3.626` and `2.905` in the world, which the row keeps as `world_ratio`) — it passes the reading the line holds (rig-parts at `c17292c` with #987's change, rigc 3.2.1). |
3798
+ | Sleeve motion (`sleeve_<s>0..2` under `chest`) | `CHECK_TIP_OVER_ROOT` certifies that the lower band of each `handwear` part's box travels more than the upper band (`ratio >= 1.4725`), in the frame of the bone it hangs from; it does not prove physics. Also measure `CHECK_ANIMATIONS_DO_NOT_FOLD`. | Set `"rotate": 1, "mix": 1, "inertia": 1.0, "damping": 0.75, "mass": 1` and taper `strength` down the chain: `[45, 30, 20]` for a 3-link sleeve (`1 : 0.67 : 0.44`). Stiff follow-through springs (`strength: 200`, `inertia: 0.2`) barely bend under a `3.333` s idle and move the sleeve as a rigid unit (`ratio ≈ 1.19..1.22`, failing `TIP_OVER_ROOT`); tapering `45 → 30 → 20` lets cumulative link rotation amplify cuff travel past `2.0x` the shoulder travel while keeping `0` folded triangles in `wave` and `hop`. Those ratios are the world reading `TIP_OVER_ROOT` took until issue #987; it now reads the halves against `chest`, the bone the sleeves hang from, and this recipe on `demo` (the working build reproduced below) reads `9.383` and `9.952` there (`handwear_l`, `handwear_r`; `3.626` and `2.905` in the world, which the row keeps as `world_ratio`) — it passes the reading the line holds (rig-parts at `c17292c` with #987's change, rigc 3.2.1). |
3727
3799
  | Hair physics (`hairback_*`, `bang_*` under `head`) | `CLOTH_SETTLES` (`>= 0.01694` rig px/s to the last frame), `CHECK_TEXTURE_STRETCH` (`<= 1.926544`), and `CHECK_ANIMATIONS_DO_NOT_FOLD` | Taper `strength` down each `n`-link chain by `strength_0 * (1 - 0.35 * i / (n - 1))`: on long back-hair chains, `strength_0 = 90` (`[90, 74.25, 58.5]` for 3 links), `inertia = 0.8`, `damping = 0.85`; on shorter fringe chains (`bang_*`), `strength = [130, 105]`, `inertia = 0.2`, `damping = 0.9`. |
3728
3800
  | Skirt / `bottomwear` physics (`skirt_*` under `hip`) | `CHECK_TIP_OVER_ROOT` on `bottomwear` (`ratio >= 1.4725`), `CHECK_ANIMATIONS_DO_NOT_FOLD` on `hop`, and `CLOTH_SETTLES` | Keep high restoration `strength` (`[200, 165, 130]` for 3 links, `inertia = 0.5`, `damping = 0.82`) so `bottomwear` does not fold during `hop`. With `hip` unkeyed, floor `"wind": [0.4, 0.6, 0.8]` passes `TIP_OVER_ROOT` (`ratio 1.83`); with `hip` keyed in `rotate` (`amp <= 0.4°`, `phase: 0.20`), set `"wind": 0` on the upper-half link `skirt_*0` and put `"wind"` on the lower links (`[0, 15, 40]`) so `tip / root` stays above `1.4725` and `CLOTH_SETTLES` clears on the default world. |
3729
3801
 
@@ -4539,7 +4611,7 @@ before it, at v0.14.0; the `--seam` figures above are v1.5.2's.
4539
4611
  **Page edges.** `rig`, `check` and `build` pack through `rigc build --pack
4540
4612
  --page-edges <v>`, and hand the value to rigc verbatim. The default is `free`,
4541
4613
  the least-area page the parts need. `--page-edges pot` is the opt-out: a power of
4542
- two on both edges, which is the page every build wrote before this flag. The pack
4614
+ two on both edges, which is the page every build wrote before this flag. `--page-size <px>` (optional, a positive integer; refused as `PACK_PAGE_SIZE` otherwise) is handed to rigc verbatim when given and recorded as `check.json`'s `pack_mode.page_size`. The pack
4543
4615
  line says which one ran, because rigc writes `, page edges free` after the padding under
4544
4616
  `free`. Measured on the two examples by `tools/atlas_population.ts` with rigc 1.5.1, and
4545
4617
  again with rigc 2.0.3, 2.1.3 and 2.10.1 under `--pack-shape rect` (the frames table
@@ -5726,6 +5798,11 @@ recorded transform. The record fields and sampling formula are specified in
5726
5798
  | <a id="ASSEMBLE_TAKE_UNIQUE"></a>`ASSEMBLE_TAKE_UNIQUE` | repeated donor for one target tag at runtime | declare each target run/tag once |
5727
5799
  | <a id="CONFIG_TAKE_UNIQUE"></a>`CONFIG_TAKE_UNIQUE` | config selects the same target run/tag more than once | retain one donor per target tag |
5728
5800
  | <a id="ASSEMBLE_PART_SOURCE"></a>`ASSEMBLE_PART_SOURCE` | `assemble.editor_receipts.trace_parts` is `true` and a part's pixels are decided by a shape drawn in the config — an `assemble.cuts` (or an alternate set's `cuts`) `polygon`, `seethrough.arm_split`, a limb's `split.line`, an `assemble.patches` `box`, an `assemble.extend_painting` `band`; the object names the part and where the shape is declared, the detail the shape found (issue #947) | `config.json`: remove that entry and paint the piece as an author layer (`author:<label>`) in an image editor with its receipt in `assemble.editor_receipts.receipts`, or take the part whole from a layer of the split (a limb split may use `"edge": "painting"`) |
5801
+ | <a id="EDITED_PART_ARGUMENT"></a>`EDITED_PART_ARGUMENT` | A writer argument is missing or blank. | Supply a non-empty config, part, file, from and editor; omit rig-config or name a non-empty path. |
5802
+ | <a id="EDITED_PART_BLOCK"></a>`EDITED_PART_BLOCK` | A named config has no assemble.edited_parts. | Declare its directory and receipts array before recording. |
5803
+ | <a id="EDITED_PART_FILE"></a>`EDITED_PART_FILE` | The file or from path is unreadable. | Supply readable PNG files at both explicit paths. |
5804
+ | <a id="EDITED_PART_PNG"></a>`EDITED_PART_PNG` | The file or from bytes are not a decodable PNG. | Supply PNGs supported by the existing codec. |
5805
+ | <a id="EDITED_PART_SIZE"></a>`EDITED_PART_SIZE` | Edited and from PNG dimensions differ. | Edit at the original crop and rig-pixel size. |
5729
5806
  | <a id="ASSEMBLE_EDITED_PART_UNKNOWN"></a>`ASSEMBLE_EDITED_PART_UNKNOWN` | A receipt names a part outside the base plan. | Use the existing base-plan part name; a new name needs a plan change. |
5730
5807
  | <a id="ASSEMBLE_EDITED_PART_FILE"></a>`ASSEMBLE_EDITED_PART_FILE` | The receipt file does not exist at dir/file. | Correct the config-relative dir or the directory-relative file, or supply that file. |
5731
5808
  | <a id="ASSEMBLE_EDITED_PART_SHA256"></a>`ASSEMBLE_EDITED_PART_SHA256` | The edited file bytes do not match sha256. | Use the intended edited file and record its exact file hash. |
@@ -5911,6 +5988,7 @@ recorded transform. The record fields and sampling formula are specified in
5911
5988
  | <a id="RIG_EXPLICIT_ISLAND_COUNT"></a>`RIG_EXPLICIT_ISLAND_COUNT` | `explicit.islands.length` differs from the non-dust 4-connected art island count of `parts/<part>.png`; the missing or extra `<part>__island<N>` slot names and island pixel counts are named | supply one `explicit.islands` entry per non-dust art island (`<part>`, `<part>__island2`, …); nothing is written |
5912
5989
  | <a id="RIG_EXPLICIT_ALTERNATE"></a>`RIG_EXPLICIT_ALTERNATE` | an alternate set replaces a part bound to one accepted explicit payload | use a generated mesh for alternate artwork; no alternate is inferred from a base payload |
5913
5990
  | <a id="RIG_INFLUENCE_REACH"></a>`RIG_INFLUENCE_REACH` | an influence mesh's `radius` is at or under the distance from its farthest lattice vertex to that vertex's nearest link (issue #378): a link pulls only when it is nearer than `radius`, so that vertex would be pulled by none. The vertex, where it is and the distance are named | a `radius` above the distance named, or a segment nearer that part of the art |
5991
+ | <a id="RIG_CONTOUR_BODY_TURN_WINDING"></a>`RIG_CONTOUR_BODY_TURN_WINDING` | config context appended inside `RIG_RIGC_GREEN` only for rigc's actual `A39_DEFORM_KEEPS_TRIANGLE_WINDING` failure on a contour mesh attachment in the `body_turn` generated by `config.turn.body` (issue #1306). Names the part, slot/attachment, failure frame, key index/time or bounding keys/measured span time, reversal count, and rigc's shown triangle indices, vertex triples and signed before/after areas; repeated gate lines get one added line per failure frame. Rigc's original text is retained | inspect `meshes.<part>.contour.maxEdge`, `meshes.<part>.contour.margin`, `meshes.<part>.contour.tolerance` and the part's depth sheet together. The outcome is not monotone in any field; no single field is a promised fix. Only rerunning rigc's gate decides whether the candidate passes; the diagnostic changes no mesh, depth or generated key and adds no validator |
5914
5992
  | <a id="RIG_INFLUENCE_LATTICE"></a>`RIG_INFLUENCE_LATTICE` | rig-c's segments lattice refused the part at the declared `cell` (no pixel of the part holds art, or the cell is not a whole number of at least 1); rig-c's message is quoted | a part with art, or a whole `cell` of at least 1 |
5915
5993
  | <a id="RIG_RIGC_GREEN"></a>`RIG_RIGC_GREEN` | rig-c refused the rig; its own FAIL or compile-error line is quoted, and nothing was written. A `constraints` field rigc does not read, or a value it refuses, is this line in rigc's words (`constraint "aim" (ik) has a key this compiler does not read: "mixx" (did you mean "mix"?)`), as is `A25_DETACHED_BONE_PARENTAGE` on a declared scene target. So is an ik whose `bones` are more than two, or two of which the second is not the first's child: from rig-c 2.15.0 its rig-spec parser refuses both by name (`ik constraint "reach" names 3 bones …`, `ik constraint "reach": "hem1" is not a child of "body" ("hem0" stands between) …`; firejune/rigc#1205), and this package no longer refuses them itself (issue #103; it did from #92 while rigc's gate passed them). Under `--idle-keys ctl` a two-bone ik over a chain link and its child link is that second refusal too, because the child's `<link>_ctl` stands between them; rigc's remedy names the control, which a config cannot, so when rigc's line says that control alone stands between, the rig stage adds a sentence naming `--idle-keys direct` on the command that ran | the field rigc's line names; for the split pair, `rig --idle-keys direct` or `build --idle-keys direct`, as the line says, which keys the link in place — rig-c's own AUTHORING §5 maps each of its assertions (`node_modules/@rig-c/core/docs/AUTHORING.md`) |
5916
5994
 
@@ -5951,7 +6029,7 @@ exits 0, and `mesh_draft.json` and the console name the reading and the amount.
5951
6029
  | <a id="REMESH_DELTA_TOPOLOGY"></a>`REMESH_DELTA_TOPOLOGY` | the replayed mesh breaks an outline rule (`contourTopologyProblems`' code quoted: one loop, the hull first, every triangle wound one way, no self-intersection, no coincident vertices), or holds more interior edges that are not locally Delaunay than the input did; or the input's own triangles are not wound one way | read the quoted code; the ops that made it are the edit's last ones |
5952
6030
  | <a id="REMESH_BONE_ORDER"></a>`REMESH_BONE_ORDER` | a bone of the input names a parent that is not declared before it — later in `bones` (`bones[i]` named), or nowhere once rig-c has expanded the rig's `stops` (issue #613). The delta's positions are read through the setup frames, which rig-c poses parents first, as rigc's rig reader resolves them (`CE_RIG_BONE_PARENT_ORDER`); the bones are not sorted into an order rigc would not load. rigc's gate over the input refuses such a rig first, so the line means rigc and its library read the bones apart | a defect between this package and rigc: report it with the line |
5953
6031
  | <a id="REMESH_INPUT_CHECK_FILE"></a>`REMESH_INPUT_CHECK_FILE` | `--input-check` names no file, a file that does not parse, one whose `spec` is not `rig-parts-input-check/1`, or one whose `versions`, `options`, `rig`, `parts` or `check` is not of the record's shape (issue #617); read before anything is built, nothing written | pass the `input-check.json` a `--record-input-check` run wrote |
5954
- | <a id="REMESH_INPUT_CHECK_BOUND"></a>`REMESH_INPUT_CHECK_BOUND` | a row of the `--input-check` record is not this run's (issue #617): a file under `--rig` or `--parts` (`parts.json`, `parts/`) added, missing or of other bytes, the rig or parts directory, the requirements file (absent, present, or of another path or bytes), `--page-edges`, `--pack-shape`, this package's version or `rigc --version`'s output; the row, the value recorded and the value required are named. The record is a check of another input, so it is not reused; nothing was built or written | run once with `--record-input-check` over this input, or leave `--input-check` off to measure the input again |
6032
+ | <a id="REMESH_INPUT_CHECK_BOUND"></a>`REMESH_INPUT_CHECK_BOUND` | a row of the `--input-check` record is not this run's (issue #617): a file under `--rig` or `--parts` (`parts.json`, `parts/`) added, missing or of other bytes, the rig or parts directory, the requirements file (absent, present, or of another path or bytes), `--page-edges`, `--pack-shape`, `--page-size`, this package's version or `rigc --version`'s output; the row, the value recorded and the value required are named. The record is a check of another input, so it is not reused; nothing was built or written | run once with `--record-input-check` over this input, or leave `--input-check` off to measure the input again |
5955
6033
  | <a id="REMESH_INPUT_CHECK_MOVED"></a>`REMESH_INPUT_CHECK_MOVED` | under `--record-input-check`, a file under `--rig` or `--parts` (or the requirements file) is not the same bytes after check-input read it as when the input was first hashed; the file and both digests are named. The check may have measured bytes the record's rows do not name, so neither the record nor the revision is written | leave the input alone while the run measures it, and run again |
5956
6034
  | <a id="REMESH_BONES_POSED"></a>`REMESH_BONES_POSED` | rig-c cannot pose the input's bones at the setup pose — its expansion of the rig's `stops`, or its evaluation of the bones (a bone `inherit` the runtime resolves to no mode), refuses with the sentence quoted; nothing was written | read rig-c's sentence; rigc's gate over the input passed, so report it with the line |
5957
6035
 
@@ -5989,7 +6067,7 @@ rig the input's check is the same every time. `--record-input-check` writes
5989
6067
  `input-check.json` into `--out` beside `remesh.json` (spec `rig-parts-input-check/1`):
5990
6068
  what that check read — every file under `--rig`, `parts.json` and every file under
5991
6069
  `parts/` by SHA-256, the two directories as resolved (check's own text can name them),
5992
- the requirements file's path and SHA-256, `--page-edges`, `--pack-shape`, this package's
6070
+ the requirements file's path and SHA-256, `--page-edges`, `--pack-shape`, `--page-size`, this package's
5993
6071
  version and `rigc --version`'s whole output — and the input's check side as
5994
6072
  `remesh.json` carries it. A later run given `--input-check <input-check.json>` compares
5995
6073
  every row with its own input before anything is built; when every row is its own it
@@ -6157,6 +6235,8 @@ outside the consumed inputs pending [#1177](https://github.com/rig-c/parts/issue
6157
6235
  | <a id="CHECK_SETUP_PAINTING_MEASURED"></a>`CHECK_SETUP_PAINTING_MEASURED` | missing native setup/ownership or unsupported clipping | supply observable textured setup geometry; an unavailable instrument never passes |
6158
6236
  | <a id="CHECK_BOUNDARY_COLOUR_STEP"></a>`CHECK_BOUNDARY_COLOUR_STEP` | the requirements file declares `boundary_colour.max_step_excess` and a part boundary's colour step in the rig's render exceeds the same boundary's step in the rig's own pieces by more than it; the part pair, the frame (`setup` or `idle frame <n> (t <s> s)`), the stage pixel, the excess, the declared allowance and both steps are quoted. Unlike [`CHECK_SETUP_MATCHES_PAINTING`](#CHECK_SETUP_MATCHES_PAINTING), which compares the painting per declared region at the setup pose, this compares against the rig's own flat pieces (`parts.json` placement at setup, each piece's rest colour through its art UVs on every idle frame), so a part drawn over its neighbour's line art is not a failure | the pair's rig image or mesh: `rig/images/<part>.png` (a texture stretched into its padded UVs, or a notch cut out of it), or that part's mesh in `config.json` `meshes` when the mesh cuts a corner off the art; see [Boundary colour step](#boundary-colour-step-issue-942) |
6159
6237
  | <a id="CHECK_BOUNDARY_COLOUR_UNMEASURED"></a>`CHECK_BOUNDARY_COLOUR_UNMEASURED` | `boundary_colour` is declared and the step cannot be taken: no `parts.json`, no `idle`, or a default-skin region or mesh image without a sequence, with a parts record, whose rig image is not its parts PNG with one even pad on every side (refused before anything is built); otherwise a drawn slot has no `parts.json` piece, is clipped, or its rig image is not its parts PNG with one even pad on every side (the slot and frame are named). Never a pass | make every drawn slot a `parts.json` piece, or drop `boundary_colour` from the requirements file (the bar then reports SKIP) |
6238
+ | <a id="CHECK_BEHIND_PART_SEAMS"></a>`CHECK_BEHIND_PART_SEAMS` | `behind_seams` is declared and a selected pair exceeds its allowance in the independent motion-opened or standing reading at setup or on an idle frame; the pair, behind slots, reading, frame, counted seam cells and allowance are named | repair the declared seam or author its per-pair allowance; no WARN mode or rest-visible mask; see [Behind-part seams](#behind-part-seams-issue-1314) |
6239
+ | <a id="CHECK_BEHIND_PART_SEAMS_UNMEASURED"></a>`CHECK_BEHIND_PART_SEAMS_UNMEASURED` | a pair with an authored effective threshold cannot read a mandatory population: selected pair, eligible behind slots, idle, readable setup, motion support, boundary population, or verified render/grid/material evidence; mandatory unread evidence makes the combined line FAIL. A missing threshold alone is a nonrequired SKIP and HOLE without this refusal code | supply the named measurement evidence; an invalid selected-pair override also refuses by name, and existing renderer or sidecar refusals remain refusals |
6160
6240
  | <a id="SETUP_PAINTING_REQUIRED_LIMIT"></a>`SETUP_PAINTING_REQUIRED_LIMIT` | `setup_painting.required` is `true` and a limit the check needs is absent: `rgb_tolerance`, `regions`, or a region's `max_pixels` (the object names the region). Refused when the requirements file is read, before anything is built (issue #943) | author the named limit; none is derived from the art. Without `required` the same region reports SKIP |
6161
6241
  | <a id="CHECK_SOURCE_GRID"></a>`CHECK_SOURCE_GRID` | the setup-pose still and its black-tinted twin (the coverage `SETUP_POSE_VS_SOURCE` reads) did not come back on one grid over one opaque background | a rigc problem; report it |
6162
6242
  | <a id="CHECK_RIGC_VERSION"></a>`CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on rig-c ^2.20.4), or put a newer `rigc` first on `PATH` |
@@ -6168,6 +6248,8 @@ outside the consumed inputs pending [#1177](https://github.com/rig-c/parts/issue
6168
6248
  | <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) |
6169
6249
  | <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 |
6170
6250
  | <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). A lag refusal (issue #580) prints the step, then the two phases it read — as the sine reader returns them, a negative amplitude read as amplitude > 0 at phase + 0.5 — then their difference, folded into (−¼, ¼] cycle because a sine's sign is half a cycle (so flipping an amplitude's sign does not change the step), then the child phases that pass for this parent: `phase step -0.230 cycle(s); >= 0.001 is required — … Phases read: "chest" 0.000, "sleeve_l0" 0.270 …; the step is their difference, 0.270, folded into (-1/4, 1/4] cycle … here a "sleeve_l0" phase in [0.001, 0.250] or [0.501, 0.750]` | for a lag, that chain track's `phase`/`lag`: a child phase from the parent's + 0.001 to + 0.25, modulo 0.5 — the windows the line prints. A larger phase helps only inside them: a child 0.25 to 0.5 above its parent still reads as a lead, and a negated `amps` moves nothing. For a swing, its `amps` (non-decreasing toward the tip; non-increasing on a chain declared resting) |
6251
+ | <a id="CHECK_CARRIER_NOT_EXCITED"></a>`CHECK_CARRIER_NOT_EXCITED` | the measured root-to-carrier chain, including the carrier itself, stays static during idle. The row adds `carrier_chain` (a string array in root-to-carrier order) and `measured_driver: "none"`. Missing or unusable geometry does not establish a static chain. The diagnostic names the unexcited carrier; a declared requirement for this cloth to move remains FAIL, never WARNING | drive the carrier during idle, or remove the requirement for this cloth to move on idle if still cloth is intended |
6252
+ | Below-floor cloth travel (unmeasured) | a link's larger unrounded carrier-frame root/tip travel is below the unchanged 0.5 rig px floor, after the zero guard. The diagnostic gives actual root and tip travel in rig px, the 0.5 rig px floor, and `measured_driver`: the nearest world-moving bone (including the carrier), `"none"` when measured still, or `"unavailable"` for missing or unusable geometry. This observes movement, not causal key attribution. The reading stays UNMEASURED under the existing SKIP policy; a separately declared requirement for measurable movement is not satisfied | drive the carrier so the cloth has measurable motion, or remove the requirement for this cloth to move on idle if that motion is not required |
6171
6253
  | <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 against the bone the part hangs from (issue #987; rig px quoted, the world reading beside it) | 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, which the detail names. Since issue #987 only a breath keyed under that bone is read: one at or above it is in the frame the halves are read in and carries nothing. When the bone named is a link of the chain the part hangs on, its segment stays, and the detail says to key the translate on the bone the part hangs from or above it. `nothing in it moves against \`<bone>\`` is a part that rides the bone it hangs from whole — a rigid sleeve, whose world ratio is 1. Since issue #995 a lone swing counts as a link too — a rotate-keyed bone with no child bone, or whose only child is its control twin (a one-link chain's control) — so a skirt bound to the one bone that swings it is read against the bone above, where its swing shows. A rotate-keyed body segment other bones hang under (a pelvis carrying the legs) is not one: a part bound whole to it reads `nothing in it moves against` that bone and fails, its world ratio passing only through the lever arm. Hang swinging cloth on its own bone under the body segment; a fitted garment the rig holds rigid on purpose (shorts on the pelvis) is declared in the scene file's `not_swinging` (§7), and the line then reads it SKIP with the reason. 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 |
6172
6254
  | <a id="CHECK_STILL_REGIONS_DARK"></a>`CHECK_STILL_REGIONS_DARK` | a slot of the face's still set (the `face` slots and every slot drawn over the face that the head bone alone carries) moves relative to the bone the face's slot rides, or a `footwear` slot moves on the screen, by more than the arithmetic's own rounding — measured from the idle's posed geometry (the slot, its largest displacement in rig px, the idle frame and the tolerance quoted) | on the face: a face mesh with a weight on a bone other than the head (`segments`), or one deformed by another bone; on the feet: a mesh weighted to a swinging bone, or a region on the wrong bone. A bang swinging over the face is not this line's failure: its depth is reported (`crossing`), with no bar |
6173
6255
  | <a id="CHECK_TEXTURE_STRETCH"></a>`CHECK_TEXTURE_STRETCH` | a mesh triangle's edge, in some idle frame, is more than 1.926544 times its rest length or less than 1/1.926544 of it (the mesh, triangle, its three vertices, the edge and the frame are named, and — issue #314 — the bones the edge's two vertices hang on: each vertex's two largest weights from `rig.json`, `vertex <i> is weighted to "<bone>" <w>, …`, then `on the idle's chains, the chain from "<first link>" carries "<bone>", …` — each chain `CHAIN_LAG` reads named once, by its first link — with a bone on no chain said, or `none of these bones hangs on a chain of the idle`); or a rest edge has length 0 A differing bone set on the failing edge or triangle names the bone and both shares. Cut attribution requires a matching config replay; otherwise the influence-cut remedy is conditional ("The weight cut"). | the chain tracks' `amps` on the bones that mesh is weighted to (the stretch grows with them), or the mesh's `segments` — a vertex blending two bones that swing against each other. Two chains named, with opposed amplitudes: give both one sign, or drop one — `propose --from-config` measures the pair before a build (§3, *Two chains on one lattice*). An edge whose two ends disagree on whether a bone's small share survives the 0.03 cut (one vertex keeps the bone at a few hundredths, the next drops it — read the two vertices' weights the line quotes): declare `influences: {floor: "continuous"}` on that mesh first, `rule: "heat"` second; the weight `exponent` moves the figure without removing the cut (issue #115, `reference-demo` `hair_back` as contour at tolerance 1, rig-c 2.47.1: 2.535 as drafted; continuous floor 1.422, heat 1.816, both PASS; exponent 1.5 / 3 / 4 / 6 read 2.564 / 1.902 / 2.119 / 4.816, the one pass on the same cut at another edge) |
@@ -6202,12 +6284,13 @@ outside the consumed inputs pending [#1177](https://github.com/rig-c/parts/issue
6202
6284
  | <a id="CHECK_PACK_LINE_READS"></a>`CHECK_PACK_LINE_READS` | rigc printed a `pack:` line that is not `pack: <page> <W>x<H>, <N> region(s), <P>% covered, padding <D>`, then `, page edges free` or nothing, then `, shape rect`, `, shape polygon` or nothing (rig-c 2.1 prints the shape; 1.5–2.0 printed none, read as `rect`); an unknown shape is this refusal; the line is quoted | a rigc this package does not know the output of; report it, with `rigc --version` |
6203
6285
  | <a id="CHECK_PACK_PAGE_EDGES"></a>`CHECK_PACK_PAGE_EDGES` | the pack line disagrees with the `--page-edges` the build was run with — its `, page edges free` clause is there under `pot` or missing under `free`, or a `pot` page is not a power of two on both edges | a rigc problem; report it, with `rigc --version` |
6204
6286
  | <a id="CHECK_PACK_SHAPE"></a>`CHECK_PACK_SHAPE` | the pack line disagrees with the `--pack-shape` the build was run with — it ends `, shape rect` under `polygon` or `, shape polygon` under `rect`, or it has no shape clause (the 1.5–2.0 form, read as `rect`) under `polygon` | a rigc older than 2.1.0 on `PATH`: rigc 2.0.3 takes `--pack-shape` without a word, packs by rectangles and prints the form with no shape clause, so this refusal is what catches it — `bun install` (this package depends on rig-c ^2.20.4); otherwise a rigc problem, report it with `rigc --version` |
6287
+ | <a id="PACK_PAGE_SIZE"></a>`PACK_PAGE_SIZE` | `--page-size` is not a positive integer (e.g. `0`, `-1`, `1.5`, `"abc"` or `""`); the value found and the value required (`a positive integer`) are named, and nothing is built or written | a positive integer in px; rigc's own range and power-of-two rules are enforced by `rigc build --pack` itself |
6205
6288
  | <a id="BUILD_ARTIFACT_PRESENT"></a>`BUILD_ARTIFACT_PRESENT` | the packed build lacks its `.json`, `.atlas` or page | a rigc problem; report it |
6206
6289
  | <a id="BUILD_REQUIREMENTS_CONFLICT"></a>`BUILD_REQUIREMENTS_CONFLICT` | `build --requirements <file>` names a file with other bytes than the one `config.requirements` declares (issue #556): the detail names both, each resolved (the flag against the working directory, the declaration against the config's) with its sha256 — or `no such file`. Refused before assemble writes anything. The same file by both, or a copy of its bytes, is not refused: the declaration is read and recorded | drop the flag to build from the config's file, or point `config.requirements` at the flag's |
6207
6290
  | <a id="BUILD_STAGE_REQUEST"></a>`BUILD_STAGE_REQUEST` | an internal build worker was given a missing or malformed request, an unknown stage, or incomplete runner, input, output or scratch paths; the worker refuses before running a stage. This is the internal process protocol, not a public command or option | invoke `rig-parts build` with its documented flags; if that command produces this refusal, report the named request defect rather than constructing or modifying a worker request |
6208
6291
  | <a id="REQUIREMENTS_FILE"></a>`REQUIREMENTS_FILE` | `--requirements` names no file, or one that does not parse as a JSON object. Refused before anything is built (by `build`, before assemble) | the path of a `spine-parts-requirements/1` file |
6209
- | <a id="REQUIREMENTS_FIELD"></a>`REQUIREMENTS_FIELD` | a field of the file is missing, of the wrong type, or not one the format reads: `spec`, `fps` (a positive number when supplied, required only when a declared measurement reads the file's sampling rate, with no default), `requirements`, each requirement's `name` (letters, digits, underscores; once each), `kind`, `animation` and its kind's fields — every bar among them (`within_px`, `fraction`, `tolerance`, `least_drive` above 0, `within_degrees` from 0 to 180, `lo_degrees` ≤ `hi_degrees`, `within_ratio` ≥ 1) — and each target's `bone`, `animation` and exactly one of `at` and `keys` (times strictly increasing), and `not_planted`, `not_swinging`, `rises` and `rests` when given (each a non-empty list of part names, each once; no part both in `not_swinging` and in `rises` or `rests`), and `may_fold` when given (a non-empty list of `{ "slot", "animation", "why" }`, every one a non-blank string, each pair once; issue #320), and `pinholes` when given (an object whose one field, `required`, is `true` or `false`; issue #944), `seam_over_motion` when given (the same shape; issue #941), and `boundary_colour` when given (an object whose one field, `max_step_excess`, is an integer from 0 through 255; issue #942). `note`, `*_note` (strings) and `x-…` (any value) are read by nothing, as in the config | write the field; the bar is yours. For a pair read only by `seam_over_motion.required`, declare `config.motion_seams` `[{part, neighbour}]` and omit a seam requirement. See the [carrier contract](#CONFIG_MOTION_SEAM) and [background over every frame](#background-over-every-frame-issue-941). |
6210
- | <a id="REQUIREMENTS_RESOLVES"></a>`REQUIREMENTS_RESOLVES` | a bone, an `ik` or `transform` constraint (by name and `constraint_type`, as rig-c resolves it), a slot, a mesh attachment or an animation the file names is not in `rig.json` or `motion.json`, or a seam's part or a `not_planted`, `not_swinging`, `rises` or `rests` name is not in `parts.json` — the detail lists the ones that are; or an animation whose name cannot be a directory. Refused before anything is built | the name as the rig spells it |
6292
+ | <a id="REQUIREMENTS_FIELD"></a>`REQUIREMENTS_FIELD` | a field of the file is missing, of the wrong type, or not one the format reads: `spec`, `fps` (a positive number when supplied, required only when a declared measurement reads the file's sampling rate, with no default), `requirements`, each requirement's `name` (letters, digits, underscores; once each), `kind`, `animation` and its kind's fields — every bar among them (`within_px`, `fraction`, `tolerance`, `least_drive` above 0, `within_degrees` from 0 to 180, `lo_degrees` ≤ `hi_degrees`, `within_ratio` ≥ 1) — and each target's `bone`, `animation` and exactly one of `at` and `keys` (times strictly increasing), and `not_planted`, `not_swinging`, `rises` and `rests` when given (each a non-empty list of part names, each once; no part both in `not_swinging` and in `rises` or `rests`), and `may_fold` when given (a non-empty list of `{ "slot", "animation", "why" }`, every one a non-blank string, each pair once; issue #320), and `pinholes` when given (an object whose one field, `required`, is `true` or `false`; issue #944), `seam_over_motion` when given (the same shape; issue #941), and `boundary_colour` when given (an object whose one field, `max_step_excess`, is an integer from 0 through 255; issue #942), and `motion_seams` when given (an array of `{part, neighbour}`, each an unordered pair of distinct output part names, once per list; issue #1269), and `behind_seams` when given (optional `threshold`, `allowance`, `pairs`; each pair requires distinct nonempty `part` and `neighbour`, with optional `threshold` and `allowance`; thresholds are integers from 0 through 255, allowances are nonnegative safe integers, and reverse duplicates are invalid; issue #1314). `note`, `*_note` (strings) and `x-…` (any value) are read by nothing, as in the config | write the field; the bar is yours. For a pair read only by `seam_over_motion.required`, declare requirements-level `motion_seams` `[{part, neighbour}]` and omit a seam requirement; this leaves a frozen `parts.json` untouched. `config.motion_seams` remains an assemble-time carrier into `parts.json`. See the [carrier contract](#CONFIG_MOTION_SEAM) and [background over every frame](#background-over-every-frame-issue-941). |
6293
+ | <a id="REQUIREMENTS_RESOLVES"></a>`REQUIREMENTS_RESOLVES` | a bone, an `ik` or `transform` constraint (by name and `constraint_type`, as rig-c resolves it), a slot, a mesh attachment or an animation the file names is not in `rig.json` or `motion.json`, or a seam's part, a requirements-level `motion_seams` part or neighbour, or a `not_planted`, `not_swinging`, `rises` or `rests` name is not in `parts.json` — the detail lists the ones that are; or an animation whose name cannot be a directory. Refused before anything is built | the name as the rig spells it |
6211
6294
  | <a id="REQUIREMENTS_CONSTRAINT_DRIVES"></a>`REQUIREMENTS_CONSTRAINT_DRIVES` | a `follow` names a bone its constraint does not constrain, or a property it does not drive: an `ik` drives `rotate` only; a `transform` drives `rotate` when a `to` names `rotate`, `translate` when one names `x` or `y` | the constraint's own bone and property |
6212
6295
  | <a id="REQUIREMENTS_TARGET_PARENT"></a>`REQUIREMENTS_TARGET_PARENT` | a scene target's bone is the root or is not parented to it, or the root is not at rest at the origin, or the animation keys the root — a stage point is a bone's position only under a root that stands still at the origin | a bone under the root for the scene to place |
6213
6296
  | <a id="REQUIREMENTS_TARGET"></a>`REQUIREMENTS_TARGET` | a scene target places one bone twice for one animation, places it for an animation no requirement measures, has a key outside the animation's `[0, duration]`, or sits in a group the animation translates | one placement per bone and animation, inside it, for an animation a requirement reads |
@@ -6222,7 +6305,7 @@ outside the consumed inputs pending [#1177](https://github.com/rig-c/parts/issue
6222
6305
  | <a id="REQUIREMENTS_TIP_EXCEPTION"></a>`REQUIREMENTS_TIP_EXCEPTION` | a `not_swinging`, `rises` or `rests` name is a part `TIP_OVER_ROOT` does not read — not from a See-through `handwear` or `bottomwear` layer — or there is no `parts.json` (refused before anything is built); or a `rises` part is not carried by a chain that rises: the chain's **last link**, at the setup pose, runs other than up — from its origin along its `length` (the extent the rig stage turns a link to), or, a last link with no length, from the link before's origin to its own — the detail giving the link read and the direction measured (refused after the idle is rendered, before `check.json` is written) (issues #231, #322; until #322 it read the chain's first link's origin to its last's, which refused a folded arm — a link that hangs, then a forearm raised) | a swinging part's name; for `rises`, a part whose chain does rise |
6223
6306
  | <a id="CHECK_ENVIRONMENT"></a>`CHECK_ENVIRONMENT` | `check --environment` (or `build --environment`, forwarded): the schedule is refused, the detail rigc's own sentence verbatim. Read once by rig-c's reader (`readEnvironmentSchedule`, `@rig-c/core/environment`) before anything is built — nothing at the path, a file that is not JSON or not an object, a `spec` other than `rigc-environment/1`, a key besides `spec`, `steps` or a step's `t`, `wind`, `gravity`, no step, a `t` not finite, below 0 or not after the step before, a `wind` or `gravity` not a pair of finite numbers (JSON's `1e999` reads as `Infinity` and is refused), a step stating neither — and `--out` is not written (`build` refuses under `[assemble]`, before it assembles). After the build, what `rigc render --environment` refuses of a well-formed schedule on this rig, quoted from its `--environment <path>:` line: no physics constraint, a half no constraint answers, two steps on one frame at 12 fps, a step after the last frame of the animation rendered. Also refused before anything is built: a `motion.json` with no animation, where no render `check` makes could pose the schedule | the schedule — rigc's sentence names the entry, the field, the value found and the value required; for a rig with no physics constraint, drop the flag: no world moves it |
6224
6307
  | <a id="CHECK_WIND_BAND"></a>`CHECK_WIND_BAND` | `check --wind-band` (or `build --wind-band`, forwarded, issue #590): the sweep file is refused before anything is built, or cannot be measured against the rig. Refused before the build (`build` refuses under `[assemble]` before it assembles, and `--out` is not written): nothing at the path, a file that is not a JSON object, an unknown key (besides `note`, `*_note` and `x-…`), a missing or malformed field (`spec` must be `"rig-parts-wind-band/1"`; `min`, `max`, `step` finite numbers with `min < max`, `step > 0`, and `(max - min) / step` within `1e-6` of an integer at most `64`; `fps` a positive integer; `max_gap` and `max_ghost` non-negative integers; `pairs` a non-empty array of unique `"<a>:<b>"` strings with `a !== b`). Refused against the rig before `rigc build`: a slot in `pairs` not in `rig.json`'s `slots`, `motion.json` with no animation, a rig with no physics constraint, or a rig where no physics constraint has a non-zero `wind`. Refused after the first sweep render (before `check.json` is written, with `--out` cleaned): a pair in `pairs` whose drawings share no overlap band at the setup pose (`status: "skip"` or `banded === 0` in `seam.json`) | the `--wind-band` file or the rig — every field in `"rig-parts-wind-band/1"` is required (nothing falls back to `SEAM_OVER_MOTION`), each `"<a>:<b>"` pair must name two distinct slots whose art overlaps at rest, and the rig must declare at least one physics constraint that answers `wind` |
6225
- | <a id="REQUIREMENTS_SEAM"></a>`REQUIREMENTS_SEAM` | a `seam` cannot be read against the rig: there is no `parts.json` (a merged rig, §7 *Measuring a rig rig-parts did not assemble*), or the two parts' art does not meet at the setup pose (no 4-adjacent pair). Refused before anything is built | two parts whose art touches, on a rig with its `parts.json` |
6308
+ | <a id="REQUIREMENTS_SEAM"></a>`REQUIREMENTS_SEAM` | a nonempty requirements-level `motion_seams` declaration has no `parts.json`, or a `seam` cannot be read against the rig: there is no `parts.json` (a merged rig, §7 *Measuring a rig rig-parts did not assemble*), or the two parts' art does not meet at the setup pose (no 4-adjacent pair). Refused before anything is built | two parts whose art touches, on a rig with its `parts.json` |
6226
6309
 
6227
6310
  **The world the readings are taken in** (`--environment`, issue #538). A physics chain
6228
6311
  answers the world as well as the bones above it, and `check` without the flag reads
@@ -6283,7 +6366,7 @@ contact counts do not replace or reinterpret them.
6283
6366
  **Steady-wind seam band** (`--wind-band`, issue #590). `check --wind-band <spec.json>` (or `build --wind-band <spec.json>`, forwarded) sweeps steady horizontal wind across a caller-declared grid and reports the contiguous `[x_lo, x_hi]` band in which each declared seam pair holds `gap <= max_gap` and `ghost <= max_ghost` across every animation in `motion.json`. Every field in `{ "spec": "rig-parts-wind-band/1", "min", "max", "step", "fps", "max_gap", "max_ghost", "pairs" }` is required — nothing falls back to `SEAM_OVER_MOTION`'s pairs, one-cell floor, or fps. At each swept step `x = min + k * step`, `check` runs `rigc render --seam <pairs> --fps <fps> --max 16 --environment` with a single-step steady schedule `{ "spec": "rigc-environment/1", "steps": [{ "t": 0, "wind": [x, 0], "gravity": [0, 1] }] }` (`seam.json` cells are in each pair's coarser drawing texels, independent of `--max`). **What it does not measure:** the sweep is steady wind (`wind: [x, 0], gravity: [0, 1]` at `t = 0`), not a time-varying gust (`x ± a` at 0.2 Hz); transient overshoot from a changing wind is not read by a steady sweep, and the band is documented and reported as the steady-wind band (`mode: "steady"`, `gravity: [0, 1]`). It is a reported line (`status: "REPORTED"`), never a bar: it prints one `WIND_BAND:` summary line plus one `WIND_BAND:` line per pair that breaks inside `[min, max]`, and writes `WIND_BAND` in `check.json` before `PASS`.
6284
6367
 
6285
6368
 
6286
- **Explicit motion seam observations** (issue #750). `motion_seams` is optional in a proposal, config and `parts.json`. The pure `draftMotionSeams(config, parts)` generator reads source provenance and the final declared carrier hierarchy: a non-limb `topwear` mesh on exactly two single-bone carriers which are a named parent and child, and non-limb `handwear-r`/`handwear-l` whose carriers are strict descendants with the same nearest trunk carrier, either that parent or that child. A sleeve may branch from the parent as a sibling of the child; it binds neither trunk carrier itself, and carriers with different nearest trunks do not qualify. This establishes declared structure, not positive compiled vertex weights or setup alpha overlap; the stock seam reader observes the band. Other structures add nothing. No part spelling, motion keys, distance heuristic or ancestor in common supplies identity. Proposal copy/write-config and turn preserve this field. For an older authored config, retain its original and use the same generator on its frozen structure/source parts, adding only this declaration in a derived config with a provenance receipt; regenerating its other rig or motion sections changes the experiment. Check reads the declaration, never calls this generator, and never restores a removed pair. A duplicate with an existing limb/requirement/root pair retains each source; an independently proven body-root pair keeps its existing FAIL policy.
6369
+ **Explicit motion seam observations** (issues #750, #1269). `motion_seams` is optional in a proposal, config, `parts.json` and the requirements file. The requirements carrier adds bar-free pairs without rewriting `parts.json`; see [Background over every frame](#background-over-every-frame-issue-941). The pure `draftMotionSeams(config, parts)` generator reads source provenance and the final declared carrier hierarchy: a non-limb `topwear` mesh on exactly two single-bone carriers which are a named parent and child, and non-limb `handwear-r`/`handwear-l` whose carriers are strict descendants with the same nearest trunk carrier, either that parent or that child. A sleeve may branch from the parent as a sibling of the child; it binds neither trunk carrier itself, and carriers with different nearest trunks do not qualify. This establishes declared structure, not positive compiled vertex weights or setup alpha overlap; the stock seam reader observes the band. Other structures add nothing. No part spelling, motion keys, distance heuristic or ancestor in common supplies identity. Proposal copy/write-config and turn preserve this field. For an older authored config, retain its original and use the same generator on its frozen structure/source parts, adding only this declaration in a derived config with a provenance receipt; regenerating its other rig or motion sections changes the experiment. Check reads the declaration, never calls this generator, and never restores a removed pair. A duplicate with an existing limb/requirement/root pair retains each source; an independently proven body-root pair keeps its existing FAIL policy.
6287
6370
 
6288
6371
  Every played non-root WARN, including existing limb pairs, additionally records the actual above-floor `worst` hit (`kind`, `index`, `px`, `cell`, `box`; maximum count, earliest frame on a tie, gap before ghost on a remaining tie) and `pose_at_worst` (`index`, actual raw `time`, `joints`). Each joint records `bone`, `parent`, `world_x_axis_degrees`, `parent_relative_setup_axis_delta_degrees_mod360`, `static_range`, `comparison` and, when needed, `reason`. Carrier paths come from the drawings actually shown at that frame and their positive weights or rigid binding, followed through the declared hierarchy. The SAME seam render supplies `--geometry`; animation, viewport, frame index and raw hit time are bound before its actual `setup.bones` and posed matrices are read. Animation frame 0 can already be posed and is never substituted for setup. Missing/mismatched geometry or matrices is a named refusal, never a zero angle or an estimate from source keys or frame/fps.
6289
6372
 
@@ -6602,6 +6685,31 @@ the two examples [observed]:
6602
6685
  | <a id="LIMB_ONE_BONE"></a>`LIMB_ONE_BONE` | issue #349. Each part `parts.json` records as a limb segment's (`limb`), read off `rig.json` and the adjacent optional `mesh_report.json`, nothing rendered: the bones its attachments are bound to — a mesh's weights, or its slot's bone for a region — against its segment's bone (under `config.turn`, that bone's leaf twin counts as the bone); a contour mesh may also bind the region bones its own part declares in `mesh_report.json`, named as `region_bones` in the row, with the same existing turn-twin equivalence. Hybrid bands retain their two-carrier rule | every limb part bound only to its segment carrier or its own declared contour region bones | not written: no limbs | not written: no limbs | never: written only when `parts.json` holds a limb part, so the examples' `check.json` keep their keys |
6603
6686
  | <a id="SEAM_OVER_RANGE"></a>`SEAM_OVER_RANGE` | issue #360. Each limb part `parts.json` records with a `range` (`config.limbs.<limb>.segments[k].range`): a copy of the rig with its physics constraints left out, its joint's bone keyed `rotate` to the range's min, its middle and its max (each angle once, rigc's sense, counter-clockwise on screen), one `rigc build --profile spine` and two `rigc render`s on one grid — one with the joint's own art drawn under the limb (the limb's parts at rest inside the cap's disc, one pixel in from every edge of what is opaque there, on the bone the joint's bone hangs from), one with it hidden (`--hide`); per pose, the seam figures of the second against the first. Issue #557: per pose also the **contour step**, a reading and never a bar — on the frame with the joint's art hidden, lines across the upper segment (perpendicular to its bone's direction at the setup pose, origin to the joint) one frame pixel apart, from one cap radius before the joint line to one past it; on each, from the axis outward on each side, the outline's extent (the first sample within 40 of the background, out to two radii); the step on a side is the largest change between adjacent lines, in rig px, `left` and `right` as the cap's `short_px` names them. A limb whose outline the bend keeps reads one frame pixel, 1 / s rig px (1.161 at the synthetic fixtures' s 0.861413); the unfilled two-layer knee of the selftest reads 11.609 on the opening side at ±15° and the filled one 1.161. The row prints it; `check.json` carries it (`step_px` on each pose) only for a joint whose cap record carries `short_px` | the rest-pose seam's: mean \|d\| ≤ 1.0 and ≤ 50 rig px over 40 at every pose; a `cap_shape: "disc"` or `"ball"` joint also 0 frame px over 40 (issue #598: the ball over its whole disc; the row says `shape`) | not written: no limbs | not written: no limbs | never: written only when `parts.json` holds a limb record with a `range`, so the examples' `check.json` keep their keys |
6604
6687
 
6688
+ **Carrier excitation diagnostics (issue #1308).** A static carrier is identified
6689
+ from the measured idle transforms of the root-to-carrier chain, including the
6690
+ carrier itself, not by scanning authored keys. Measured inherited motion and
6691
+ physics-driven motion count as excitation; absence of a direct carrier key is
6692
+ not evidence that the carrier is static. A measured wholly static chain is reported as
6693
+ [`CHECK_CARRIER_NOT_EXCITED`](#CHECK_CARRIER_NOT_EXCITED); its row adds
6694
+ `carrier_chain`, a string array in root-to-carrier order, and
6695
+ `measured_driver: "none"`. A below-floor `UNMEASURED` reading reports actual
6696
+ root and tip travel in rig px, the unchanged 0.5 rig px floor, and
6697
+ `measured_driver`: the nearest world-moving bone on that chain, including the
6698
+ carrier, `"none"` when the chain is measured still, or `"unavailable"` when
6699
+ geometry is missing or unusable. Unknown movement does not establish a static
6700
+ chain. The nearest moving bone is an observation, not causal attribution to
6701
+ its authored keys. The helper reads world-origin span and both affine columns
6702
+ rounded to three decimal places; it changes no public threshold.
6703
+
6704
+ These are diagnostic changes. A below-floor reading stays `UNMEASURED`; the
6705
+ existing SKIP policy and mixed-line verdict semantics are unchanged. It does
6706
+ not automatically make the generic check FAIL. A separately declared requirement
6707
+ for measurable cloth movement on idle is not satisfied by that reading. The
6708
+ static-carrier failure is not relaxed to WARNING. Drive the carrier, or remove
6709
+ that requirement if still cloth is the intent. The existing zero guard, travel
6710
+ floor and ratio bars are unchanged. Measured excitation and travel do not
6711
+ certify visible cloth movement.
6712
+
6605
6713
  **Small link motion (issue #994).** After the carrier-frame zero guard, a part on
6606
6714
  one of the links identified by the hang-bone walk is unmeasured when the larger of
6607
6715
  its unrounded root and tip travels is below **0.5 rig px**. Its row retains both travels, the ratio,
@@ -6907,6 +7015,7 @@ Under `--source <painting.png>`, a second reported line, also never a FAIL
6907
7015
  | <a id="CHECK_SUPPORT_GRID"></a>`CHECK_SUPPORT_GRID` | a support sidecar, part PNG or painting cannot be registered to the declared native canvas | use the same parts.json dimensions and source scale, and regenerate assemble output; no resized or guessed domain is substituted |
6908
7016
  | <a id="SETUP_MATCHES_PAINTING"></a>`SETUP_MATCHES_PAINTING` | declared region count, native box, limit and actual top contributor rows; observations source-over white unless `setup_painting.backdrop` declares the opaque plate behind a full-frame painting | PASS/FAIL against authored limits; no limit is SKIP, or the refusal `SETUP_PAINTING_REQUIRED_LIMIT` under `setup_painting.required: true`; with `--source`, no declaration is SKIP with its reason and declaration remedy; undeclared regions are not judged |
6909
7017
  | <a id="BOUNDARY_COLOUR_STEP"></a>`BOUNDARY_COLOUR_STEP` | the worst colour-step excess over the rig's own pieces at any part boundary of the setup and every idle frame, its part pair, frame and stage pixel, and the declared `max_step_excess` | PASS/FAIL against the declared allowance (FAIL is [`CHECK_BOUNDARY_COLOUR_STEP`](#CHECK_BOUNDARY_COLOUR_STEP), an unreadable piece [`CHECK_BOUNDARY_COLOUR_UNMEASURED`](#CHECK_BOUNDARY_COLOUR_UNMEASURED)); no `boundary_colour` in the requirements file is SKIP with its reason and the declaration to add, never a pass |
7018
+ | <a id="BEHIND_PART_SEAMS"></a>`BEHIND_PART_SEAMS` | selected front pair and declaration provenance, per-frame `behind_slots`, core seam grid, separate `setup`, `motion_opened` and `standing` readings, sampled/read/unmeasured counts, per-frame hits, worst frame, temporal spans and spatial runs | required for pairs with an authored effective threshold: PASS/FAIL against the effective allowance, default 0; missing T is a nonrequired SKIP and HOLE, while mandatory unread evidence causes `CHECK_BEHIND_PART_SEAMS_UNMEASURED` and combined FAIL; no declaration is SKIP, and curved or diagonal openings are not certified |
6910
7019
 
6911
7020
  `assemble` writes optional `part_support_domains.json` beside `parts.json`, with
6912
7021
  spec `rig-parts-support-domains/1`. It binds the exact parts.json and named PNG
@@ -7315,7 +7424,7 @@ is `{ "spec": "spine-parts-requirements/1", "requirements": [], "not_planted": [
7315
7424
  | `range` | `bone`, `lo_degrees`, `hi_degrees` | the bone's world rotation less its parent's (the world's, for the root), less the same at the setup pose, as a signed shortest angle: the least and the greatest, and their frames | — |
7316
7425
  | `stretch` | `slot`, `attachment` (a mesh), `within_ratio` | `TEXTURE_STRETCH`'s own per-mesh measure (imported, not rewritten): the mesh's worst max(ratio, 1/ratio) over the frames; `held_by` names what the worst edge's two vertices hang on, as `CHECK_TEXTURE_STRETCH` does (issue #321) | a rest edge of length 0; no frame shows the mesh |
7317
7426
  | `follow` | `constraint`, `constraint_type` (`ik` or `transform`), `bone`, `property` (`rotate` or `translate`), `fraction`, `tolerance`, `least_drive` | below | no frame's drive reaches `least_drive` (the line prints the largest drive there was) |
7318
- | `seam` | `part`, `neighbour` (two part names: each is drawn by the slot of its name), `within_px` (required for parting distance). For `seam_over_motion.required` pair coverage alone, declare `config.motion_seams` `[{part, neighbour}]` and omit a seam requirement. See the [carrier contract](#CONFIG_MOTION_SEAM) and [background over every frame](#background-over-every-frame-issue-941) | below | no seam pair reads on any frame (each pixel off its attachment's rest geometry, or the slot shows nothing) |
7427
+ | `seam` | `part`, `neighbour` (two part names: each is drawn by the slot of its name), `within_px` (required for parting distance). For `seam_over_motion.required` pair coverage alone, declare requirements-level `motion_seams` `[{part, neighbour}]` and omit a seam requirement; `parts.json` stays untouched. See the [carrier contract](#CONFIG_MOTION_SEAM) and [background over every frame](#background-over-every-frame-issue-941) | below | no seam pair reads on any frame (each pixel off its attachment's rest geometry, or the slot shows nothing) |
7319
7428
 
7320
7429
  A `contact` held against its own bone and point, and an `aim` at a point of the aimed bone itself, read 0 by construction (or, an aim at its own origin, no line at all), so they are refused before anything is built (`REQUIREMENTS_SELF_TARGET`, issue #540); a bone's tip against its own origin stays a contact, measured.
7321
7430
 
@@ -7637,6 +7746,27 @@ would gain a requirements block its `expected/` copy does not hold.
7637
7746
 
7638
7747
  ### Background over every frame (issue #941)
7639
7748
 
7749
+ The optional requirements-level `motion_seams` field (issue #1269) declares
7750
+ coverage without a distance bar and without editing the parts manifest:
7751
+
7752
+ ```json
7753
+ { "spec": "spine-parts-requirements/1", "requirements": [], "motion_seams": [{ "part": "upper", "neighbour": "lower" }], "seam_over_motion": { "required": true } }
7754
+ ```
7755
+
7756
+ Each entry contains only `part` and `neighbour`. The shared declaration reader
7757
+ refuses malformed shapes, self-pairs, unknown fields and duplicate pairs within
7758
+ the list (including reversed duplicates) as `REQUIREMENTS_FIELD`. Both names must
7759
+ resolve to rig slots and to parts in the supplied manifest
7760
+ (`REQUIREMENTS_RESOLVES`); a nonempty declaration without a parts manifest is
7761
+ `REQUIREMENTS_SEAM`. Check selects the union of the manifest's declarations,
7762
+ existing `seam` requirements and this list. An unordered pair appearing in
7763
+ several sources is read once and retains every source in `declared`; sources
7764
+ may contribute different pairs. An empty list adds nothing. With no selected
7765
+ pair, the required gate fails exactly as before. Existing `seam` requirements
7766
+ still require and measure `within_px`; no distance bar is inferred here.
7767
+ `config.motion_seams` continues to reach check through assemble's manifest
7768
+ carrier; standalone check does not read a new config source.
7769
+
7640
7770
  `SEAM_OVER_MOTION` reads every declared seam pair in every animation
7641
7771
  `motion.json` holds, the idle included: one `rigc render --seam` at 12 fps,
7642
7772
  which poses frame `i` at `i / 12` s for every `i` from 0 to
@@ -7645,7 +7775,7 @@ a pair depends on its class. A **body-root** pair (a limb's segment 0 against
7645
7775
  the body drawing its bone hangs from, proven from hierarchy, slots and
7646
7776
  provenance) is a bar; an **internal-joint** pair (a limb's two segments at a
7647
7777
  joint, `config.limbs`) and an **explicit** pair (a `--requirements` `seam`, or
7648
- `config.motion_seams`) only warn, and only above the one-cell floor (the
7778
+ `parts.json.motion_seams`, including the assemble-time `config.motion_seams` carrier, or requirements-level `motion_seams`) only warn, and only above the one-cell floor (the
7649
7779
  owner's ruling: a seam that opens in motion may be intended).
7650
7780
 
7651
7781
  An author who intends none to open declares it in the
@@ -7749,6 +7879,9 @@ art:
7749
7879
  its own parts PNG through its own art UVs — the boundary's colours at rest,
7750
7880
  tracked through the pieces' own UVs.
7751
7881
 
7882
+ A PASS does not prove seam closure: a standing opening present in both the
7883
+ render and its own-parts reference can have zero step excess.
7884
+
7752
7885
  The reading is the excess of the render's step over the reference's,
7753
7886
  `max(0, s_render - s_reference)`, and the bar is its largest value over every
7754
7887
  pair of every frame. A texture stretched into its padded UVs and a notch cut out
@@ -7775,6 +7908,133 @@ The public examples read, clean: `demo` 1, `scarf` 1, `reference-sample` 3,
7775
7908
  `config.json` does not name (as for `pinholes`), and the chain suite holds each
7776
7909
  to it (`CH942`); the suite `boundary-colour` holds the plants.
7777
7910
 
7911
+ ### Behind-part seams (issue #1314)
7912
+
7913
+ The optional `behind_seams` object in `spine-parts-requirements/1` activates
7914
+ `BEHIND_PART_SEAMS`. A pair with an authored effective T has required
7915
+ readings, with no WARN mode, new requirement kind or CLI flag. Omitting the
7916
+ block preserves existing requirements and checks; the behind-part reading is
7917
+ SKIP, never a claimed pass. An empty object is valid but supplies no contrast
7918
+ threshold: it reports a nonrequired SKIP and HOLE without an unmeasured refusal.
7919
+ It cannot establish a behind-part PASS.
7920
+
7921
+ | Field | Contract |
7922
+ | --- | --- |
7923
+ | `behind_seams.threshold` | Optional authored T, an integer from 0 through 255. There is no default. A pair override can supply it; a pair with neither value reports SKIP and a HOLE. |
7924
+ | `behind_seams.allowance` | Optional nonnegative safe integer counted-cell allowance for both independent halves. The explicit design ruling sets omission to 0. |
7925
+ | `behind_seams.pairs` | Optional array of selected-pair overrides; no adjacency is guessed. |
7926
+ | `behind_seams.pairs[i].part`, `behind_seams.pairs[i].neighbour` | Required distinct nonempty part names. They must resolve to known parts in the selected declaration population; repeating a pair in either order is invalid. |
7927
+ | `behind_seams.pairs[i].threshold` | Optional authored integer T from 0 through 255, overriding the rig value for this pair. No effective T means SKIP and a HOLE. |
7928
+ | `behind_seams.pairs[i].allowance` | Optional nonnegative safe integer, overriding the rig allowance for both halves of this pair. |
7929
+
7930
+ Malformed shapes and fields are [`REQUIREMENTS_FIELD`](#REQUIREMENTS_FIELD).
7931
+ Pair names must resolve to known parts and the pair must already belong to
7932
+ the actual selected declarations; neither is inferred from tags or body roles. Existing limb-segment, proven body-root and explicit
7933
+ seam declarations supply pair provenance. Missing selection or unresolved
7934
+ parts cannot be a zero reading. No threshold is borrowed from boundary colour
7935
+ or the setup seam bar.
7936
+
7937
+ For each selected front pair A/B, the behind set contains every slot strictly
7938
+ earlier than both members in that frame's actual draw order, including all its
7939
+ fragments. The complete ordered `behind_slots` list is reported and recomputed
7940
+ when draw order changes. Hiding the whole set proves the set's contribution;
7941
+ it does not uniquely attribute a defect to one rear slot.
7942
+
7943
+ The two readings are independent:
7944
+
7945
+ - `motion_opened` attributes core's stock transported setup-overlap
7946
+ `gapCovered` cells to that behind set. Its ordinary all-behind-hidden
7947
+ counterfactual must be transparent at the exact seam-cell centre, and setup
7948
+ attribution must show A or B covering that material. It uses no one-cell
7949
+ floor. A rigidly translated closed pair stays closed; no setup overlap band
7950
+ means this half is unmeasured, even when the standing half can read.
7951
+ - `standing` scans row and column runs whose combined A/B alpha is below
7952
+ 128/255, bracketed immediately by different unambiguous A/B owners. A cell
7953
+ counts when the behind set has positive surviving source-over contribution
7954
+ and its straight RGB differs from BOTH endpoint neighbours by strictly more
7955
+ than the effective T in max-channel distance. Equal-colour antialias ramps
7956
+ count zero contrast. Later opaque art contributes no visible rear colour.
7957
+ There is no width guess, rest mask or subtraction of setup-visible cells.
7958
+ A corridor with an ambiguous endpoint owner stays unread; neither A nor B
7959
+ is inferred. Other readable corridors on that frame retain their measured
7960
+ cells. A counted total above allowance stays FAIL even when another corridor
7961
+ is unread; an unread population cannot turn a measured failure into SKIP.
7962
+ With unread corridors and no measured excess, standing is SKIP, never PASS.
7963
+ This bracketed-run definition does not certify curved or diagonal openings.
7964
+
7965
+ Both readings use core's public `seamGridOf` from `@rig-c/core/seam` and its
7966
+ official raster traversal. The full
7967
+ render and ordinary hidden-set render retain identical pose, sampling, skin,
7968
+ constraints, physics, environment and viewport; the hidden render does not
7969
+ combine `--hide` with `--seam`. A viewport match alone is not a seam-grid proof.
7970
+ Cells join by world centre and cell side, never by nearest image pixel.
7971
+
7972
+ The report keeps `setup` separate from idle. Setup standing is measured in its
7973
+ own right; setup motion-opened is zero by definition only if setup was read.
7974
+ Standing is measured independently on every idle frame, including the trough.
7975
+ Rows name the pair, declaration provenance, animation, `behind_slots`, grid and
7976
+ sampled/read/unmeasured frame counts. Independent `motion_opened` and `standing`
7977
+ readings retain per-frame `index`, `time`, `px`, `cell`, `box`, `max_px`, the
7978
+ earliest worst hit and contiguous spans. `max_run` is temporal, in frames and
7979
+ seconds; `max_spatial_run_cells` is the longest counted horizontal/vertical run,
7980
+ with world length equal to cells times cell side. Counts named `px` are seam
7981
+ cells; rig-pixel area is count times cell side squared. Geometric rear-visible,
7982
+ raw contrast and threshold-filtered counts remain distinct. Overlapping pair
7983
+ counts are not a unique whole-rig area.
7984
+
7985
+ Issue #1325 adds optional unread-corridor evidence to the per-frame `standing`
7986
+ record, both at `BEHIND_PART_SEAMS.pairs[].setup.standing` and at
7987
+ `BEHIND_PART_SEAMS.pairs[].frames[].standing`. The fields below are relative to
7988
+ that record. They describe bracketed low-alpha runs with an endpoint owner of
7989
+ 0 or 3; they do not infer an owner or count those runs as measured contrast.
7990
+ The reported cells are the run's interior, excluding its endpoints, whether
7991
+ or not rear colour would qualify against T. A cell can be unread on one axis
7992
+ and readable on the other; unread evidence does not remove a measured hit.
7993
+
7994
+ | Field | Contract |
7995
+ | --- | --- |
7996
+ | `unread_cells` | Optional positive integer: the number of distinct native grid cells in all unread corridors of this frame. Cross-axis intersections count once; this is not a sum of `cell_count` values or a measured defect count. |
7997
+ | `unread_corridors` | Optional nonempty array. Horizontal corridors come first, in top-to-bottom row and left-to-right run order; vertical corridors follow, in left-to-right column and top-to-bottom run order. |
7998
+ | `unread_corridors[].axis` | `horizontal` for a row run, `vertical` for a column run. |
7999
+ | `unread_corridors[].endpoints` | Two numeric tuples in spatial order: left/right for horizontal, top/bottom for vertical. They are not reordered into A/B ownership order. Each tuple is `[grid_x, grid_y, world_x, world_y, owner]`. |
8000
+ | `unread_corridors[].endpoints[][0]` | Zero-based grid column, increasing right from the native viewport's left edge. |
8001
+ | `unread_corridors[].endpoints[][1]` | Zero-based grid row, increasing down from the native viewport's top edge. |
8002
+ | `unread_corridors[].endpoints[][2]` | World-space x coordinate of the endpoint cell centre. |
8003
+ | `unread_corridors[].endpoints[][3]` | World-space y coordinate of the endpoint cell centre, y up. |
8004
+ | `unread_corridors[].endpoints[][4]` | Observed half-alpha owner code: 0 means neither A nor B reaches 128/255; 1 means only A does; 2 means only B does; 3 means both do. A and B are the selected pair's named members; 0 and 3 are not resolved by guessing. |
8005
+ | `unread_corridors[].cells` | Interior native-cell centres as numeric `[world_x, world_y]` tuples, y up, left-to-right or top-to-bottom along the run. A centre may occur in multiple corridors. |
8006
+ | `unread_corridors[].cell_count` | The number of interior cells in this corridor, exactly `cells.length`. |
8007
+ | `unread_corridors[].row_scope` | `pair`; the corridor observes the selected front pair, not an individual rear slot. |
8008
+ | `unread_corridors[].row_kind` | `evidence`, including when the required check fails. |
8009
+ | `unread_corridors[].row_subjects` | The two selected part names in producer A/B order. |
8010
+
8011
+ Both optional fields are omitted when no ambiguous corridor is found; no zero
8012
+ or empty-array placeholders are written. Fully read frames retain their existing
8013
+ bytes. These additions do not change `motion_opened` or its report shape.
8014
+ Numeric colour underflow and other unavailable evidence retain their named
8015
+ unmeasured handling; absence of these optional fields alone does not prove a
8016
+ fully read frame.
8017
+
8018
+ `sampled_frames`, `read_frames` and `unmeasured_frames` count idle frames only.
8019
+ A frame enters `read_frames` only when both halves are available and no standing
8020
+ corridor is unread. A partially unread frame remains in `unmeasured_frames`
8021
+ even when its measured standing cells already make it FAIL. Setup is reported
8022
+ separately and is not counted as an idle frame.
8023
+
8024
+ A measured count above the effective allowance is
8025
+ [`CHECK_BEHIND_PART_SEAMS`](#CHECK_BEHIND_PART_SEAMS). A pair without an
8026
+ effective T reports a nonrequired SKIP and HOLE; missing T alone emits no
8027
+ `CHECK_BEHIND_PART_SEAMS_UNMEASURED` problem and cannot establish a behind-part
8028
+ PASS. With authored T, missing behind slots, idle, setup, motion support,
8029
+ boundary population or verified render/material evidence cannot establish PASS.
8030
+ An unavailable reading is SKIP; a partially unread standing reading retains
8031
+ any measured FAIL as described above. An unread population reports a HOLE and emits
8032
+ [`CHECK_BEHIND_PART_SEAMS_UNMEASURED`](#CHECK_BEHIND_PART_SEAMS_UNMEASURED),
8033
+ making the combined line FAIL. Existing hard render and sidecar failures
8034
+ remain named refusals. Setup-only or partial readings cannot establish the
8035
+ combined PASS. Other animations and
8036
+ alternate skins/sets are outside an idle-only claim unless explicitly measured.
8037
+
7778
8038
  ## 8. What one character costs
7779
8039
 
7780
8040
  | step | reference-sample | reference-demo | source |
@@ -8222,9 +8482,10 @@ declares `near`, positive `zScale` and `pivot`; optional `unitDepths` explicitly
8222
8482
  replaces that group's rigid depths. `clear` explicitly lists part references to
8223
8483
  remove, including any small units intended to sample the surface. Unselected
8224
8484
  parts retain their artwork and depth references. The output config copies the
8225
- original, sets the declared group pivots/unit depths, and relocates every file
8226
- reference `configFileReferences` declares, including `assemble.edited_parts`
8227
- receipt files, through that reference's `set`
8485
+ original, sets the declared group pivots/unit depths, and relocates the file
8486
+ references `configFileReferences` declares. It rebases `assemble.edited_parts.dir`
8487
+ to the output directory while keeping every receipt's `file` unchanged; other
8488
+ references use their `set`
8228
8489
  ([STABILITY](STABILITY.md#programmatic-config-file-references)). Built-in
8229
8490
  skeleton names remain names. A selected part whose provenance records
8230
8491
  `depth.kind: "authored-unit"` is refused before output
@@ -8687,55 +8948,64 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
8687
8948
  <!-- check-row-table:begin -->
8688
8949
  | Row family | Registered JSON paths | row_scope | row_kind | row_subjects (producer expression) | Producer |
8689
8950
  | --- | --- | --- | --- | --- | --- |
8690
- | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for e.slot; otherwise [] | [check.ts:3518](../src/check.ts#L3518) |
8691
- | `ANIMATIONS_DO_NOT_FOLD.folding` | `ANIMATIONS_DO_NOT_FOLD.folding` | part when the supplied mapping resolves a piece; otherwise rig | finding when entry === undefined; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:3480](../src/check.ts#L3480) |
8951
+ | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for e.slot; otherwise [] | [check.ts:3550](../src/check.ts#L3550) |
8952
+ | `ANIMATIONS_DO_NOT_FOLD.folding` | `ANIMATIONS_DO_NOT_FOLD.folding` | part when the supplied mapping resolves a piece; otherwise rig | finding when entry === undefined; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:3512](../src/check.ts#L3512) |
8692
8953
  | `ART_JOINT_DISTANCE.joints` | `ART_JOINT_DISTANCE.joints` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [artjoints.ts:86](../src/artjoints.ts#L86) |
8954
+ | `BEHIND_PART_SEAMS.contributors` | `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples[].contributors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:348](../src/behindseams.ts#L348) |
8955
+ | `BEHIND_PART_SEAMS.hits` | `BEHIND_PART_SEAMS.pairs[].motion_opened.frames`; `BEHIND_PART_SEAMS.pairs[].standing.frames`; `BEHIND_PART_SEAMS.pairs[].motion_opened.worst`; `BEHIND_PART_SEAMS.pairs[].standing.worst` | 'pair' | finding when r.px > allowance; otherwise evidence | parts | [behindseams.ts:408](../src/behindseams.ts#L408) |
8956
+ | `BEHIND_PART_SEAMS.pairs` | `BEHIND_PART_SEAMS.pairs` | 'pair' | finding when failed; otherwise evidence | parts | [behindseams.ts:485](../src/behindseams.ts#L485) |
8957
+ | `BEHIND_PART_SEAMS.pairs[].frames` | `BEHIND_PART_SEAMS.pairs[].frames` | | | | |
8958
+ | `BEHIND_PART_SEAMS.pairs[].setup` | `BEHIND_PART_SEAMS.pairs[].setup` | | | | |
8959
+ | `BEHIND_PART_SEAMS.samples` | `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:347](../src/behindseams.ts#L347) |
8960
+ | `BEHIND_PART_SEAMS.spans` | `BEHIND_PART_SEAMS.pairs[].motion_opened.spans`; `BEHIND_PART_SEAMS.pairs[].standing.spans` | 'pair' | evidence | parts | [behindseams.ts:416](../src/behindseams.ts#L416) |
8961
+ | `BEHIND_PART_SEAMS.unmeasured` | `BEHIND_PART_SEAMS.unmeasured` | pair === null ? 'rig' : 'pair'; 'rig' | finding when required; otherwise evidence; finding | pair === null ? [] : [pair.a, pair.b]; [] | [behindseams.ts:429](../src/behindseams.ts#L429), [behindseams.ts:562](../src/behindseams.ts#L562), [behindseams.ts:590](../src/behindseams.ts#L590) |
8962
+ | `BEHIND_PART_SEAMS.unread_corridors` | `BEHIND_PART_SEAMS.pairs[].setup.standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.unread_corridors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:271](../src/behindseams.ts#L271) |
8693
8963
  | `BOUNDARY_COLOUR_STEP.over` | `BOUNDARY_COLOUR_STEP.over` | 'pair' | finding | r.parts | [boundarycolour.ts:221](../src/boundarycolour.ts#L221) |
8694
8964
  | `BOUNDARY_COLOUR_STEP.unmeasured` | `BOUNDARY_COLOUR_STEP.unmeasured` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for r.slot; otherwise [] | [boundarycolour.ts:222](../src/boundarycolour.ts#L222) |
8695
- | `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:5960](../src/check.ts#L5960) |
8965
+ | `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:5996](../src/check.ts#L5996) |
8696
8966
  | `CUT_JOINT_MATERIAL.rows` | `CUT_JOINT_MATERIAL.rows` | 'part' | finding when r.status === 'FAIL'; otherwise evidence | [r.part] | [cutmaterial.ts:280](../src/cutmaterial.ts#L280) |
8697
- | `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:3719](../src/check.ts#L3719) |
8698
- | `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:3694](../src/check.ts#L3694) |
8699
- | `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:4011](../src/check.ts#L4011) |
8967
+ | `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:3751](../src/check.ts#L3751) |
8968
+ | `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:3726](../src/check.ts#L3726) |
8969
+ | `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:4043](../src/check.ts#L4043) |
8700
8970
  | `PART_SUPPORT_REPORT.pairs` | `PART_SUPPORT_REPORT.pairs` | 'pair' | evidence; finding when length > 0; otherwise evidence | [F.name, B.name] | [coincide.ts:114](../src/coincide.ts#L114), [coincide.ts:130](../src/coincide.ts#L130) |
8701
8971
  | `PART_SUPPORT_REPORT.raw_pairs` | `PART_SUPPORT_REPORT.raw_pairs` | 'pair' | evidence | [F.name, B.name] | [coincide.ts:110](../src/coincide.ts#L110) |
8702
8972
  | `PART_SUPPORT_REPORT.unowned.regions` | `PART_SUPPORT_REPORT.unowned.regions` | 'rig' | finding | [] | [coincide.ts:145](../src/coincide.ts#L145) |
8703
- | `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:5357](../src/check.ts#L5357) |
8704
- | `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:4681](../src/check.ts#L4681) |
8705
- | `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4673](../src/check.ts#L4673) |
8706
- | `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:5334](../src/check.ts#L5334) |
8707
- | `SEAM_OVER_MOTION.rows` | `SEAM_OVER_MOTION.rows` | 'pair'; unique ? 'pair' : 'rig' | finding when motionSeamFinding(want.root !== undefined, p.status, p.banded, opens.length); otherwise evidence; finding when motionSeamFinding(rootNames.has(r.pair), r.status, r.banded, r.opens.length); otherwise evidence | [want.a, want.b]; unique ? [pair.a, pair.b] : [] | [check.ts:5291](../src/check.ts#L5291), [check.ts:5363](../src/check.ts#L5363) |
8708
- | `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:5304](../src/check.ts#L5304) |
8709
- | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:5294](../src/check.ts#L5294) |
8973
+ | `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:5393](../src/check.ts#L5393) |
8974
+ | `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:4713](../src/check.ts#L4713) |
8975
+ | `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4705](../src/check.ts#L4705) |
8976
+ | `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:5370](../src/check.ts#L5370) |
8977
+ | `SEAM_OVER_MOTION.rows` | `SEAM_OVER_MOTION.rows` | 'pair'; unique ? 'pair' : 'rig' | finding when motionSeamFinding(want.root !== undefined, p.status, p.banded, opens.length); otherwise evidence; finding when motionSeamFinding(rootNames.has(r.pair), r.status, r.banded, r.opens.length); otherwise evidence | [want.a, want.b]; unique ? [pair.a, pair.b] : [] | [check.ts:5327](../src/check.ts#L5327), [check.ts:5399](../src/check.ts#L5399) |
8978
+ | `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:5340](../src/check.ts#L5340) |
8979
+ | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:5330](../src/check.ts#L5330) |
8710
8980
  | `SEAM_OVER_MOTION.rows[].pose_at_worst.joints` | `SEAM_OVER_MOTION.rows[].pose_at_worst.joints` | 'rig' | evidence | [] | [motionseampose.ts:53](../src/motionseampose.ts#L53) |
8711
- | `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:5288](../src/check.ts#L5288) |
8712
- | `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:4335](../src/check.ts#L4335), [check.ts:4381](../src/check.ts#L4381) |
8713
- | `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4379](../src/check.ts#L4379) |
8981
+ | `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:5324](../src/check.ts#L5324) |
8982
+ | `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:4367](../src/check.ts#L4367), [check.ts:4413](../src/check.ts#L4413) |
8983
+ | `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4411](../src/check.ts#L4411) |
8714
8984
  | `SETUP_MATCHES_PAINTING.regions` | `SETUP_MATCHES_PAINTING.regions` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [setuppainting.ts:175](../src/setuppainting.ts#L175) |
8715
8985
  | `SETUP_MATCHES_PAINTING.regions[].slots` | `SETUP_MATCHES_PAINTING.regions[].slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for slot; otherwise [] | [setuppainting.ts:176](../src/setuppainting.ts#L176) |
8716
- | `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:8910](../src/check.ts#L8910) |
8717
- | `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:8896](../src/check.ts#L8896), [check.ts:8901](../src/check.ts#L8901) |
8718
- | `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:3939](../src/check.ts#L3939) |
8719
- | `STRESS_OFF_CHAIN.per_part` | `STRESS_OFF_CHAIN.per_part` | 'part' | finding when poses.some(p => typeof p.reading === 'number' && p.reading > STRESS_RIGID); otherwise evidence | [r.part] | [check.ts:3927](../src/check.ts#L3927) |
8720
- | `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:3927](../src/check.ts#L3927) |
8721
- | `STRESS_OFF_CHAIN.per_part[].poses` | `STRESS_OFF_CHAIN.per_part[].poses` | 'part' | evidence; finding when shown > STRESS_RIGID; otherwise evidence | [r.part] | [check.ts:3895](../src/check.ts#L3895), [check.ts:3913](../src/check.ts#L3913) |
8722
- | `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:9560](../src/check.ts#L9560), [check.ts:9570](../src/check.ts#L9570) |
8723
- | `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:8325](../src/check.ts#L8325), [check.ts:8330](../src/check.ts#L8330), [check.ts:8351](../src/check.ts#L8351), [check.ts:8362](../src/check.ts#L8362) |
8724
- | `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6464](../src/check.ts#L6464) |
8725
- | `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6475](../src/check.ts#L6475) |
8726
- | `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5781](../src/check.ts#L5781) |
8727
- | `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7445](../src/check.ts#L7445) |
8728
- | `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:7744](../src/check.ts#L7744) |
8729
- | `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:7744](../src/check.ts#L7744) |
8730
- | `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:7744](../src/check.ts#L7744) |
8731
- | `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4670](../src/check.ts#L4670) |
8732
- | `seam_cells.frames[].cells` | `frames[].cells` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for cell.setupTop ?? ''; otherwise [] | [check.ts:4630](../src/check.ts#L4630) |
8733
- | `seam_pairs` | `seam_pairs`; `seam_scope.whole_pairs`; `sets.*.seam_pairs`; `sets.*.seam_scope.whole_pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:2480](../src/check.ts#L2480) |
8734
- | `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:1958](../src/check.ts#L1958) |
8735
- | `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:2043](../src/check.ts#L2043) |
8736
- | `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:7355](../src/check.ts#L7355) |
8737
- | `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:2414](../src/check.ts#L2414) |
8738
- | `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:2415](../src/check.ts#L2415) |
8986
+ | `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:9026](../src/check.ts#L9026) |
8987
+ | `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:9012](../src/check.ts#L9012), [check.ts:9017](../src/check.ts#L9017) |
8988
+ | `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:3971](../src/check.ts#L3971) |
8989
+ | `STRESS_OFF_CHAIN.per_part` | `STRESS_OFF_CHAIN.per_part` | 'part' | finding when poses.some(p => typeof p.reading === 'number' && p.reading > STRESS_RIGID); otherwise evidence | [r.part] | [check.ts:3959](../src/check.ts#L3959) |
8990
+ | `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:3959](../src/check.ts#L3959) |
8991
+ | `STRESS_OFF_CHAIN.per_part[].poses` | `STRESS_OFF_CHAIN.per_part[].poses` | 'part' | evidence; finding when shown > STRESS_RIGID; otherwise evidence | [r.part] | [check.ts:3927](../src/check.ts#L3927), [check.ts:3945](../src/check.ts#L3945) |
8992
+ | `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:9676](../src/check.ts#L9676), [check.ts:9686](../src/check.ts#L9686) |
8993
+ | `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:8430](../src/check.ts#L8430), [check.ts:8435](../src/check.ts#L8435), [check.ts:8456](../src/check.ts#L8456), [check.ts:8467](../src/check.ts#L8467) |
8994
+ | `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6500](../src/check.ts#L6500) |
8995
+ | `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6511](../src/check.ts#L6511) |
8996
+ | `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5817](../src/check.ts#L5817) |
8997
+ | `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7498](../src/check.ts#L7498) |
8998
+ | `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:7800](../src/check.ts#L7800) |
8999
+ | `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:7800](../src/check.ts#L7800) |
9000
+ | `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:7800](../src/check.ts#L7800) |
9001
+ | `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4702](../src/check.ts#L4702) |
9002
+ | `seam_cells.frames[].cells` | `frames[].cells` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for cell.setupTop ?? ''; otherwise [] | [check.ts:4662](../src/check.ts#L4662) |
9003
+ | `seam_pairs` | `seam_pairs`; `seam_scope.whole_pairs`; `sets.*.seam_pairs`; `sets.*.seam_scope.whole_pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:2508](../src/check.ts#L2508) |
9004
+ | `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:1986](../src/check.ts#L1986) |
9005
+ | `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:2071](../src/check.ts#L2071) |
9006
+ | `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:7397](../src/check.ts#L7397) |
9007
+ | `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:2442](../src/check.ts#L2442) |
9008
+ | `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:2443](../src/check.ts#L2443) |
8739
9009
 
8740
9010
  | Open serialized type path | Reason for schema exclusion |
8741
9011
  | --- | --- |