rig-parts 1.60.0 → 1.60.1

package/NOTICE.md

@@ -119,7 +119,7 @@ redistributed.
   `allowDifferentLicense: false`: generated images may be used commercially and
   the model must be credited, which this line does.
 
-The [parts-examples](https://github.com/rig-c/parts-examples) README records
+The [rig-c/examples](https://github.com/rig-c/examples) README records
 both, beside each character's generation record.
 
 ### Models named by the optional painting graph

package/README.md

@@ -30,7 +30,7 @@ The painting was generated for this repository with a public checkpoint (Hassaku
 (Illustrious) v1.3 Style A, by Ikena, Fair AI Public License 1.0-SD) and no LoRA, on a
 pose that holds the hands apart, then given one hand-detailer pass; its generation
 record, See-through layers and licence are in
-<a href="https://github.com/rig-c/parts-examples">parts-examples</a>.
+<a href="https://github.com/rig-c/examples">rig-c/examples</a>.
 See-through ran twice, once on the whole figure and once on a square head crop.
 Then one command: <code>rig-parts build --loop --lead-in 3</code>. The proposer's bones, meshes,
 regions and motion were used as proposed but for one correction, written in the
@@ -209,7 +209,7 @@ head run on `st_input_head.png` is what gives the eyes more pixels
 four, and `rig-parts comfy` is only a convenience for that route: every
 stage after See-through reads files, whichever route wrote them. On the two
 reference examples each run took 171–199 s through the wrapper, and on the demo 179 s (each run's
-`meta.json`, in [parts-examples](https://github.com/rig-c/parts-examples)).
+`meta.json`, in [rig-c/examples](https://github.com/rig-c/examples)).
 
 ### The two images See-through is fed: `inputs`
 

package/cli.ts

@@ -660,7 +660,15 @@ usage:
       the default (AUTHORING §6, The world the readings are taken in). One
       environment: line names the path, the step count and the sha256's first
       16 hex; check.json's environment holds path (as given), sha256 and
-      steps. Without the flag no key and no render argument moves.
+      steps. Without the flag no environment provenance key is written.
+      Physics rigs with readable declared seam pairs also report independent
+      default wind [1, 0] and still wind [0, 0], gravity [0, 1], under
+      SEAM_OVER_MOTION.worlds: gap/ghost maximum and worst frame only;
+      dir points to retained raw seam renders relative to check.json. No
+      new bar or warning, and the custom reading is unchanged. No wind
+      response or no band is SKIP; no pair or animation gives no worlds.
+      Nonphysics output is unchanged. In rig-play environment(null) returns
+      to the default world, not still air (AUTHORING, Physics seam environments).
 
   rig-parts loop --frames <dir> --out <file.png | file.gif> [--palette]
       Encode a frame set rigc render wrote (its --out directory, or the set

package/docs/AUTHORING.md

@@ -3896,7 +3896,7 @@ measured). `build --loop` encodes a product and takes none. One line,
 `environment: <path>, rigc-environment/1, <n> step(s), sha256 <16 hex>`, says which
 schedule, and `check.json` carries `environment` — `path` as the command line gave it,
 the `sha256` of the bytes read, `steps` — after `pack_mode`; without the flag neither
-is written and no render argument moves.
+is written; the physics seam reference worlds below are separate probes.
 
 The world before the first step is the runtime's, so a still schedule is the one that
 states it: `{ "t": 0, "wind": [1, 0], "gravity": [0, 1] }` reads what a run without the
@@ -3908,6 +3908,8 @@ wind (1, 0), then (40, 0) from 0.5 s, reads `TEXTURE_STRETCH` 32.181 (FAIL, `hai
 triangle 258), two meshes folding under `ANIMATIONS_DO_NOT_FOLD` (FAIL; none without the
 flag) and 8 `CLOTH_SETTLES` warnings for 9 (selftest `CK515`).
 
+**Physics seam environments** (issue #591). Default: wind [1, 0], gravity [0, 1]. Still: wind [0, 0], gravity [0, 1]. In rig-play, environment(null) returns to Default; still air requires an explicit wind [0, 0]. For a physics rig with readable declared pairs and animations, SEAM_OVER_MOTION adds optional `worlds.default` and `worlds.still` readings. They are informational raw gap/ghost cell counts (including cells below the warning floor), never new bars or warnings; neither changes PASS, exit status or the bar count. Each world records its vectors, status and rows; each row names its pair, animation, drawn/banded frames and gap/ghost maximum and worst frame, cell size and world box. Per-frame hits are not embedded in check.json. A rendered world's `dir` is relative to check.json (`seam_motion/default` or `seam_motion/still`): it retains the complete rigc render, including frames.json, frame images and each animation's seam.json with all raw hits. The directories are published with check.json only after the readings are validated; scratch is removed, and an unrendered SKIP has no directory reference. The original reading and any custom `--environment` schedule keep their existing meaning; the two reference worlds are independent of that schedule. A rig with no wind response reports Still as SKIP with its reason; no band is SKIP, never a measured zero. With no readable declared pair or animation no worlds block is written. Only existing declared pairs are read: neighbouring limb segments and explicit seam requirements; thigh/hem pairs are not inferred. Nonphysics output stays byte-identical, with no extra key, line or render. Reference renders start physics at frame 0 at 12 fps; they do not certify a composed player scene or another sampling rate. Malformed sidecars or renderer failures remain named refusals.
+
 ### compose
 
 Every refusal below is collected with the others and printed at once, under
@@ -4756,7 +4758,7 @@ is built (`CK83`–`CK85`, `RQ30`–`RQ35`).
 
 | step | reference-sample | reference-demo | source |
 | --- | --- | --- | --- |
-| painting (GPU) | 20.2 s | 18.3 s | `generation.json` `elapsed_s`, in [parts-examples](https://github.com/rig-c/parts-examples) |
+| painting (GPU) | 20.2 s | 18.3 s | `generation.json` `elapsed_s`, in [rig-c/examples](https://github.com/rig-c/examples) |
 | See-through full run (GPU) | 194.9 s | 198.5 s | `inputs/layers/full/meta.json` `elapsed_s` |
 | See-through head run (GPU) | 170.9 s | 171.4 s | `inputs/layers/head/meta.json` `elapsed_s` |
 | `build` (CPU, user + sys) | 14.6 s | 30.7 s | measured with `/usr/bin/time -p` on an Apple M4 machine under other load, rigc's child processes included; wall clock 12.7 s and 27.5 s |

package/docs/PAINTING.md

@@ -140,7 +140,7 @@ one way that passes `painting`: the `generation` block and the pose file of seed
 and chosen to be the next public example — a character for a wind demo, where hair
 and cloth move by physics under a side gust. It is the public example `wind`: its
 painting, See-through layers and generation record are in
-[parts-examples](https://github.com/rig-c/parts-examples) (`wind/`), and its config,
+[rig-c/examples](https://github.com/rig-c/examples) (`wind/`), and its config,
 proposal and build are [`examples/wind`](../examples/wind/README.md). The block:
 
 ```json
@@ -350,4 +350,4 @@ To paint one without the character drifting, repaint only the limb:
 
 `comfy paint` does not run an inpainting graph; the demo's hand-detailer pass is
 the same idea at hand scale (a masked repaint on the same checkpoint, recorded
-beside its painting in parts-examples).
+beside its painting in rig-c/examples).

package/docs/STABILITY.md

@@ -200,7 +200,7 @@ every number) are AUTHORING §3's tables, and the loader refuses any other by na
 | `parts.json`, `parts/<name>.png` | `assemble`, `build` | one record per part: `from` (`<run>:<tag>` with a See-through v3 tag, `<run>:author:<label>` for a layer the author made — issue #256, read by no role rule — or `painting:<name>` for a patch), `cut_from` on a cut's piece only (the plan part it was cut from, issue #230), `limb` on a limb segment's part only (issue #349: `name`, `segment`, `of`, `bone`, and below a joint `joint`, `range` when the config segment declares one (issue #360), and `cap` — `at`, `width`, `radius`, `box`, `layer_px`, `image_px` with a cap image, `image_layer` after it when that image was a hidden-art layer — issue #359, `<run>:<layer>:hidden` — `missing_px`, `short_px` (`left`, `right`) after it only when `missing_px` is above 0 (issue #557, additive), `excluded_px` after them only on a subset set's limb part whose cap the set exclusion took a pixel of (issue #603, additive: each pixel taken out of the count it was in, so the cap's counts are the written PNG's), then `shape` and `upper_px` under the segment's `cap_shape` — `upper_px` without the shape only when the upper segment gave a pixel (issue #557, additive) — and after them `lower_px`, `lower_kept_px` and `lower_missing_px` under `cap_shape: "ball"` (issue #579, additive), and `edge`, `feather_radius` and `feathered_px` under its `edge`, and `cut_band`, `cut_offset`, `cut_at`, `cut_crossed`, `joint_crossed`, `band_px` and `stroke_luma_max` (when the band has a split) under its `cut_band`, issue #360), the box `x`, `y`, `w`, `h` (rig px), the pixel counts `src/parts.ts` documents (`opaque_px`, `visible_px`, `occluded_px`, `projected_core_px`, `source_px_taken`, `visible_not_projected_px`, `refused_drift_px`, `merged_px` — on a subset set's limb part counted after the set exclusion, issue #603 — `seam_override_px`, and `fringe_pushed_back` when not empty); `rig_size`, `scale_rig_per_source`, `ghost_px`, `recomposite`, and `scene` (`figure_alpha_above`, `figure_px`, `figure_mask`) under `config.scene` only, with the figure's mask `figure_rig.png` beside the recomposite (issue #242); `single_run_pad` (`file_size`, `side`, `left`, `top`) last, only for one run whose file is not the `seethrough.resolution` square (issue #366) |
 | `rig/rig.json`, `rig/motion.json`, `rig/images/` | `rig`, `build`, `compose` | rig-c's rig spec and motion spec, `spec` `rigc-rig/1` and `rigc-motion/1`: the format is rig-c's, and this package writes only what rig-c's parser accepts; a bone carries `inherit` only where config.bones declares one, rig-c's mode name as written (issue #348) |
 | `rig/mesh_report.json` | `rig`, `build` | one row per mesh: `part`, `vertices`, `triangles`, `hull`, `bones` (the sorted names the attachment's weights bind in the written `rig.json`, in every mode — since 1.49.1 (issue #536) a rig with `turn` or `stops` names the twins and `<link>_d` bones there, where the row named the segment bones they replace: a fix of a wrong name, not a format change; a rig with neither writes the bytes it wrote), `max_influences`, `mean_influences`, `art_coverage`, then `grid` (a lattice); `mode` "contour" with `params`, `contour`, `regions` (`params.maxEdge` and `contour.outlineCut` only when the mesh declares `contour.maxEdge`; `params.bridges` and `contour.bridges` — `islands`, `units`, `joins`, and `faint` only when an island was left out as faint — only when it declares `contour.bridges`); or `mode` "influence" with `influence` (as declared), `reach` (`farthest`, `at`, `nearest`, `capped`, `widest`) and `lattice` (rig-c's `SegmentsLatticeReport`: `cols`, `rows`, `artCells`, `keptCells`, `passes`, `islands`) (issue #378); or `mode` "auto" with `settings`, `source`, `result`, `residuals`, `worst_residual`, `worst_region`, `motion_amplitude`, `termination`, `weights`, `regions`, `deformation`, `quality_report` (rig-c's `mesh-quality-report/1` document whole), `motion_report`, and, only when they apply, `stray_cleared` (after `source`, when `source.stray` is declared), `skinning_residual` and `replay` (`AutoMeshReport` in `src/rig.ts`); in every mode, `exponent` when the mesh declares one (after `grid`, or after `mode`); `influences`, as declared, when a lattice or contour mesh declares it (after `exponent`, or where `exponent` would be); `stray` and `stray_cleared` when a lattice mesh declares `stray` (after `influences`, or where `influences` would be); `ribs` when a contour or auto mesh declares them (after `exponent`, or after `mode`), and then `contour.ribs` (`source.contour.ribs` in the automatic mode) |
-| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `environment` after it under `--environment` only (issue #538, additive: `path` as given, `sha256`, `steps`), `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_border` after the seam figures when `parts.json` declares a scene (issue #242), `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `ANIMATIONS_DO_NOT_FOLD` after them when `motion.json` holds an animation, the idle included — on every rig with an idle since issue #333 (issues #320, #363: `status`, `animations`, `fps`, `physics_left_out`, `folding` — each `animation`, `slot`, `attachment`, `frames`, `worst_frame`, `worst_triangles`, `triangles`, `physics_on`, `physics_off`, `physics_constraints`, `declared`, `line` — `folding_undeclared`, `declared_not_folding`, `bar`), `FEET_STAY_LEVEL` after it when a `footwear` part rides a bone that hangs from another and `motion.json` holds an animation (issue #348: `status`, `reason` on a SKIP only, `animations`, `fps`, `physics_left_out`, `bar_degrees`, `bar`, `feet` — each `part`, `bone`, `hangs_from`, `status`, `frames_posed`, `worst`), `LIMB_ONE_BONE` after it (and after `STRESS_OFF_CHAIN` where that is written) when `parts.json` holds a limb segment's part (issue #349: `status`, `parts` — each `part`, `limb`, `bone`, `status`, `others`), `SEAM_OVER_RANGE` after it when a limb record carries a `range` (issue #360: `status`, `frame_scale`, `physics_left_out`, `bar` — `mean`, `rig_px_over_40`, `level` — and `joints`, each `part`, `limb`, `segment`, `joint`, `bone`, `range`, `at`, `radius`, `under_px`, `status`, `poses` — each `degrees`, `status`, `mean`, `px_over_40`, `px_over_80`, `rig_px_over_40`, and `step_px` (`left`, `right`) only on a joint whose cap record carries `short_px` (issue #557, additive) — and `unread` on a joint not read), `SEAM_OVER_MOTION` after it when `parts.json` holds a limb segment or `--requirements` a `seam` (issue #493, a warning and not a bar: `status` — `WARN`, `CLEAR` or `SKIP` — `reason` on a SKIP only, `fps`, `floor`, `pairs` — each `pair`, `a`, `b`, `declared`, and `unread` on a pair not read — `animations`, `warnings`, `rows` — each `pair`, `animation`, `status`, `drawn`, `banded`, `opens`, `px`, `max_px`, `under_floor`), `CLOTH_SETTLES` after it when the rig declares a physics constraint and has an idle (issue #501, a warning and not a bar: `status` — `WARN` or `CLEAR` — `fps`, `frames`, `duration`, `floor_rig_px_per_s`, `floor`, `levers`, `warnings`, `rows` — each `tip`, `root`, `links`, `point`, `settles_at`, `max_rig_px_per_s`, `min_rig_px_per_s`), `RECOMPOSITE_HOLES` (its first figure `declared_scene` when `parts.json` declares a scene), `SETUP_POSE_VS_SOURCE`, `skipped`, `config` under `build` only (issue #607, additive: `path` as `--config` was typed, `sha256` of the bytes the build read; `check` and `compose` read no config and write none), a `requirements` block under `--requirements` (or `build`'s `config.requirements`) — `file` first from issue #556, additive: `path` as typed or declared, `sha256`, `keys` — and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
+| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `environment` after it under `--environment` only (issue #538, additive: `path` as given, `sha256`, `steps`), `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_border` after the seam figures when `parts.json` declares a scene (issue #242), `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `ANIMATIONS_DO_NOT_FOLD` after them when `motion.json` holds an animation, the idle included — on every rig with an idle since issue #333 (issues #320, #363: `status`, `animations`, `fps`, `physics_left_out`, `folding` — each `animation`, `slot`, `attachment`, `frames`, `worst_frame`, `worst_triangles`, `triangles`, `physics_on`, `physics_off`, `physics_constraints`, `declared`, `line` — `folding_undeclared`, `declared_not_folding`, `bar`), `FEET_STAY_LEVEL` after it when a `footwear` part rides a bone that hangs from another and `motion.json` holds an animation (issue #348: `status`, `reason` on a SKIP only, `animations`, `fps`, `physics_left_out`, `bar_degrees`, `bar`, `feet` — each `part`, `bone`, `hangs_from`, `status`, `frames_posed`, `worst`), `LIMB_ONE_BONE` after it (and after `STRESS_OFF_CHAIN` where that is written) when `parts.json` holds a limb segment's part (issue #349: `status`, `parts` — each `part`, `limb`, `bone`, `status`, `others`), `SEAM_OVER_RANGE` after it when a limb record carries a `range` (issue #360: `status`, `frame_scale`, `physics_left_out`, `bar` — `mean`, `rig_px_over_40`, `level` — and `joints`, each `part`, `limb`, `segment`, `joint`, `bone`, `range`, `at`, `radius`, `under_px`, `status`, `poses` — each `degrees`, `status`, `mean`, `px_over_40`, `px_over_80`, `rig_px_over_40`, and `step_px` (`left`, `right`) only on a joint whose cap record carries `short_px` (issue #557, additive) — and `unread` on a joint not read), `SEAM_OVER_MOTION` after it when `parts.json` holds a limb segment or `--requirements` a `seam` (issue #493, a warning and not a bar: `status` — `WARN`, `CLEAR` or `SKIP` — `reason` on a SKIP only, `fps`, `floor`, `pairs` — each `pair`, `a`, `b`, `declared`, and `unread` on a pair not read — `animations`, `warnings`, `rows` — each `pair`, `animation`, `status`, `drawn`, `banded`, `opens`, `px`, `max_px`, `under_floor`; issue #591 adds optional `worlds` on physics rigs with readable declared pairs and animations: `default` and `still`, each `wind`, `gravity`, `status` (`REPORTED` or `SKIP`), `reason` on SKIP, `dir` only when rendered (relative to check.json: `seam_motion/default` or `seam_motion/still`, the complete retained render with frames.json and each animation's raw seam.json), and `rows` — pair, animation, status, drawn, banded, `gap` and `ghost`, each `max_px` and `worst` only; worst carries `index`, `px`, `cell`, `box`. Per-frame hits stay in the raw sidecars. These raw reference readings add no bar or warning and leave the custom environment reading unchanged), `CLOTH_SETTLES` after it when the rig declares a physics constraint and has an idle (issue #501, a warning and not a bar: `status` — `WARN` or `CLEAR` — `fps`, `frames`, `duration`, `floor_rig_px_per_s`, `floor`, `levers`, `warnings`, `rows` — each `tip`, `root`, `links`, `point`, `settles_at`, `max_rig_px_per_s`, `min_rig_px_per_s`), `RECOMPOSITE_HOLES` (its first figure `declared_scene` when `parts.json` declares a scene), `SETUP_POSE_VS_SOURCE`, `skipped`, `config` under `build` only (issue #607, additive: `path` as `--config` was typed, `sha256` of the bytes the build read; `check` and `compose` read no config and write none), a `requirements` block under `--requirements` (or `build`'s `config.requirements`) — `file` first from issue #556, additive: `path` as typed or declared, `sha256`, `keys` — and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
 | `layers.json`, `<index>_<name>.png` | `layers --export` | the wrapper form `layers` reads (issue #359): `width`, `height`, then `layers` — each `name`, `filename`, `left`, `top`, `right`, `bottom`, `depth_median` (the input's own; `null` for a PSD, the manifest's order then being the draw order) — drawn layers in draw order, then the hidden-art layers; a PNG's name is its index and its layer's name, and the manifest, not the file name, says which layer it is |
 | the template `.psd` | `layers --template` | one empty layer per name `templateLayerNames` (`src/layers.ts`) holds, bottom first; the same canvas writes the same bytes |
 | `proposal.json`, `render/landmarks*.png` | `propose` | the config's four rig sections, `constraints` with `--cloth` (issue #364: a physics constraint per tree link named `<bone>_physics`, a dangling end's `<bone>_translate`, and a skirt swing's transforms `<swing>_<tree>`), `turn` with `--full`/`--head`, `proposed_rig_scale` (issue #354), and `notes` |

package/package.json

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

package/src/build.ts

@@ -1719,7 +1719,7 @@ export function sweepCheckLines(line: SweepLine, steps: ReadonlyMap<string, { le
  * read nothing of (its SKIP) or the line could not read. A SKIP with nothing declared prints its reason alone.
  */
 export function motionSeamLines(line: MotionSeamLine, plant: MotionSeamPlant = {}): string[] {
-  if (line.status === 'SKIP' && line.rows.length === 0 && line.pairs.every((p) => p.unread === undefined)) return [`${MOTION_SEAM_LINE}: SKIP — ${String(line.reason)}`];
+  if (line.worlds === undefined && line.status === 'SKIP' && line.rows.length === 0 && line.pairs.every((p) => p.unread === undefined)) return [`${MOTION_SEAM_LINE}: SKIP — ${String(line.reason)}`];
   const read = `${line.pairs.length} declared pair(s) in ${line.animations.length} animation(s) (${line.animations.join(', ')}), read by rigc render --seam at ${line.fps} fps on the build as played`;
   const head =
     line.status === 'SKIP'
@@ -1731,6 +1731,20 @@ export function motionSeamLines(line: MotionSeamLine, plant: MotionSeamPlant = {
     ...line.rows.filter((r) => r.status === 'skip').map((r) => `seam "${r.pair}" in "${r.animation}": SKIP — rigc read no band on any of the ${r.drawn} frame(s) both slots draw, so there is no seam to read`),
     ...(plant.silent === true ? [] : line.rows.filter((r) => r.opens.length > 0).map(motionSeamWarnText)),
     ...line.rows.filter((r) => r.opens.length === 0 && r.under_floor.length > 0).map((r) => `seam "${r.pair}" in "${r.animation}": under the floor — rigc names ${r.under_floor.length} frame(s) open ${frameRuns(r.under_floor)}, each opening one cell thick`),
+    ...(line.worlds === undefined ? [] : (['default', 'still'] as const).flatMap(name => {
+      const w = line.worlds?.[name];
+      if (w === undefined) return [];
+      const label = 'seam world "' + name + '"';
+      const header = label + ' wind [' + w.wind.join(', ') + '], gravity [' + w.gravity.join(', ') + ']: ' + w.status +
+        (w.status === 'SKIP' ? ' — ' + String(w.reason) : ' — raw gap/ghost cell counts, informational, not judged') +
+        (w.dir === undefined ? '' : '; raw render: ' + w.dir);
+      return [header, ...w.rows.map(r => {
+        const head = label + ' "' + r.pair + '" in "' + r.animation + '": ';
+        if (r.status === 'skip') return head + 'SKIP — rigc read no band';
+        const at = (kind: typeof r.gap) => kind.worst === null ? 'none' : 'frame ' + kind.worst.index + ' (t = ' + kind.worst.index / line.fps + 's)';
+        return head + 'gap ' + r.gap.max_px + ' cell(s), worst ' + at(r.gap) + '; ghost ' + r.ghost.max_px + ' cell(s), worst ' + at(r.ghost);
+      })];
+    })),
   ];
 }
 

package/src/check.ts

@@ -78,8 +78,8 @@
  * `TIME_SLACK`, issue #244).
  */
 import { createHash } from 'node:crypto';
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { basename, delimiter, dirname, join, resolve } from 'node:path';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { measureRecomposite, type RecompositeFigures, recompositeRecord, scenePhrase, sourceInRig } from './assemble.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal } from './coords.ts';
 import { capBox, inDisc } from './limbs.ts';
@@ -160,7 +160,7 @@ import {
 } from './requirements.ts';
 import { RIG_BONE_INHERIT, type RigSpec as RigcRigSpec } from 'rig-c/src/rig.ts';
 import { expandStops } from 'rig-c/src/stop.ts';
-import { ENVIRONMENT_SPEC, EnvironmentError, readEnvironmentSchedule } from 'rig-c/src/environment.ts';
+import { ENVIRONMENT_SPEC, EnvironmentError, environmentResponse, readEnvironmentSchedule } from 'rig-c/src/environment.ts';
 import { alphaComposite } from './raster/composite.ts';
 import { readPng, writePng } from './raster/png.ts';
 import { newFloatImage, newRaster, type Raster } from './raster/types.ts';
@@ -3535,6 +3535,7 @@ export const MOTION_SEAM_LINE = 'SEAM_OVER_MOTION';
 
 /** The seam reading's scratch build and renders, under `--out`; removed before the stage returns. */
 const MOTION_SEAM_SCRATCH = '_seam_motion';
+const MOTION_SEAM_DIR = 'seam_motion';
 
 /** rig-c's seam reading: the file it writes in each set's directory, and its format tag. */
 export const SEAM_READING_FILE = 'seam.json';
@@ -3584,6 +3585,8 @@ export interface MotionSeamLine {
   /** Rows with a frame over the floor: the WARN lines. */
   warnings: number;
   rows: MotionSeamRow[];
+  /** Physics-only reference worlds (issue #591); do not participate in warnings or bars. */
+  worlds?: MotionSeamWorlds;
 }
 
 /**
@@ -3640,7 +3643,109 @@ export interface MotionSeamPlant {
   silent?: true;
 }
 
-type SeamHitRead = { index: number; px: number; cell: number; box: [number, number, number, number] };
+
+/** One raw opening, in rigc cells; its frame time is index / the line's fps. */
+export interface MotionSeamHit {
+  index: number;
+  px: number;
+  cell: number;
+  box: [number, number, number, number];
+}
+export interface MotionSeamWorldKind {
+  max_px: number;
+  worst: MotionSeamHit | null;
+}
+/** Raw gap and ghost readings, including cells under the warning floor. */
+export interface MotionSeamWorldRow {
+  pair: string;
+  animation: string;
+  status: 'read' | 'skip';
+  drawn: number;
+  banded: number;
+  gap: MotionSeamWorldKind;
+  ghost: MotionSeamWorldKind;
+}
+export interface MotionSeamWorld {
+  wind: [number, number];
+  gravity: [number, number];
+  status: 'REPORTED' | 'SKIP';
+  reason?: string;
+  /** Complete rigc render directory, relative to check.json; absent when not rendered. */
+  dir?: string;
+  rows: MotionSeamWorldRow[];
+}
+export interface MotionSeamWorlds {
+  default: MotionSeamWorld;
+  still: MotionSeamWorld;
+}
+
+/** No callback and no output for nonphysics; a wind no constraint answers is not measured. */
+export function motionSeamWorlds(physics: boolean, answersWind: boolean, read: (world: 'default' | 'still') => MotionSeamWorldRow[]): MotionSeamWorlds | undefined {
+  if (!physics) return undefined;
+  const world = (wind: [number, number], rows: MotionSeamWorldRow[], reason?: string): MotionSeamWorld => {
+    const measured = rows.some(r => r.status === 'read');
+    return { wind, gravity: [0, 1], status: measured ? 'REPORTED' : 'SKIP',
+      ...(measured ? {} : { reason: reason ?? 'rigc read no band on any frame of any declared pair in any animation' }), rows };
+  };
+  return {
+    default: world([1, 0], read('default')),
+    still: answersWind ? world([0, 0], read('still')) : world([0, 0], [], 'no physics constraint answers wind; still air is not separately measurable'),
+  };
+}
+
+/** The same validated sidecars as the warning, retaining the raw gap and ghost cells. */
+export function readMotionSeamWorldRows(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[]): MotionSeamWorldRow[] {
+  const rows: MotionSeamWorldRow[] = [];
+  readMotionSeams(dir, animations, fps, pairs, {}, rows);
+  return rows;
+}
+
+
+/** Publish complete validated render directories with check.json; roll back if its writer fails. */
+export function publishMotionSeamWorlds(out: string, scratch: string, worlds: MotionSeamWorlds, publishCheck: () => void): void {
+  const problems: Problem[] = [];
+  const names = (['default', 'still'] as const).filter(name => worlds[name].dir !== undefined);
+  for (const name of names) {
+    const world = worlds[name];
+    const home = join(scratch, name);
+    if (world.dir !== MOTION_SEAM_DIR + '/' + name) problems.push({ code: 'FRAMES_SIDECAR', object: 'seam world ' + name, detail: 'raw directory reference must be ' + MOTION_SEAM_DIR + '/' + name });
+    const manifest = readJson(join(home, 'frames.json'), problems);
+    const sets = manifest !== null && Array.isArray(manifest.sets) ? manifest.sets.filter(isRecord) : [];
+    for (const animation of new Set(world.rows.map(row => row.animation))) {
+      const set = sets.find(item => item.animation === animation);
+      const rawDir = set !== undefined && typeof set.dir === 'string' ? set.dir : null;
+      const at = rawDir === null ? null : resolve(home, rawDir);
+      const rel = at === null ? '..' : relative(home, at);
+      if (rawDir === null || isAbsolute(rawDir) || at === null || isAbsolute(rel) || /^\.\.(?:[\\/]|$)/.test(rel) || !existsSync(join(at, SEAM_READING_FILE))) {
+        problems.push({ code: 'FRAMES_SIDECAR', object: home, detail: 'animation ' + JSON.stringify(animation) + ' raw dir ' + JSON.stringify(rawDir) + ' must be relative, stay inside its render directory and hold seam.json' });
+      }
+    }
+  }
+  refuseIfAny(problems);
+  const stage = join(scratch, '_publish');
+  const previous = join(scratch, '_previous');
+  const kept = join(out, MOTION_SEAM_DIR);
+  const check = join(out, 'check.json');
+  const previousCheck = existsSync(check) ? readFileSync(check) : null;
+  mkdirSync(out, { recursive: true });
+  mkdirSync(stage, { recursive: true });
+  for (const name of names) renameSync(join(scratch, name), join(stage, name));
+  const hadPrevious = existsSync(kept);
+  if (hadPrevious) renameSync(kept, previous);
+  try {
+    renameSync(stage, kept);
+    publishCheck();
+  } catch (err) {
+    rmSync(kept, { recursive: true, force: true });
+    if (hadPrevious) renameSync(previous, kept);
+    if (previousCheck === null) rmSync(check, { force: true });
+    else writeFileSync(check, previousCheck);
+    throw err;
+  }
+  rmSync(previous, { recursive: true, force: true });
+}
+
+type SeamHitRead = MotionSeamHit;
 
 /**
  * The rows of one `rigc render --seam` run over every animation: `frames.json`
@@ -3649,7 +3754,7 @@ type SeamHitRead = { index: number; px: number; cell: number; box: [number, numb
  * file that is missing, a file that is not the animation's or not at the rate
  * asked, a pair out of the flag's order, and a field of the wrong shape.
  */
-export function readMotionSeams(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[], plant: MotionSeamPlant = {}): MotionSeamRow[] {
+export function readMotionSeams(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[], plant: MotionSeamPlant = {}, worldRows?: MotionSeamWorldRow[]): MotionSeamRow[] {
   const problems: Problem[] = [];
   const bad = (object: string, detail: string): void => {
     problems.push({ code: 'FRAMES_SIDECAR', object, detail });
@@ -3686,6 +3791,7 @@ export function readMotionSeams(dir: string, animations: readonly string[], fps:
         return;
       }
       const over = new Map<number, number>();
+      const kinds: Record<'gap' | 'ghost', MotionSeamWorldKind> = { gap: { max_px: 0, worst: null }, ghost: { max_px: 0, worst: null } };
       for (const kind of ['gap', 'ghost'] as const) {
         const k = p[kind];
         const frames = isRecord(k) && Array.isArray(k.frames) ? k.frames.map(hitOf) : null;
@@ -3693,8 +3799,12 @@ export function readMotionSeams(dir: string, animations: readonly string[], fps:
           bad(`${at} ${kind}`, 'is not { frames: [{ index, px, cell, box }…], spans, worst } as rigc-seam/1 writes it');
           return;
         }
-        for (const h of frames as SeamHitRead[]) if (plant.noFloor === true || openingOverFloor(h)) over.set(h.index, Math.max(over.get(h.index) ?? 0, h.px));
+        const hits = frames as SeamHitRead[];
+        const worst = hits.reduce<MotionSeamHit | null>((best, h) => best === null || h.px > best.px || (h.px === best.px && h.index < best.index) ? h : best, null);
+        kinds[kind] = { max_px: worst?.px ?? 0, worst };
+        for (const h of hits) if (plant.noFloor === true || openingOverFloor(h)) over.set(h.index, Math.max(over.get(h.index) ?? 0, h.px));
       }
+      worldRows?.push({ pair: want.pair, animation, status: p.status, drawn: p.drawn, banded: p.banded, gap: kinds.gap, ghost: kinds.ghost });
       const opens = [...over.keys()].sort((x, y) => x - y);
       rows.push({
         pair: want.pair,
@@ -4070,13 +4180,15 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   const seamDir = join(out, SEAM_DIR);
   const keptDir = join(out, STILL_DIR);
   const foldDir = join(out, FOLD_SCRATCH);
-  for (const d of [buildDir, idleDir, stillDir, isoDir, loopDir, seamDir, keptDir, foldDir]) rmSync(d, { recursive: true, force: true });
+  const seamMotionDir = join(out, MOTION_SEAM_SCRATCH);
+  for (const d of [buildDir, idleDir, stillDir, isoDir, loopDir, seamDir, keptDir, foldDir, seamMotionDir]) rmSync(d, { recursive: true, force: true });
   const written: string[] = [];
   const write = (name: string, data: string): void => {
     writeFileSync(join(out, name), data);
     written.push(name);
   };
 
+  try {
   // 1. build, packed, under the policy profile
   const build = rigc(['build', '--rig', inp.rigPath, '--motion', inp.motionPath, '--out', buildDir, ...packedBuildArgs(mode)]);
   const gateHtml = buildGateLines(build.out);
@@ -4429,15 +4541,38 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     else if (animationNames.length === 0) motionSeam = motionSeamLine(pairs, [], fps, [], 'motion.json holds no animation to read the declared pairs in');
     else if (read.length === 0) motionSeam = motionSeamLine(pairs, animationNames, fps, []);
     else {
-      const seamMotionDir = join(out, MOTION_SEAM_SCRATCH);
       rmSync(seamMotionDir, { recursive: true, force: true });
-      try {
+      {
         const list = read.map((p) => `${p.a}:${p.b}`).join(',');
-        const r = measured(['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', seamMotionDir]);
+        const activeDest = stripped === null ? seamMotionDir : join(seamMotionDir, env === null ? 'default' : 'active');
+        const renderedWorlds = new Set<'default' | 'still'>();
+        const r = measured(['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', activeDest]);
         if (r.status !== 0) refuseIfAny(rigcFailed(`render --seam ${list} --fps ${fps}`, r, r.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
-        motionSeam = motionSeamLine(pairs, animationNames, fps, readMotionSeams(seamMotionDir, animationNames, fps, read));
-      } finally {
-        rmSync(seamMotionDir, { recursive: true, force: true });
+        const activeWorldRows: MotionSeamWorldRow[] = [];
+        motionSeam = motionSeamLine(pairs, animationNames, fps, readMotionSeams(activeDest, animationNames, fps, read, {}, stripped !== null && env === null ? activeWorldRows : undefined));
+        if (stripped !== null) {
+          const response = environmentResponse(readFileSync(join(buildDir, 'skeleton.json'), 'utf8'));
+          motionSeam.worlds = motionSeamWorlds(true, response.wind.length > 0, world => {
+            if (world === 'default' && env === null) { renderedWorlds.add(world); return activeWorldRows; }
+            const dest = join(seamMotionDir, world);
+            const args = ['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', dest];
+            if (world === 'still') {
+              const schedule = join(seamMotionDir, 'still.json');
+              writeFileSync(schedule, JSON.stringify({ spec: ENVIRONMENT_SPEC, steps: [{ t: 0, wind: [0, 0] }] }));
+              args.push('--environment', schedule);
+            }
+            // These reference worlds are independent of the caller's --environment.
+            const rendered = rigc(args);
+            if (rendered.status !== 0) refuseIfAny(rigcFailed('render --seam (' + world + ' reference world)', rendered, rendered.out.split('\n').filter(l => l.includes('FAIL') || l.includes('rigc:'))));
+            const rows = readMotionSeamWorldRows(dest, animationNames, fps, read);
+            renderedWorlds.add(world);
+            return rows;
+          });
+          for (const world of renderedWorlds) {
+            const reading = motionSeam.worlds?.[world];
+            if (reading !== undefined) reading.dir = MOTION_SEAM_DIR + '/' + world;
+          }
+        }
       }
     }
   }
@@ -4692,7 +4827,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   problems.unshift(...barProblems);
   problems.push(...foldProblems, ...levelProblems, ...stressProblems, ...limbProblems, ...sweepProblems, ...reqProblems);
   figures.PASS = problems.length === 0;
-  write('check.json', `${JSON.stringify(figures, null, 1)}\n`);
+  const publishCheck = (): void => write('check.json', `${JSON.stringify(figures, null, 1)}\n`);
+  if (motionSeam.worlds === undefined) publishCheck();
+  else publishMotionSeamWorlds(out, seamMotionDir, motionSeam.worlds, publishCheck);
   const bars: CheckReport['bars'] = { measured: ['gate'], skipped: [] };
   const tally = (bar: string, reason: string | null): void => {
     if (reason === null) bars.measured.push(bar);
@@ -4731,6 +4868,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     cloth,
     ...(sweepSteps.size === 0 ? {} : { sweepSteps }),
   };
+  } finally {
+    rmSync(seamMotionDir, { recursive: true, force: true });
+  }
 }
 
 // ---------------------------------------------------------------------------