rig-parts 1.83.2 → 1.85.0

package/cli.ts

@@ -723,6 +723,8 @@ usage:
   rig-parts assemble --source <painting.png> --full <dir|psd> [--head <dir|psd>]
                        --config <config.json> --out <dir> [--seam near-white|silhouette]
                        [--project core|visible] [--alt <name>=<source>:<full>[:<head>]]
+                       [--requirements <file.json>]
+      With cut_material declared, records original source edges bound to emitted parts for check.
       Merge the full-body and head-crop See-through runs into rig-space parts:
       <out>/rig/parts/<name>.png (each cropped to its alpha box), <out>/rig/parts.json,
       <out>/render/recomposite_rig.png and <out>/render/${ERROR_MAP_FILE} (the error
@@ -1082,7 +1084,7 @@ const TAKES = {
   compare: { valued: ['--left', '--right', '--map'], switches: [] },
   check: { valued: ['--rig', '--out', '--parts', '--source', '--page-edges', '--pack-shape', '--requirements', '--set', '--environment', '--wind-band'], switches: ['--seam-pairs', '--keep-stills', '--all-sets', '--no-extremes'] },
   loop: { valued: ['--frames', '--out'], switches: ['--palette'] },
-  assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project', '--alt', '--write-config'], switches: ['--propose-plan'] },
+  assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project', '--alt', '--write-config', '--requirements'], switches: ['--propose-plan'] },
   'comfy seethrough': { valued: ['--image', '--out', '--resolution', '--steps', '--seed', '--prefix', '--host', '--wait', '--timeout', '--poll', '--config', '--depth-run'], switches: ['--offload', '--no-offload', '--lama', '--nf4'] },
   'comfy paint': { valued: ['--config', '--out', '--seeds', '--seed0', '--host', '--wait', '--timeout', '--poll'], switches: [] },
   inputs: { valued: ['--source', '--config', '--out'], switches: [] },
@@ -1707,6 +1709,7 @@ function cmdAssemble(args: string[]): number {
   }
   // --head is optional (issue #359): without it the full run is the one run, and it must hold the face.
   for (const f of ['--source', '--full', '--config']) if (!flags.has(f)) return usage(`assemble needs ${f}`);
+  if (propose && flags.has('--requirements')) return usage('--requirements belongs to assemble output, not --propose-plan');
   if (propose && (flags.has('--out') || flags.has('--seam') || flags.has('--project') || alts.length > 0)) return usage('--propose-plan prints to the console; it takes none of --out, --seam, --project, --alt');
   if (!propose && flags.has('--write-config')) return usage('--write-config belongs to assemble --propose-plan');
   if (!propose && !flags.has('--out')) return usage('assemble needs --out <dir>');
@@ -1739,7 +1742,7 @@ function cmdAssemble(args: string[]): number {
     }
     const out = flags.get('--out') as string;
     assembleStage(
-      { source, full, head, config, seam: seam as SeamRule, project: project as ProjectRule, ...(alts.length === 0 ? {} : { alts }) },
+      { source, full, head, config, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), seam: seam as SeamRule, project: project as ProjectRule, ...(alts.length === 0 ? {} : { alts }) },
       { partsJson: join(out, 'rig', 'parts.json'), partsDir: join(out, 'rig', 'parts'), recomposite: join(out, 'render', 'recomposite_rig.png'), errorMap: join(out, 'render', ERROR_MAP_FILE) },
       console.log,
     );

package/docs/AUTHORING.md

@@ -4067,6 +4067,93 @@ consumer acceptance work; assembly provenance does not establish motion quality.
 
 <a id="source-before-scissors-issue-819"></a>
 
+A hand polygon ending at a joint supplies no material for that joint's turn
+(issue #888). An `overlap` keeps pixels on the **parent**; it does not grow
+the cut piece. No source for material past the joint means stop and name the
+tool gap, following the source ladder below; do not hide a tear with crops or
+under-pieces. With an explicit `cut_material` declaration, `assemble` prints
+each original polygon edge's length through
+opaque source art (`alpha > 8`) and contiguous material past it on the piece.
+The same reading covers a limb's original structural joint line and the
+lower segment together with its generated hybrid band, when present.
+Assembly readings are SKIP-class observations; only check judges the declared bend.
+Without a declaration the API reading is SKIP and the CLI keeps its existing output.
+Limb source intersections use the final segmentation ownership map separately
+for each adjacent source; another limb's island is excluded before capture.
+
+To enforce a bend, add `cut_material` to the existing
+`spine-parts-requirements/1` file (the other fields remain required):
+
+```json
+{
+  "spec": "spine-parts-requirements/1", "fps": 12, "requirements": [],
+  "cut_material": [{
+    "part": "hand", "joint": "wrist", "at": [8, 12], "axis": [0, 1],
+    "reach_px": 3, "bend_degrees": [-30, 30]
+  }]
+}
+```
+
+These are hand-computable fixture coordinates, not recommended rig values.
+`at` is an independently supplied joint centre in stage pixels (y down);
+`axis` identifies an original opaque cut inward within reach, checked against
+the source evidence. Every polygon edge retains its own canonical inward
+normal; a declaration matching none of the eligible edges is refused.
+Correspondence accepts exact perpendicularity to the original edge direction
+(zero dot product), or exact collinearity with its stored canonical inward
+(zero cross product); the inward cross-product sign must also agree.
+Positive scalar multiples such as `[1,1]` and `[2,2]` are equivalent; rounded
+unit components are never compared. Orientation arithmetic must be finite and
+the direction magnitude representable, otherwise the declaration is refused.
+`reach_px` is the author's explicit joint reach, and `bend_degrees` is the
+continuous interval in stage coordinates, positive clockwise, inside
+`[-180, 180]`. Nothing is inferred from a name or an animation. A limb's joint
+name and centre must match its recorded lower segment; segment0 and a
+standalone generated band have no lower structural cut to read.
+
+Run `assemble --requirements <file>` (or `build --requirements <file>`)
+first, then `check --requirements <file>` against that assembly. Only an
+explicit `cut_material` declaration writes `cut_material_sources.json`
+beside `parts.json`: original edge endpoints, inward direction, opaque
+source intervals split at pixel-cell boundaries (ordered, nonoverlapping
+`opaque_t` spans inside `[0,1]` on their actual edge), source labels and
+transformed RGBA digests including placement and size, bound to the emitted `parts.json` and every base PNG by SHA-256.
+`check` also verifies the complete source payload digest, the interval census
+and canonical perpendiculars. Listed source edges must contain positive
+opaque intervals; an empty array cannot hide an edge beside another one.
+`check` never reconstructs discarded source pixels or polygons from siblings.
+Missing or stale evidence is unavailable, not zero support. Assemble again to
+refresh it. Alternate-set source evidence is not interchangeable with the base
+assembly; this instrument currently reads the base parts only.
+
+The gate clips every original opaque edge interval to the declared reach.
+Let its tangent be `(-ny, nx)` for inward normal `n`. A point relative to the
+joint has **both** coordinates `(t, d)`, where `d` is the actual cut plane's
+normal offset. Inverse rotation gives `(t*cos(theta) - d*sin(theta),
+t*sin(theta) + d*cos(theta))`. Required outward material, measured from the
+actual cut plane, is `max(0, d*(1-cos(theta)) - t*sin(theta))`; the normal offset
+is never dropped or projected onto the joint plane.
+
+The entire actual line segment is tested against every relevant transparent
+pixel cell's outward normal shadow. Segment/polygon incidence can change only
+when a rotating endpoint crosses an edge, the rotating source line crosses a
+vertex, or edges become parallel. All critical angles are solved analytically;
+interval interiors and boundary angles cover the whole declared continuous
+range, including a fixed angle. A strict intersection supplies a witness and
+its contiguous depth, ending at the first transparent cell. Midpoint rays are
+additional diagnostics, never the coverage proof. No angular sampling rate or
+calibrated tolerance is used. Controls plant a between-ray hole and translated
+and oblique cut edges whose inverse rotations are computed by hand.
+
+`CHECK_CUT_JOINT_MATERIAL` names part, joint, original edge length, length
+within reach and found/required depth on the same deficient ray. The interval
+and pixel-cell geometry are measured; subpixel texture filtering, another
+motion, material outside the declared reach and consumer compositing remain
+outside this gate. An absent source crossing or unrepresentable arithmetic is
+`CHECK_CUT_MATERIAL_MEASURED`, never PASS. Without a declaration the API reading
+is SKIP; the CLI preserves its existing stdout and adds no sidecar, `parts.json` field,
+`check.json` field or counted bar to an undeclared build.
+
 **Scissors are for structure, never for repair.** `cuts`, `patches` and
 `author:<label>` layers separate something that must move independently and
 that See-through has no layer for: a joint, an accessory, or a rear piece that
@@ -4934,6 +5021,9 @@ documents do not ship). Each is an input this package built; none is an author's
 | <a id="CHECK_INPUT_PRESENT"></a><a id="CHECK_INPUT_IS_JSON"></a><a id="CHECK_PART_PNG_PRESENT"></a><a id="CHECK_PART_PNG_MATCHES_BOX"></a><a id="CHECK_PART_SLOT_PRESENT"></a><a id="CHECK_RIG_STAGE_PRESENT"></a><a id="CHECK_RIG_STAGE_IS_THE_CANVAS"></a><a id="CHECK_RIG_ROOT_BONE"></a><a id="CHECK_IDLE_PRESENT"></a>`CHECK_INPUT_PRESENT`, `CHECK_INPUT_IS_JSON`, `CHECK_PART_PNG_PRESENT`, `CHECK_PART_PNG_MATCHES_BOX`, `CHECK_PART_SLOT_PRESENT`, `CHECK_RIG_STAGE_PRESENT`, `CHECK_RIG_STAGE_IS_THE_CANVAS`, `CHECK_RIG_ROOT_BONE`, `CHECK_IDLE_PRESENT` | the rig directory is incomplete or disagrees with `parts.json` (`CHECK_PART_SLOT_PRESENT`: a part with no slot of its own name, which the judgement lines render it by; `CHECK_INPUT_PRESENT` on `--set` / `--all-sets`: no `parts.json`, no `alternates`, or the named set is not in `alternates`). `motion.json` is required even with no animation in it, because `rigc build` takes `--motion` (a spec with `"animations": {}` builds green); `CHECK_IDLE_PRESENT` is an `idle` that is there with no positive `duration` — an absent `idle` is measured around (§7). `CHECK_INPUT_PRESENT` on `…/parts.json`: `--parts` named a directory without `parts.json` — most often `parts/` itself — or, without `--parts`, the rig directory has none while the directory above it does (build's layout, `<out>/rig` under `<out>/parts.json`). The detail says it: "--parts names the directory holding parts.json and parts/, not parts/ itself (after build, that is build's --out, whose rig is <out>/rig); without --parts it is --rig", and names the parent when the parent holds `parts.json`. With neither (no `--parts`, and no `parts.json` beside `rig.json` or above it), the rig is measured without parts and nothing is refused (§7) | re-run rig (`build` does both); for `…/parts.json`, `--parts` — the directory above `parts/` |
 | <a id="CHECK_SOURCE_SIZE"></a>`CHECK_SOURCE_SIZE` | the painting `--source` names is not this rig's: no single `rig_scale` takes its width and height to the stage's (assemble makes the canvas `trunc(w × rig_scale)` x `trunc(h × rig_scale)`), or, with `parts.json` read, its `scale_rig_per_source` does not; or the stage is not whole pixels. Refused before anything is built | the painting the rig was made from — the stage's own size, or the painting `assemble` was given |
 | <a id="CHECK_SOURCE_PNG"></a>`CHECK_SOURCE_PNG` | `--source` names a file that does not read as a PNG | a PNG |
+| <a id="CHECK_SETUP_MATCHES_PAINTING"></a>`CHECK_SETUP_MATCHES_PAINTING` | region, slot, failing-pixel box, slot pixelcount, complete region pixelcount and declared limit | compare the source painting beside the actual setup; follow [Source before scissors](#source-before-scissors), then rerun with the same authored limit |
+| <a id="CHECK_SETUP_PAINTING_SOURCE"></a>`CHECK_SETUP_PAINTING_SOURCE` | a declaration without a source painting | supply `--source`; the assembled composite is not an independent reference |
+| <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 |
 | <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 |
 | <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` |
 | <a id="CHECK_RIGC_ENTRY"></a><a id="CHECK_RIGC_ENTRY_READS"></a>`CHECK_RIGC_ENTRY`, `CHECK_RIGC_ENTRY_READS` | `rigc --version` names no entry (a rigc below 2.0.0), or names one in neither launcher form (`entry: cli.ts — @esotericsoftware/spine-core <v> present`, `entry: cli_core.ts — @esotericsoftware/spine-core absent — …`); `check.json`'s `rigc_entry` records the one that gated the build | `bun install` |
@@ -4987,6 +5077,8 @@ documents do not ship). Each is an input this package built; none is an author's
 | <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 |
 | <a id="REQUIREMENTS_SELF_TARGET"></a>`REQUIREMENTS_SELF_TARGET` | a `contact` whose `target` is its own `bone` and `point` (0 apart by construction), or an `aim` whose `target` is a point of the aimed bone itself — its tip lies on its own axis (0 degrees by construction), its origin gives no line at all (issue #540): a PASS would say nothing. Refused before anything is built, beside the file's other refusals; a bone's tip against its own origin is a contact like any other (it reads the bone's length), and a stage target is never one | a different bone (or a stage point, for an aim), or for a contact the bone's other point |
 | <a id="CHECK_REQUIREMENTS_FRAMES"></a>`CHECK_REQUIREMENTS_FRAMES` | a requirement render did not write every frame rigc sampled, or the as-declared, released and full renders of a follow sampled different frames | a rigc problem; report it |
+| <a id="CHECK_CUT_JOINT_MATERIAL"></a>`CHECK_CUT_JOINT_MATERIAL` | A declared `cut_material` source ray within reach needs more depth during its continuous bend interval than its final piece supplies; the message names part, joint, original opaque edge length, found and required material | follow [Source before scissors](#source-before-scissors); obtain source material past the joint, or explicitly declare the consumer's smaller required bend; no crop or under-piece repair |
+| <a id="CHECK_CUT_MATERIAL_MEASURED"></a>`CHECK_CUT_MATERIAL_MEASURED` | Original source evidence is missing, malformed or stale, a part/joint correspondence is unresolved, the inward axis disagrees, or no opaque crossing lies within reach | rerun `assemble --requirements <file>` or `build --requirements <file>` to bind original source readings to the actual emitted parts; correct an independently declared correspondence/reach; never infer original art from emitted siblings |
 | <a id="CHECK_REQUIREMENT_MET"></a>`CHECK_REQUIREMENT_MET` | a declared requirement measured outside its bar; the figure, its frame and the bar are quoted | the rig or its motion (§7, *Declared requirements*) — or the bar, if the scene asks less |
 | <a id="CHECK_REQUIREMENT_MEASURABLE"></a>`CHECK_REQUIREMENT_MEASURABLE` | a declared requirement is NOT MEASURABLE: what it asks is undefined in the frames, and the reason is quoted. Not a pass | the declaration (a bone with a length, a target off the bone's origin, a least drive the constraint reaches) or the rig |
 | <a id="REQUIREMENTS_MAY_FOLD"></a>`REQUIREMENTS_MAY_FOLD` | a `may_fold` entry names a slot with no mesh attachment — a region is one quad and cannot fold (issue #320). Refused before anything is built. Before issue #333 an entry naming the idle was refused here too; the bar reads the idle now, and `idle` is an animation name like any other | a mesh slot |
@@ -5118,6 +5210,7 @@ and stay absent).
 | <a id="RIG_TURN_SURFACE_OVERLAP_DEPTH"></a>`RIG_TURN_SURFACE_OVERLAP_DEPTH` | same-group overlap neighbours demand incompatible emitted offsets at one target setup point | separate the conflicting support or provide coincident neighbour fields; the refusal names the fields and target vertex |
 | <a id="RIG_TURN_SURFACE_MESH_BINDINGS"></a>`RIG_TURN_SURFACE_MESH_BINDINGS` | an authored surface mesh has unresolved/nonclosing weights or shares a frame moved by a unit/rear turn carrier; declared stop draw aliases resolve to their links for setup sampling | provide weighted bindings closing at 1 in the authored frame; `<link>_d` resolves only for links declared in `config.stops`; use independent chains for parts with different roles |
 | <a id="RIG_TURN_SURFACE_MESH_ATTACHMENT"></a>`RIG_TURN_SURFACE_MESH_ATTACHMENT` | a surface mesh has an alternate drawing without its own registered depth sampling frame | use the base attachment; explicit islands retain their own slot, attachment and bindings |
+| <a id="RIG_TURN_BODY_UNCOVERED"></a>`RIG_TURN_BODY_UNCOVERED` | **Warning:** a shown part without a body role overlaps a moved `turn.body` surface at setup alpha >= 128 and has different emitted endpoint displacement | declare the intended body role and inspect both endpoints; no role or depth is inferred |
 | <a id="RIG_TURN_SURFACE_DEPTH_REQUIRED"></a>`RIG_TURN_SURFACE_DEPTH_REQUIRED` | a part with role `"surface"` in `config.turn.roles` or `config.turn.body.roles` carries no depth sheet in `parts.json` | run `assemble` with `config.depth` or provide `<part>_depth.png` in `parts.json` |
 | <a id="RIG_TURN_GRID_BUDGET"></a>`RIG_TURN_GRID_BUDGET` | a `"surface"` grid exceeds 2,400 triangles on one slot or 4,000 triangles across all `"surface"` slots | lower `config.turn.grid` / `config.turn.body.grid` `[cols, rows]` within the per-slot and total budgets |
 | <a id="RIG_TURN_HEAD_BONE"></a>`RIG_TURN_HEAD_BONE` | `buildRig` found no `"head"` (or body turn root) bone when emitting 2.5D turn carriers | declare `"head"` (or the body turn root bone) in `config.bones` |
@@ -5548,6 +5641,7 @@ Under `--source <painting.png>`, a second reported line, also never a FAIL
 | line | reports | bar | `reference-demo` | `reference-sample` | SKIP when |
 | --- | --- | --- | --- | --- | --- |
 | <a id="SETUP_POSE_VS_SOURCE"></a>`SETUP_POSE_VS_SOURCE` | the setup pose against the painting, by `assemble`'s own `measureRecomposite` over the stage's pixels — `mean_abs` and `within_share` (mean channel, within 8), `error_px` (max channel over 40), `uncovered_error_px` (of those, where the pose has alpha 128 or less), `hole_count` and the largest hole's box — with `painting_px`, `stage_px`, `render_px` and `render_scale` beside them. The painting is resampled onto the stage as assemble resamples it (lanczos3, alpha dropped). rigc renders onto an opaque grey, so the pose over white and its alpha are read off a second still of the same pose with every slot tinted black; both are carried onto the stage with the seam's map turned round (bilinear) | none — status `REPORTED`; assemble applies no bar to the figures it measures, so none is derived here | 3.146 / 93.43 % / 12,399 / 1,732, 518 holes, the largest 61 px at 351,157 6x20 (assemble's recomposite: 2.391 / 95.81 % / 11,050 / 1,564, 453) | 1.095 / 97.30 % / 5,348 / 1,239, 313 holes, the largest 88 px at 479,416 6x29 (assemble's: 0.835 / 97.95 % / 4,512 / 1,185, 259) | not written without `--source` |
+| <a id="SETUP_MATCHES_PAINTING"></a>`SETUP_MATCHES_PAINTING` | declared region count, native box, limit and actual top contributor rows | PASS/FAIL against authored limits; no limit is SKIP; undeclared regions are not judged |
 
 The figures are assemble's by construction, not a second definition beside them;
 what differs is what they are taken of — the pose rigc draws, not the flat stack —
@@ -6020,6 +6114,132 @@ on a bone of length 0 are NOT MEASURABLE and the run is not PASS (`CK68`–`CK79
 frame the slide peaks; a seam on a rig with no `parts.json` is refused before anything
 is built (`CK83`–`CK85`, `RQ30`–`RQ35`).
 
+### Art joints on a fixed skeleton
+
+When art is fitted to a skeleton whose setup must stay fixed, declare
+`fixed_skeleton` in the existing `--requirements` file (issue #880):
+
+```json
+{
+  "spec": "spine-parts-requirements/1",
+  "fps": 12,
+  "requirements": [],
+  "fixed_skeleton": {
+    "source": "independent joint measurements on the fitted art",
+    "within_px": 4,
+    "joints": [
+      { "name": "shoulder", "bone": "upper_arm", "at": [26, 57] }
+    ]
+  }
+}
+```
+
+The block explicitly identifies this as a fixed-skeleton comparison; a generation
+control pose does not. `source` is required nonempty provenance text, recorded
+without interpretation. Each `at` is an independently measured point on the art
+**as placed on the rig's stage**, in stage pixels from its top-left, x right and y
+down, the same space as a requirement's `target.stage`. Convert painting/source
+coordinates through the actual placement before declaring them: raw source pixels,
+bone-local offsets and normalized coordinates are not stage pixels. Each nonempty
+`name` is unique and each `bone` explicitly names its matching bone origin in
+`rig.json`. No anatomical names, hidden joints, correspondences or positions are
+inferred; only the listed measurements are covered. An unmeasured joint must not
+be supplied as the bone's own position.
+
+`check` uses the existing setup-still renderer, requesting `--geometry`, and reads
+`geometry.json`'s `setup.bones` through its existing geometry reader. It converts
+the renderer's setup-world origin to stage pixels through the coordinate door;
+it never substitutes an animation's first frame or a bone's parent-local `x,y`.
+This also works for an external `rig.json` with no `parts.json` or idle. The
+Euclidean distance, art point and setup origin are printed **for every declared
+joint** and written to `check.json`'s `ART_JOINT_DISTANCE`, along with `source`,
+`instrument` and `within_px`. This is a setup-placement check, not a motion check
+or automatic detection of joints in an image.
+
+`within_px` is optional and, when present, must be finite and nonnegative. The
+example's `4` is an authored demonstration, not a calibrated or default tolerance.
+Distance **greater than** the declared limit fails; equality passes. Without a
+limit, the block and every joint are **SKIP**, with the measured distances and
+`within_px: null`; this line is excluded from measured bars and contributes no
+PASS. Other independent checks may still pass. With no `fixed_skeleton` block,
+this measurement adds no output or render call. `fps` and `requirements` remain
+required by the enclosing file; they do not change this setup measurement.
+
+| rule | change |
+| --- | --- |
+| <a id="CHECK_ART_JOINT_DISTANCE"></a>`CHECK_ART_JOINT_DISTANCE` | The named joint is farther from its setup bone origin than `fixed_skeleton.within_px`; the message gives distance and limit. Correct a wrong art measurement or bone correspondence, or supply art aligned to the fixed skeleton. Choose any changed limit explicitly from the consumer's requirement; bones and art are never moved by this check. |
+| <a id="CHECK_ART_JOINT_MEASURED"></a>`CHECK_ART_JOINT_MEASURED` | Supply a finite renderer setup origin and a finite measurable distance; missing geometry is never taken as zero. The existing `CHECK_GEOMETRY_FILE` refusal names missing/malformed geometry. |
+
+`REQUIREMENTS_FIELD` and `REQUIREMENTS_RESOLVES` cover malformed declarations:
+supply nonempty provenance and a nonempty joint list, unique joint names, finite
+`[x, y]` points, known bone names and an explicit valid limit or omit the limit.
+Unknown fields are refused.
+
+| line | measures | bar | SKIP |
+| --- | --- | --- | --- |
+| <a id="CUT_JOINT_MATERIAL"></a>`CUT_JOINT_MATERIAL` | Original source edge intervals versus final opaque pixel-cell material over each explicit `cut_material` joint reach and continuous bend interval; full two-coordinate swept-segment coverage plus contiguous normal support | every required source interval has material through its inverse-rotation sweep; a hole between diagnostic rays also fails | no declaration: API SKIP, unchanged CLI stdout, no JSON key or counted bar; missing/stale source evidence or no crossing within reach: named unavailable refusal |
+| <a id="ART_JOINT_DISTANCE"></a>`ART_JOINT_DISTANCE` | Each independently measured art joint versus its explicitly named bone's renderer setup origin, in stage pixels; printed and recorded per joint | distance <= the declared `fixed_skeleton.within_px`, with no rounding slack | no limit declared: every row and the block retain their distances as SKIP, never a pass; no declaration: no line |
+
+### Setup against the painting
+
+`check --source <painting> --requirements <file>` can declare
+`setup_painting` in the existing `spine-parts-requirements/1` file:
+
+```json
+{
+  "spec": "spine-parts-requirements/1",
+  "fps": 12,
+  "requirements": [],
+  "setup_painting": {
+    "rgb_tolerance": 60,
+    "regions": [
+      { "name": "torso", "box": [10, 20, 40, 60], "max_pixels": 0 }
+    ]
+  }
+}
+```
+
+These are authored limits, not defaults or calibrated figures. A region's
+`box` is `[x, y, width, height]` in the declared stage's native pixel grid,
+x right and y down, with exclusive far edges. Regions must fit the stage.
+`rgb_tolerance` is an integer from 0 through 255. Count a pixel once when its
+maximum absolute RGB-channel difference is **strictly greater** than that
+value. The region passes when its total count is at most its authored
+nonnegative integer `max_pixels`. Without that limit the region reports
+**SKIP**, including a zero-count region. An undeclared region has no verdict.
+Without `setup_painting`, existing output bytes and rendering remain unchanged.
+
+The observation is the actual renderer's setup pose, without animation or
+physics advancement, from the already gated setup candidate. Its viewport is
+the declared stage, scale 1; no fitted alignment or flat part composite is
+substituted. Source PNG readers preserve straight RGBA. This optional check
+first composites the painting over opaque white at its **original source
+resolution**, rounding each RGB channel to RGBA8, then passes that opaque
+image through the existing `sourceInRig` Lanczos3 resampling onto the stage.
+The rendered setup is composited over white on the native stage grid. This
+ordering excludes hidden RGB from both resampling taps and figure detection;
+the global `sourceInRig` and legacy checks retain their existing RGB semantics.
+The figure domain is the union of rendered
+alpha above zero and the painting's existing `figureSilhouette`: border-median
+background difference, morphological opening and hole filling. This includes
+missing output over source figure and extra rendered support. It is not an
+independent segmentation oracle for arbitrary backgrounds.
+
+`SETUP_MATCHES_PAINTING` reports each region's box, pixel count and limit.
+Diagnostic slot rows partition that count and report their failing-pixel box.
+The slot is the **last actual textured drawing with sampled alpha above zero**
+at that pixel, measured by rig-c's rasterizer, or explicit `(uncovered)`.
+For translucent stacks this names the top contributor, not the exclusive
+material owner or the cause of the difference. Overlapping region declarations
+are measured independently. Clipped drawings whose ownership cannot be observed
+are refused rather than attributed by a part's bounding box.
+
+Invalid limits, repeated names, unknown fields and out-of-stage boxes use the existing `REQUIREMENTS_FIELD` refusal; no value is guessed.
+
+This optional declaration is independent of motion requirements and
+`fixed_skeleton`; it does not replace their schemas or validation. The named
+refusals are in the check/build rule table and the observation in the line table.
+
 ## 8. What one character costs
 
 | step | reference-sample | reference-demo | source |
@@ -6324,6 +6544,26 @@ art. An authored `parts.json` depth reference remains an active standalone
 guards still apply. With binding inactive there is no added reference, file or
 legacy-byte change. #773 adds no image generation, geometry or motion model.
 
+### Missing body-turn coverage
+
+`RIG_TURN_BODY_UNCOVERED` warns when a shown part without a
+`turn.body.roles` entry overlaps a moved body surface. It names both parts,
+both endpoint times, their actual emitted displacement vectors and the maximum
+relative displacement at a setup painting-pixel centre. Both drawings require
+alpha >= 128 and actual covering setup triangles; bounding boxes and transparent
+pixels alone do not count. Excluded alpha does not count. The diagnostic reads
+positive bindings in the declared torso subtree, excluding head/neck subtrees.
+Explicit body roles and bindings wholly inheriting an emitted body-turn carrier
+count as declared coverage; identical inherited motion needs no second role. Differences no larger than the producer's six-place
+encoding unit (0.000001 rig px) are ignored. This is a warning about a missing
+declaration, not an automatic seam verdict or a rule for limb crossings.
+
+Warnings belong to the stage report only. They add no rig, motion or PNG field
+and never assign a role, depth, binding or draw order. A part already bound to
+`chest` does not inherit a weighted topwear surface's per-vertex deform. Declare
+its actual intended role, then inspect setup, both turn endpoints and their diff;
+an explicit role alone does not establish that two drawings remain coincident.
+
 ### Unit depth precedence
 
 For `"unit"` roles, a transported part's sheet is recorded and validated but is not

package/docs/STABILITY.md

@@ -54,7 +54,7 @@ defaults are the help's too, and none is guessed from the art.
 | `inputs` | `--source`, `--config`, `--out` |
 | `comfy` | `paint`: `--config`, `--out`; optional `--seeds`, `--seed0`, `--host`, `--wait`, `--timeout`, `--poll` |
 | `comfy` | `seethrough`: `--image`, `--out`; optional `--resolution`, `--steps`, `--seed`, `--prefix`, `--offload`, `--no-offload`, `--lama`, `--nf4`, `--host`, `--wait`, `--timeout`, `--poll`, `--config` (See-through settings and optional depth block), `--depth-run` (`full` or `head`, required with the block) |
-| `assemble` | `--propose-plan` with `--source`, `--full`, `--config`, optional `--head`, `--write-config` (must name `--config` itself, issue #356); or `--source`, `--full`, `--config`, `--out`, optional `--head` (without it, one run: issue #359), `--seam` (near-white, silhouette), `--project` (core, visible), `--alt` (repeatable `<name>=<source>:<full>[:<head>]`, issue #454) |
+| `assemble` | `--propose-plan` with `--source`, `--full`, `--config`, optional `--head`, `--write-config` (must name `--config` itself, issue #356); or `--source`, `--full`, `--config`, `--out`, optional `--head` (without it, one run: issue #359), `--seam` (near-white, silhouette), `--project` (core, visible), `--alt` (repeatable `<name>=<source>:<full>[:<head>]`, issue #454), `--requirements` (source-bound cut-material evidence only when the file declares `cut_material`, issue #888) |
 | `propose` | `--head-box` with `--full`, `--canvas`; optional `--no-back-hair`, `--write-config` (existing config, issue #356) |
 | `propose` | `--parts`, `--source`, `--out`; optional `--compare` or `--from-config` (one of them), `--keypoints`, `--person` and `--wrist-snap` (each with `--keypoints`), `--full`, `--head` (the turn control's depths; not with `--from-config`), `--grid-rule` (`figure` or `part`, the drafted lattice's spacing; not with `--from-config`), `--cloth` (a config whose `cloth` block is the recipe, issue #364; not with `--from-config`), `--write-config` (existing config for an ordinary proposal, issue #356; a new file with `--cloth`, issue #537; not with `--from-config` — additive: without it nothing `propose` writes changes), `--from` (the config the recipe is changed from, only with `--write-config`, issue #571 — additive: without it nothing `--write-config` writes changes), `--only-missing` (only with `--parts` and `--write-config`, not with `--cloth` or `--from-config`, issue #671 — additive: without it nothing `--write-config` writes changes) |
 | `propose` | `--parts`, `--source`, `--out`, `--full`, `--head`, `--write-config` together: the [neck draft](AUTHORING.md#a-neck-that-moves-on-its-own) for an existing config with `turn.body` and one neck plan row; reassembles under `<out>/rig`, preserves the sampled turn and drafts a rigid neck unit (issue #826) |
@@ -491,6 +491,37 @@ inverse-bind deform offsets in motion, without adding a Core attachment depth
 field. Head yaw/pitch and independent body yaw use their existing turn groups.
 Blended surfaces retain the documented per-group masks and setup-overlap
 neighbour field rules in [AUTHORING](AUTHORING.md#per-layer-depth-sheets-773).
+`RIG_TURN_BODY_UNCOVERED` is a report-only warning for a shown torso part
+without a body role that has opaque setup-triangle overlap with a moved body
+surface and different emitted endpoint displacement. It names the part, surface,
+times, vectors and relative travel. Head/neck bindings, transparent/excluded
+alpha, explicit/inherited body roles and identical inherited motion are excluded as
+described in [AUTHORING](AUTHORING.md#missing-body-turn-coverage). It assigns
+no role or depth and changes no emitted file bytes.
 The unit-depth precedence and its primary-surface sampling are documented in
 [AUTHORING](AUTHORING.md#unit-depth-precedence).
 The separate ordering scalar is unchanged. No-image outputs retain legacy bytes.
+
+### Declared setup-painting regions
+
+The optional `setup_painting` key in `spine-parts-requirements/1` adds a
+`SETUP_MATCHES_PAINTING` observation only when declared. It requires authored
+`rgb_tolerance` and named native-stage boxes. Each optional `max_pixels` is
+that whole region's limit; omission is SKIP, never PASS. Existing files without
+the key retain their output bytes and renderer calls. Other requirement fields
+remain independent. The [authoring contract](AUTHORING.md#setup-against-the-painting)
+defines white compositing, the figure domain, strict RGB comparison, top
+contributor attribution and named measurement refusals. The check observes the
+actual renderer setup at scale 1; it neither fits the art nor duplicates core
+validation. Only this declared check composites source RGBA over white at its
+original resolution **before** existing Lanczos3 stage resampling. Setup RGBA
+is composited on the native stage grid. Source readers preserve alpha; the
+global RGB-only source helper and checks without this declaration are unchanged.
+
+The optional `cut_material` block in `--requirements` declares a part, joint,
+independent stage-pixel centre, inward axis, reach and continuous bend interval.
+`assemble --requirements` and `build --requirements` write source-edge evidence
+only for that explicit block; `check --requirements` refuses unavailable or
+stale evidence rather than reconstructing original art from emitted siblings.
+Without the block the API reading is SKIP; CLI stdout and emitted bytes remain unchanged.
+See [Source before scissors](AUTHORING.md#source-before-scissors).

package/package.json

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

package/src/artjoints.ts

@@ -0,0 +1,94 @@
+/** Explicit art-joint measurements on a fixed skeleton (issue #880). */
+import { refuseIfAny, type Problem } from './errors.ts';
+import { cropToSpineY } from './coords.ts';
+import { edgeLength } from './length.ts';
+
+export interface ArtJoint {
+  name: string;
+  bone: string;
+  /** Measured art point in stage pixels, x right and y down. */
+  at: [number, number];
+}
+export interface FixedSkeleton {
+  /** Where the independent art measurements came from; never interpreted. */
+  source: string;
+  joints: ArtJoint[];
+  /** Maximum Euclidean distance in stage pixels. Absent means measurement only. */
+  within_px?: number;
+}
+const object = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+const finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);
+const free = (k: string, v: unknown): boolean => (k.startsWith('x-') && k.length > 2) || ((k === 'note' || k.endsWith('_note')) && typeof v === 'string');
+
+/** Validate without deriving any art point, bone correspondence or limit. */
+export function fixedSkeletonProblems(value: unknown, at: string): Problem[] {
+  const problems: Problem[] = [];
+  const fail = (where: string, detail: string): void => { problems.push({ code: 'REQUIREMENTS_FIELD', object: where, detail }); };
+  const keys = (v: Record<string, unknown>, allowed: string[], where: string): void => {
+    for (const k of Object.keys(v)) if (!allowed.includes(k) && !free(k, v[k])) fail(`${where}.${k}`, `is unknown; fields are ${allowed.join(', ')}`);
+  };
+  if (!object(value)) return [{ code: 'REQUIREMENTS_FIELD', object: at, detail: 'requires {source, joints, within_px?}; omit fixed_skeleton for a rig without this declaration' }];
+  keys(value, ['source', 'joints', 'within_px'], at);
+  if (typeof value.source !== 'string' || value.source.trim() === '') fail(`${at}.source`, 'requires the provenance of the independent art-joint measurements as nonempty text');
+  if ('within_px' in value && (!finite(value.within_px) || value.within_px < 0)) fail(`${at}.within_px`, `is ${JSON.stringify(value.within_px)}; a finite nonnegative stage-pixel limit is required, or omit it for a SKIP-class measurement`);
+  if (!Array.isArray(value.joints) || value.joints.length === 0) fail(`${at}.joints`, 'requires a nonempty list of {name, bone, at: [x, y]} measured on the art in stage pixels (x right, y down)');
+  else {
+    const seen = new Set<string>();
+    value.joints.forEach((joint, i) => {
+      const where = `${at}.joints[${i}]`;
+      if (!object(joint)) { fail(where, 'requires {name, bone, at: [x, y]}'); return; }
+      keys(joint, ['name', 'bone', 'at'], where);
+      for (const k of ['name', 'bone']) if (typeof joint[k] !== 'string' || joint[k].trim() === '') fail(`${where}.${k}`, 'requires a nonempty name');
+      if (typeof joint.name === 'string') {
+        if (seen.has(joint.name)) fail(`${where}.name`, `declares joint "${joint.name}" twice; each measured joint is declared once`);
+        seen.add(joint.name);
+      }
+      if (!Array.isArray(joint.at) || joint.at.length !== 2 || !joint.at.every(finite)) fail(`${where}.at`, 'requires a finite [x, y] measured on the art in stage pixels (x right, y down)');
+    });
+  }
+  return problems;
+}
+
+export const ART_JOINT_LINE = 'ART_JOINT_DISTANCE';
+export interface ArtJointRow extends ArtJoint {
+  /** Bone origin in the same stage-pixel space as at. */
+  bone_at: [number, number];
+  distance_px: number;
+  status: 'PASS' | 'FAIL' | 'SKIP';
+}
+export interface ArtJointLine {
+  status: 'PASS' | 'FAIL' | 'SKIP';
+  instrument: 'rigc-geometry/1 setup.bones';
+  source: string;
+  within_px: number | null;
+  joints: ArtJointRow[];
+  reason?: string;
+}
+
+/** Compare independent art points to renderer setup origins, never animation frame zero. */
+export function artJointLine(
+  fixed: FixedSkeleton,
+  stage: { x: number; y: number; height: number },
+  setup: (bone: string) => { worldX: number; worldY: number },
+  problems: Problem[],
+): ArtJointLine {
+  refuseIfAny(fixedSkeletonProblems(fixed, 'fixed_skeleton'));
+  const limit = fixed.within_px;
+  const joints = fixed.joints.map<ArtJointRow>(j => {
+    const world = setup(j.bone);
+    if (!Number.isFinite(world.worldX) || !Number.isFinite(world.worldY)) refuseIfAny([{ code: 'CHECK_ART_JOINT_MEASURED', object: `joint "${j.name}" (bone "${j.bone}")`, detail: 'has no finite renderer setup origin; a missing position is never a zero distance' }]);
+    const boneAt: [number, number] = [world.worldX - stage.x, cropToSpineY(world.worldY - stage.y, stage.height)];
+    const distance = edgeLength(j.at[0] - boneAt[0], j.at[1] - boneAt[1]);
+    if (!Number.isFinite(distance)) refuseIfAny([{ code: 'CHECK_ART_JOINT_MEASURED', object: `joint "${j.name}" (bone "${j.bone}")`, detail: 'has no finite art-to-setup distance; finite stage-pixel coordinates are required' }]);
+    const status = limit === undefined ? 'SKIP' : distance > limit ? 'FAIL' : 'PASS';
+    if (status === 'FAIL') problems.push({ code: 'CHECK_ART_JOINT_DISTANCE', object: `joint "${j.name}" (bone "${j.bone}")`, detail: `art at [${j.at.join(', ')}] is ${distance} stage px from setup origin [${boneAt.join(', ')}]; distance <= declared fixed_skeleton.within_px ${limit} px is required — correct the art measurement/correspondence if wrong, or supply art aligned to the fixed skeleton; bones are not moved` });
+    return { name: j.name, bone: j.bone, at: [...j.at] as [number, number], bone_at: boneAt, distance_px: distance, status };
+  });
+  return { status: limit === undefined ? 'SKIP' : joints.some(j => j.status === 'FAIL') ? 'FAIL' : 'PASS', instrument: 'rigc-geometry/1 setup.bones', source: fixed.source, within_px: limit ?? null, joints,
+    ...(limit === undefined ? { reason: 'fixed_skeleton.within_px is absent; distances are measured, no limit is invented and no joint passes' } : {}) };
+}
+
+export function artJointLines(line: ArtJointLine): string[] {
+  return [`${ART_JOINT_LINE}: ${line.status}${line.reason === undefined ? '' : ` — ${line.reason}`}; source ${JSON.stringify(line.source)}; ${line.instrument}`,
+    ...line.joints.map(j => `${ART_JOINT_LINE}: joint "${j.name}" (bone "${j.bone}") ${j.status} — art [${j.at.join(', ')}], setup [${j.bone_at.join(', ')}], distance ${j.distance_px} px; ${line.within_px === null ? 'no declared limit (SKIP)' : `limit <= ${line.within_px} px`}`)];
+}

package/src/assemble.ts

@@ -1,3 +1,5 @@
+import { edgeLength } from './length.ts';
+import { materialSource, type MaterialSource, materialRows, polygonMaterialEdges, type MaterialRow, type MaterialEdge, type PlacedArt } from './cutmaterial.ts';
 import { unionTakenSources } from './takesource.ts';
 import { authoredUnitDepths, type AuthoredUnitDepth } from './authoredunit.ts';
 import { paintingExtensionMasks, paintingExtensionProblems, type PaintingExtension } from './paintingextension.ts';
@@ -3934,10 +3936,10 @@ function cutLimbs(
   readHidden: (layer: string, by: string) => void = () => undefined,
   tips?: Record<string, [number, number]>,
   sourceGroups: ReadonlyMap<string, string> = new Map(),
-): { parts: LimbPart[]; pieces: Built[]; counts: LimbCount[]; capFrom: Array<CapFrom | null> } {
+): { parts: LimbPart[]; pieces: Built[]; counts: LimbCount[]; capFrom: Array<CapFrom | null>; material: MaterialRow[]; sources: MaterialSource[] } {
   const logical = (source: string): string => sourceGroups.get(source) ?? source;
   const names = Object.keys(limbs);
-  if (names.length === 0) return { parts: [], pieces: [], counts: [], capFrom: [] };
+  if (names.length === 0) return { parts: [], pieces: [], counts: [], capFrom: [], material: [], sources: [] };
   const problems: Problem[] = [];
   const places = bonePlaces(bones, tips);
   const parts: LimbPart[] = [];
@@ -4413,7 +4415,30 @@ function cutLimbs(
     });
   }
   refuseIfAny(problems);
-  return { parts, pieces: pieces as Built[], counts, capFrom };
+  const material: MaterialRow[] = [];
+  const sourceReadings: MaterialSource[] = [];
+  for (const l of names) limbs[l].segments.forEach((sg, k) => {
+    if (k === 0) return;
+    const line = (lines.get(l) as Array<JointLine | null>)[k];
+    if (line === null) return;
+    const lo = parts.findIndex(p => p.part === sg.part);
+    const source = [...new Set([limbs[l].segments[k - 1].from, sg.from])].flatMap(name => {
+      const b = builtOf(name);
+      if (b === null) return [];
+      // Match segmentation and cap source ownership, after crossing/hand reassignment.
+      // Evidence must never borrow another limb's island or mutate its source raster.
+      const image = { ...b.r, data: b.r.data.slice() };
+      const owned = owners.get(name), li = names.indexOf(l);
+      for (let p = 0; p < W * H; p++) if (owned?.[p] !== li) image.data.fill(0, p * 4, p * 4 + 4);
+      return [{ x: 0, y: 0, image }];
+    });
+    const own = [lo, ...(sg.hybrid === undefined ? [] : [parts.findIndex(p => p.part === sg.hybrid?.part)])].filter(i => i >= 0).map(i => ({ x: 0, y: 0, image: (pieces[i] as Built).r }));
+    const t: [number, number] = [-line.axis[1], line.axis[0]], r = edgeLength(W, H);
+    const edge: MaterialEdge = { a: [line.at[0] - r * t[0], line.at[1] - r * t[1]], b: [line.at[0] + r * t[0], line.at[1] + r * t[1]], inward: line.axis };
+    sourceReadings.push(materialSource(sg.part, [...new Set([limbs[l].segments[k - 1].from, sg.from])], [edge], source));
+    material.push(...materialRows(sg.part, undefined, [edge], source, own).map(row => ({ ...row, joint: String(sg.joint) })));
+  });
+  return { parts, pieces: pieces as Built[], counts, capFrom, material, sources: sourceReadings };
 }
 
 // ---------------------------------------------------------------------------
@@ -4470,6 +4495,9 @@ export interface AssembleResult {
   figures: RecompositeFigures;
   /** What each `assemble.cuts` entry took, counted when it was made (`cutLines`); empty without cuts. */
   cuts: CutCount[];
+  /** Console-only source-edge support (#888); never serialized into parts.json. */
+  cutMaterial: MaterialRow[];
+  materialSources: MaterialSource[];
   /** What each `config.limbs` limb cut, per part it took and per joint (`limbLines`); empty without limbs (issue #349). */
   limbs: LimbCount[];
   /** The full-run layers the plan does not take from the full run whose uncovered error holds a body (`uncoveredErrorLayers`); empty otherwise. */
@@ -5016,11 +5044,14 @@ export function assemble(input: AssembleInput): AssembleResult {
   const mergedIn = (b: Built, region: Mask): number => count(b.trace.lastSel ?? null, region) + count(b.trace.lastRing ?? null, region);
   const pieces: Array<Built | null> = cuts.map(() => null);
   const cutCounts: CutCount[] = [];
+  const cutMaterial: MaterialRow[] = [];
+  const materialSources: MaterialSource[] = [];
   plan.forEach(([name], pi) => {
     const mine = cuts.map((q, i) => i).filter((i) => cuts[i].from === name);
     const b = built[pi];
     if (mine.length === 0 || b === null) return;
     const before = opaqueOf(b.r);
+    const sourceBeforeCuts: PlacedArt = { x: 0, y: 0, image: { ...b.r, data: b.r.data.slice() } };
     const rest = newMask(W, H);
     rest.data.fill(1);
     // The base's own pixels: `rest`, and every cut's band, which it keeps as well as the piece.
@@ -5120,6 +5151,8 @@ export function assemble(input: AssembleInput): AssembleResult {
         if (cuts[i].under_fill === 'colour') c.underFill = 'colour';
       }
       cutCounts.push(c);
+      const piece = pieces[i];
+      if (piece !== null) { materialSources.push(materialSource(cuts[i].into, [b.key], polygonMaterialEdges(cuts[i].polygon), [sourceBeforeCuts])); cutMaterial.push(...materialRows(cuts[i].into, undefined, polygonMaterialEdges(cuts[i].polygon), [sourceBeforeCuts], [{ x: 0, y: 0, image: piece.r }])); }
     });
   });
   // Parent partition counts and under use the removed parent art above. Only
@@ -5131,6 +5164,10 @@ export function assemble(input: AssembleInput): AssembleResult {
     if (opaqueOf(r) === 0) empty.push({ code: 'ASSEMBLE_CUT_PIXELS', object: `config.assemble.cuts[${i}] (part "${cuts[i].into}")`, detail: `takes 0 opaque pixels from selected ${source.key}; draw its polygon over that layer's art` });
     const writers = (source.writers as Int32Array).slice();
     pieces[i] = { ...source, r, writers, region: m, merged: mergedIn(source, m) };
+    for (let j = materialSources.length - 1; j >= 0; j--) if (materialSources[j].part === cuts[i].into) materialSources.splice(j, 1);
+    materialSources.push(materialSource(cuts[i].into, [source.key], polygonMaterialEdges(cuts[i].polygon), [{ x: 0, y: 0, image: source.r }]));
+    for (let j = cutMaterial.length - 1; j >= 0; j--) if (cutMaterial[j].part === cuts[i].into) cutMaterial.splice(j, 1);
+    cutMaterial.push(...materialRows(cuts[i].into, undefined, polygonMaterialEdges(cuts[i].polygon), [{ x: 0, y: 0, image: source.r }], [{ x: 0, y: 0, image: r }]));
   });
   refuseIfAny(empty);
   // In cut order, as the config lists them.
@@ -5638,6 +5675,8 @@ export function assemble(input: AssembleInput): AssembleResult {
     figure: inside === null ? null : figureImage(inside, W, H),
     figures,
     cuts: cutCounts,
+    cutMaterial: [...cutMaterial, ...lim.material],
+    materialSources: [...materialSources, ...lim.sources],
     limbs: lim.counts,
     uncovered,
     holeKinds: kinds,