@rig-c/parts 2.52.0 → 2.52.1

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
@@ -7067,6 +7067,10 @@ assemble*, at the end of this section):
7067
7067
  `loop physics: … "<name>" on bone "<bone>" (rig.json|motion.json)`, and written as `check.json`'s `loop_physics` after
7068
7068
  `loop_max_diff`; they are reported, not judged. A rig with none is measured from the
7069
7069
  idle render itself, exactly as before, and writes no such line or key.
7070
+ When removing physics tracks leaves a named animation beside `idle` without
7071
+ any timeline, the keyed build omits it and the `loop physics:` line names it
7072
+ (issue #1461). Bone tracks and other timelines, including events and draw order,
7073
+ stay in the keyed build.
7070
7074
 
7071
7075
  On the examples: `reference-sample` 23/23, seam 0.207 with 0 pixels over 40, loop 0;
7072
7076
  `reference-demo` (default rule) 23/23, seam 0.326 with 2 pixels over 40, loop 0.
@@ -7381,6 +7385,7 @@ exemption that exempts nothing.
7381
7385
  | `animations` | every animation, the idle included, in `motion.json`'s order: each one read |
7382
7386
  | `fps` | the rate the reading sampled at |
7383
7387
  | `physics_left_out` | how many physics constraints the rig declares — stepped in `physics_on` and left out in `physics_off` (0 without any) |
7388
+ | `physics_off_skipped` | written when stripping physics removed a named animation's last timeline. Lists omitted names in motion order. The original build still supplies their fold verdicts. The console marks their physics-off readings `SKIP`, and `FEET_STAY_LEVEL` reads only the remaining keyed animations. A `physics_off: null` for a listed animation means no reading was taken. |
7384
7389
  | `folding` | one row per mesh that folds in an animation: `animation`, `slot`, `attachment`, `frames` (how many show a folded triangle), `worst_frame`, `worst_triangles`, `triangles` (the mesh's), `physics_on` and `physics_off` (`{ frames, worst_frame, worst_triangles, line }` or null, side by side so a reader sees which folds physics adds), `physics_constraints` (the physics constraints on the mesh's bones, `"<name> on <bone>"`, when the fold appears only with physics on; empty otherwise), `declared` (the `may_fold` why, or null) and `line`, rigc's printed line verbatim |
7385
7390
  | `folding_undeclared` | the rows no `may_fold` entry takes: the bar's figure |
7386
7391
  | `declared_not_folding` | the `may_fold` entries no row matches, each a failure |
@@ -9916,8 +9921,8 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
9916
9921
  <!-- check-row-table:begin -->
9917
9922
  | Row family | Registered JSON paths | row_scope | row_kind | row_subjects (producer expression) | Producer |
9918
9923
  | --- | --- | --- | --- | --- | --- |
9919
- | `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:3711](../src/check.ts#L3711) |
9920
- | `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:3673](../src/check.ts#L3673) |
9924
+ | `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:3729](../src/check.ts#L3729) |
9925
+ | `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:3689](../src/check.ts#L3689) |
9921
9926
  | `ART_JOINT_DISTANCE.joints` | `ART_JOINT_DISTANCE.joints` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [artjoints.ts:86](../src/artjoints.ts#L86) |
9922
9927
  | `BEHIND_PART_SEAMS.contributors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples[].contributors`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples[].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:664](../src/behindseams.ts#L664) |
9923
9928
  | `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:750](../src/behindseams.ts#L750) |
@@ -9933,51 +9938,51 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
9933
9938
  | `BEHIND_PART_SEAMS.unread_corridors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.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:585](../src/behindseams.ts#L585) |
9934
9939
  | `BOUNDARY_COLOUR_STEP.over` | `BOUNDARY_COLOUR_STEP.over` | 'pair' | finding | r.parts | [boundarycolour.ts:221](../src/boundarycolour.ts#L221) |
9935
9940
  | `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) |
9936
- | `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:6158](../src/check.ts#L6158) |
9941
+ | `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:6178](../src/check.ts#L6178) |
9937
9942
  | `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) |
9938
- | `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:3912](../src/check.ts#L3912) |
9939
- | `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:3887](../src/check.ts#L3887) |
9940
- | `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:4204](../src/check.ts#L4204) |
9943
+ | `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:3931](../src/check.ts#L3931) |
9944
+ | `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:3906](../src/check.ts#L3906) |
9945
+ | `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:4224](../src/check.ts#L4224) |
9941
9946
  | `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) |
9942
9947
  | `PART_SUPPORT_REPORT.raw_pairs` | `PART_SUPPORT_REPORT.raw_pairs` | 'pair' | evidence | [F.name, B.name] | [coincide.ts:110](../src/coincide.ts#L110) |
9943
9948
  | `PART_SUPPORT_REPORT.unowned.regions` | `PART_SUPPORT_REPORT.unowned.regions` | 'rig' | finding | [] | [coincide.ts:145](../src/coincide.ts#L145) |
9944
9949
  | `PHYSICS_CONTRIBUTES.rows` | `PHYSICS_CONTRIBUTES.rows` | 'part' | evidence; finding when !moves; otherwise evidence | [part] | [physicscontrib.ts:217](../src/physicscontrib.ts#L217), [physicscontrib.ts:220](../src/physicscontrib.ts#L220) |
9945
- | `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:5555](../src/check.ts#L5555) |
9946
- | `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:4874](../src/check.ts#L4874) |
9947
- | `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4866](../src/check.ts#L4866) |
9948
- | `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:5532](../src/check.ts#L5532) |
9949
- | `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:5489](../src/check.ts#L5489), [check.ts:5561](../src/check.ts#L5561) |
9950
- | `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:5502](../src/check.ts#L5502) |
9951
- | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:5492](../src/check.ts#L5492) |
9950
+ | `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:5575](../src/check.ts#L5575) |
9951
+ | `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:4894](../src/check.ts#L4894) |
9952
+ | `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4886](../src/check.ts#L4886) |
9953
+ | `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:5552](../src/check.ts#L5552) |
9954
+ | `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:5509](../src/check.ts#L5509), [check.ts:5581](../src/check.ts#L5581) |
9955
+ | `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:5522](../src/check.ts#L5522) |
9956
+ | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:5512](../src/check.ts#L5512) |
9952
9957
  | `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) |
9953
- | `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:5486](../src/check.ts#L5486) |
9954
- | `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:4528](../src/check.ts#L4528), [check.ts:4574](../src/check.ts#L4574) |
9955
- | `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4572](../src/check.ts#L4572) |
9958
+ | `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:5506](../src/check.ts#L5506) |
9959
+ | `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:4548](../src/check.ts#L4548), [check.ts:4594](../src/check.ts#L4594) |
9960
+ | `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4592](../src/check.ts#L4592) |
9956
9961
  | `SETUP_MATCHES_PAINTING.regions` | `SETUP_MATCHES_PAINTING.regions` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [setuppainting.ts:175](../src/setuppainting.ts#L175) |
9957
9962
  | `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) |
9958
- | `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:9317](../src/check.ts#L9317) |
9959
- | `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:9303](../src/check.ts#L9303), [check.ts:9308](../src/check.ts#L9308) |
9960
- | `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:4132](../src/check.ts#L4132) |
9961
- | `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:4120](../src/check.ts#L4120) |
9962
- | `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:4120](../src/check.ts#L4120) |
9963
- | `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:4088](../src/check.ts#L4088), [check.ts:4106](../src/check.ts#L4106) |
9964
- | `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:9967](../src/check.ts#L9967), [check.ts:9977](../src/check.ts#L9977) |
9965
- | `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:8692](../src/check.ts#L8692), [check.ts:8697](../src/check.ts#L8697), [check.ts:8718](../src/check.ts#L8718), [check.ts:8729](../src/check.ts#L8729) |
9966
- | `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6662](../src/check.ts#L6662) |
9967
- | `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6673](../src/check.ts#L6673) |
9968
- | `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5979](../src/check.ts#L5979) |
9969
- | `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7731](../src/check.ts#L7731) |
9970
- | `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:8060](../src/check.ts#L8060) |
9971
- | `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:8060](../src/check.ts#L8060) |
9972
- | `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:8060](../src/check.ts#L8060) |
9973
- | `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4863](../src/check.ts#L4863) |
9974
- | `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:4823](../src/check.ts#L4823) |
9975
- | `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:2558](../src/check.ts#L2558) |
9976
- | `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:2036](../src/check.ts#L2036) |
9977
- | `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:2121](../src/check.ts#L2121) |
9978
- | `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:7590](../src/check.ts#L7590) |
9979
- | `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:2492](../src/check.ts#L2492) |
9980
- | `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:2493](../src/check.ts#L2493) |
9963
+ | `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:9341](../src/check.ts#L9341) |
9964
+ | `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:9327](../src/check.ts#L9327), [check.ts:9332](../src/check.ts#L9332) |
9965
+ | `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:4152](../src/check.ts#L4152) |
9966
+ | `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:4140](../src/check.ts#L4140) |
9967
+ | `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:4140](../src/check.ts#L4140) |
9968
+ | `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:4108](../src/check.ts#L4108), [check.ts:4126](../src/check.ts#L4126) |
9969
+ | `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:9991](../src/check.ts#L9991), [check.ts:10001](../src/check.ts#L10001) |
9970
+ | `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:8716](../src/check.ts#L8716), [check.ts:8721](../src/check.ts#L8721), [check.ts:8742](../src/check.ts#L8742), [check.ts:8753](../src/check.ts#L8753) |
9971
+ | `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6682](../src/check.ts#L6682) |
9972
+ | `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6693](../src/check.ts#L6693) |
9973
+ | `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5999](../src/check.ts#L5999) |
9974
+ | `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7755](../src/check.ts#L7755) |
9975
+ | `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:8084](../src/check.ts#L8084) |
9976
+ | `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:8084](../src/check.ts#L8084) |
9977
+ | `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:8084](../src/check.ts#L8084) |
9978
+ | `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4883](../src/check.ts#L4883) |
9979
+ | `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:4843](../src/check.ts#L4843) |
9980
+ | `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:2570](../src/check.ts#L2570) |
9981
+ | `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:2048](../src/check.ts#L2048) |
9982
+ | `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:2133](../src/check.ts#L2133) |
9983
+ | `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:7614](../src/check.ts#L7614) |
9984
+ | `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:2504](../src/check.ts#L2504) |
9985
+ | `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:2505](../src/check.ts#L2505) |
9981
9986
 
9982
9987
  | Open serialized type path | Reason for schema exclusion |
9983
9988
  | --- | --- |
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@rig-c/parts",
3
- "version": "2.52.0",
3
+ "version": "2.52.1",
4
4
  "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.",
5
5
  "type": "module",
6
6
  "exports": {
package/src/build.ts CHANGED
@@ -2243,18 +2243,22 @@ export function judgementLine(name: string, line: JudgementLine | ReportedLine):
2243
2243
  * where `may_fold` takes it.
2244
2244
  */
2245
2245
  export function foldsLines(line: FoldsLine): string[] {
2246
- const physics = line.physics_left_out === 0 ? '' : `, with its ${line.physics_left_out} physics constraint(s) on and off`;
2246
+ const skipped = new Set(line.physics_off_skipped);
2247
+ const sides = skipped.size === 0 ? 'on and off' : skipped.size === line.animations.length ? 'on' : 'on and off where a keyed animation remains';
2248
+ const physics = line.physics_left_out === 0 ? '' : `, with its ${line.physics_left_out} physics constraint(s) ${sides}`;
2247
2249
  const head =
2248
2250
  `${FOLD_LINE}: ${line.status} — ${line.animations.length} animation(s) read by rigc render --folds at ${line.fps} fps${physics} (${line.animations.join(', ')}): ` +
2249
2251
  `${line.folding.length} folding mesh(es), ${line.folding_undeclared} not declared in may_fold (<= ${line.bar})` +
2250
2252
  (line.declared_not_folding.length === 0 ? '' : `; may_fold declares ${line.declared_not_folding.map((d) => `slot "${d.slot}" in "${d.animation}"`).join(', ')}, which do(es) not fold`);
2251
2253
  return [
2252
2254
  head,
2255
+ ...[...skipped].map(name => ` folds physics off: SKIP — ${JSON.stringify(name)} has no timeline after removing physics tracks`),
2253
2256
  ...line.folding.map((r) => {
2257
+ const off = skipped.has(r.animation) ? 'SKIP' : r.physics_off === null ? '0 frame(s)' : `${r.physics_off.frames} frame(s), worst frame ${r.physics_off.worst_frame} (${r.physics_off.worst_triangles}/${r.triangles} triangle(s))`;
2254
2258
  const side =
2255
2259
  line.physics_left_out === 0
2256
2260
  ? ''
2257
- : ` — physics on: ${r.physics_on === null ? '0 frame(s)' : `${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s))`}; physics off: ${r.physics_off === null ? '0 frame(s)' : `${r.physics_off.frames} frame(s), worst frame ${r.physics_off.worst_frame} (${r.physics_off.worst_triangles}/${r.triangles} triangle(s))`}` +
2261
+ : ` — physics on: ${r.physics_on === null ? '0 frame(s)' : `${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s))`}; physics off: ${off}` +
2258
2262
  (r.physics_constraints.length === 0 ? '' : `; physics constraint(s): ${r.physics_constraints.join(', ')}`);
2259
2263
  return ` folds ${r.line}${side}${r.declared === null ? '' : ` — declared in may_fold: ${r.declared}`}`;
2260
2264
  }),
@@ -2405,7 +2409,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
2405
2409
  if (r.idle === null) log(` loop: SKIP — ${fig.skipped?.loop ?? ''}`);
2406
2410
  else log(` ${loopCheckLine(r.idle, fig.loop_max_diff, fig.loop_physics?.length ?? 0)}`);
2407
2411
  if (r.loopPhysics !== null) log(` ${r.loopPhysics}`);
2408
- const beside = besideIdleLine(r.besideIdle, r.figures[LEVEL_LINE] !== undefined);
2412
+ const beside = besideIdleLine(r.besideIdle, fig[LEVEL_LINE] !== undefined, (fig[FOLD_LINE]?.physics_off_skipped?.length ?? 0) > 0);
2409
2413
  if (beside !== null) log(` ${beside}`);
2410
2414
  if (r.seamViewport === null || fig.seam_mean === null) log(` seam: SKIP — ${fig.skipped?.seam ?? ''}`);
2411
2415
  else {
package/src/check.ts CHANGED
@@ -1230,10 +1230,11 @@ function withoutSliders(rig: Record<string, unknown>, animations: Record<string,
1230
1230
  * `constraints` entry of `type` `"physics"` and every entry of motion.json's
1231
1231
  * `physics` table are dropped, with what names them only to activate or key
1232
1232
  * them — a skin's `physics` list, and an animation track whose target is a
1233
- * `physics` constraint. Nothing else is touched, and nothing here judges the
1234
- * constraints: the line that names them reports.
1233
+ * `physics` constraint. A named animation beside the idle is dropped if this
1234
+ * removes its last timeline. The idle still has to pass the keyed build's
1235
+ * gate. The line naming what was left out reports it.
1235
1236
  */
1236
- export function withoutPhysics(rig: Record<string, unknown>, motion: Record<string, unknown>): { rig: Record<string, unknown>; motion: Record<string, unknown>; physics: LoopPhysics[] } | null {
1237
+ export function withoutPhysics(rig: Record<string, unknown>, motion: Record<string, unknown>): { rig: Record<string, unknown>; motion: Record<string, unknown>; physics: LoopPhysics[]; droppedAnimations: string[] } | null {
1237
1238
  const physics: LoopPhysics[] = [];
1238
1239
  const constraints = Array.isArray(rig.constraints) ? rig.constraints : null;
1239
1240
  if (constraints !== null) {
@@ -1258,18 +1259,29 @@ export function withoutPhysics(rig: Record<string, unknown>, motion: Record<stri
1258
1259
  }
1259
1260
  const m: Record<string, unknown> = { ...motion };
1260
1261
  delete m.physics;
1262
+ const droppedAnimations: string[] = [];
1261
1263
  if (isRecord(motion.animations)) {
1262
- m.animations = Object.fromEntries(Object.entries(motion.animations).map(([name, a]) => {
1263
- if (!isRecord(a) || !Array.isArray(a.tracks)) return [name, a];
1264
- return [name, { ...a, tracks: a.tracks.filter((t) => !(isRecord(t) && 'physics' in t)) }];
1264
+ m.animations = Object.fromEntries(Object.entries(motion.animations).flatMap(([name, a]): Array<[string, unknown]> => {
1265
+ if (!isRecord(a) || !Array.isArray(a.tracks)) return [[name, a]];
1266
+ const tracks = a.tracks.filter((t) => !(isRecord(t) && 'physics' in t));
1267
+ if (tracks.length === a.tracks.length) return [[name, a]];
1268
+ const hasOtherTimeline = [a.ik, a.transform, a.deform, a.sequence, a.drawOrder, a.events]
1269
+ .some(timeline => Array.isArray(timeline) && timeline.length > 0);
1270
+ if (name !== 'idle' && tracks.length === 0 && !hasOtherTimeline) {
1271
+ droppedAnimations.push(name);
1272
+ return [];
1273
+ }
1274
+ return [[name, { ...a, tracks }]];
1265
1275
  }));
1266
1276
  }
1267
- return { rig: r, motion: m, physics };
1277
+ return { rig: r, motion: m, physics, droppedAnimations };
1268
1278
  }
1269
1279
 
1270
1280
  /** The one line naming what {@link withoutPhysics} left out of the loop's frames: reported, not judged. */
1271
- export function loopPhysicsLine(physics: readonly LoopPhysics[]): string {
1272
- return `loop physics: ${physics.length} physics constraint(s) left out of the loop's frames, reported, not judged — ${physics.map((p) => `"${p.name}" on bone "${p.bone}" (${p.in})`).join(', ')}`;
1281
+ export function loopPhysicsLine(physics: readonly LoopPhysics[], droppedAnimations: readonly string[] = []): string {
1282
+ const dropped = droppedAnimations.length === 0 ? ''
1283
+ : `; physics-only animation(s) omitted from the keyed build: ${droppedAnimations.map(name => JSON.stringify(name)).join(', ')}`;
1284
+ return `loop physics: ${physics.length} physics constraint(s) left out of the loop's frames, reported, not judged — ${physics.map((p) => `"${p.name}" on bone "${p.bone}" (${p.in})`).join(', ')}${dropped}`;
1273
1285
  }
1274
1286
 
1275
1287
  // ---------------------------------------------------------------------------
@@ -3352,9 +3364,9 @@ export function checkStatuses(fig: Omit<CheckFigures, 'spec' | 'bar_outcomes' |
3352
3364
  * idle (issue #183), or null when it holds none, so a rig of the idle alone
3353
3365
  * prints what it printed before.
3354
3366
  */
3355
- export function besideIdleLine(names: readonly string[], level = false): string | null {
3367
+ export function besideIdleLine(names: readonly string[], level = false, skipsKeyedAnimations = false): string | null {
3356
3368
  if (names.length === 0) return null;
3357
- const readers = level ? `${FOLD_LINE} reads each for folds and ${LEVEL_LINE} for how far the feet turn` : `${FOLD_LINE} reads each for folds`;
3369
+ const readers = level ? `${FOLD_LINE} reads each for folds and ${LEVEL_LINE} for how far the feet turn${skipsKeyedAnimations ? ' in the remaining keyed animations' : ''}` : `${FOLD_LINE} reads each for folds`;
3358
3370
  return `beside the idle: ${names.length} animation(s), ${names.join(', ')} — built and gated by rigc with the rig; ${readers}, every other bar here reads the idle`;
3359
3371
  }
3360
3372
 
@@ -3401,9 +3413,9 @@ export interface FoldRow {
3401
3413
  triangles: number;
3402
3414
  /** The reading with physics on, or null when the mesh folds only with physics off. */
3403
3415
  physics_on: FoldSide | null;
3404
- /** The reading with physics off, or null when the mesh folds only with physics on. */
3416
+ /** The reading with physics off, or null when that side found no fold or skipped this animation. */
3405
3417
  physics_off: FoldSide | null;
3406
- /** When the mesh folds only with physics on (`physics_on !== null && physics_off === null`), the physics constraints on its bones (`<name> on <bone>`); empty otherwise. */
3418
+ /** When physics on found a fold and physics off measured none, the physics constraints on the mesh's bones (`<name> on <bone>`); empty otherwise. */
3407
3419
  physics_constraints: string[];
3408
3420
  /** The `may_fold` entry's why when the requirements file declares this slot and animation; null when nothing does. */
3409
3421
  declared: string | null;
@@ -3414,11 +3426,13 @@ export interface FoldRow {
3414
3426
  /** `check.json`'s `ANIMATIONS_DO_NOT_FOLD`: written whenever the motion holds an animation, the idle included. */
3415
3427
  export interface FoldsLine {
3416
3428
  status: 'PASS' | 'FAIL';
3417
- /** Every animation, the idle included, in motion.json's order: each one read. */
3429
+ /** Every animation read on the original build, the idle included, in motion.json's order. */
3418
3430
  animations: string[];
3419
3431
  fps: number;
3420
3432
  /** How many physics constraints the rig declares ({@link withoutPhysics}) — stepped in `physics_on` and left out in `physics_off`; 0 when the rig has none. */
3421
3433
  physics_left_out: number;
3434
+ /** Animations omitted from the keyed build when stripping physics removed their last timeline. */
3435
+ physics_off_skipped?: string[];
3422
3436
  /** Every mesh that folds in an animation read, in that animation's order and rigc's mesh order. */
3423
3437
  folding: FoldRow[];
3424
3438
  /** The rows no `may_fold` entry takes: the bar's figure. */
@@ -3644,7 +3658,9 @@ export function foldsLine(
3644
3658
  motion: Record<string, unknown> = {},
3645
3659
  context?: WeightStepContext,
3646
3660
  slotParts?: ReadonlyMap<string, string>,
3661
+ physicsOffSkipped: readonly string[] = [],
3647
3662
  ): FoldsLine {
3663
+ const offSkipped = new Set(physicsOffSkipped);
3648
3664
  const toSide = (m: FoldingMesh | undefined): FoldSide | null =>
3649
3665
  m === undefined ? null : { frames: m.frames, worst_frame: m.worstFrame, worst_triangles: m.worstTriangles, line: m.line };
3650
3666
  const folding: FoldRow[] = [];
@@ -3667,7 +3683,7 @@ export function foldsLine(
3667
3683
  const off = offList.find((m) => m.slot === slot && m.attachment === attachment);
3668
3684
  const primary = (on ?? off) as FoldingMesh;
3669
3685
  const entry = mayFold.find((e) => e.slot === slot && e.animation === name);
3670
- const onlyPhysicsOn = on !== undefined && off === undefined;
3686
+ const onlyPhysicsOn = on !== undefined && off === undefined && !offSkipped.has(name);
3671
3687
  const constraints = onlyPhysicsOn ? meshPhysicsConstraints(rig, slot, attachment, physicsList) : [];
3672
3688
  const row: FoldRow = {
3673
3689
  ...checkSlotRow('ANIMATIONS_DO_NOT_FOLD.folding', entry === undefined, slot, slotParts),
@@ -3688,14 +3704,16 @@ export function foldsLine(
3688
3704
  worstOf.set(row, primary.worstTriangleList);
3689
3705
  }
3690
3706
  }
3691
- const physics =
3707
+ const physics = (name: string): string =>
3692
3708
  physicsLeftOut === 0
3693
3709
  ? ''
3694
- : `, with its ${physicsLeftOut} physics constraint(s) on and off`;
3710
+ : `, with its ${physicsLeftOut} physics constraint(s) ${offSkipped.has(name) ? 'on' : 'on and off'}`;
3695
3711
  for (const r of folding) {
3696
3712
  if (r.declared !== null) continue;
3697
3713
  const sideClause =
3698
- r.physics_on !== null && r.physics_off === null && physicsLeftOut > 0
3714
+ offSkipped.has(r.animation)
3715
+ ? ' (physics off: SKIP — removing physics leaves no timeline)'
3716
+ : r.physics_on !== null && r.physics_off === null && physicsLeftOut > 0
3699
3717
  ? ` (physics on: ${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s)); physics off: 0 frame(s); physics constraint(s) on mesh "${r.attachment}": ${r.physics_constraints.join(', ')})`
3700
3718
  : r.physics_on !== null && r.physics_off !== null && physicsLeftOut > 0
3701
3719
  ? ` (physics on: ${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame}; physics off: ${r.physics_off.frames} frame(s), worst frame ${r.physics_off.worst_frame})`
@@ -3705,7 +3723,7 @@ export function foldsLine(
3705
3723
  problems.push({
3706
3724
  code: `CHECK_${FOLD_LINE}`,
3707
3725
  object: `animation "${r.animation}", mesh "${r.attachment}" (slot "${r.slot}")`,
3708
- detail: `rigc render --folds at ${fps} fps${physics}${sideClause}: ${r.line}; ${foldBonesText(rig, motion, r.slot, r.attachment, r.worst_frame, worstOf.get(r) ?? [], context)}; no triangle turned over against the setup pose is required — a fold the art means is declared in the --requirements file's may_fold, { "slot": "${r.slot}", "animation": "${r.animation}", "why": … }`,
3726
+ detail: `rigc render --folds at ${fps} fps${physics(r.animation)}${sideClause}: ${r.line}; ${foldBonesText(rig, motion, r.slot, r.attachment, r.worst_frame, worstOf.get(r) ?? [], context)}; no triangle turned over against the setup pose is required — a fold the art means is declared in the --requirements file's may_fold, { "slot": "${r.slot}", "animation": "${r.animation}", "why": … }`,
3709
3727
  });
3710
3728
  }
3711
3729
  const declaredNotFolding = mayFold.filter((e) => !folding.some((r) => r.slot === e.slot && r.animation === e.animation)).map((e) => ({ ...checkSlotRow('ANIMATIONS_DO_NOT_FOLD.declared_not_folding', true, e.slot, slotParts), slot: e.slot, animation: e.animation }));
@@ -3713,7 +3731,7 @@ export function foldsLine(
3713
3731
  problems.push({
3714
3732
  code: `CHECK_${FOLD_LINE}`,
3715
3733
  object: `${requirementsPath ?? 'the requirements file'} may_fold (slot "${e.slot}", animation "${e.animation}")`,
3716
- detail: `declares a fold, and rigc render --folds at ${fps} fps${physics} reads no folded triangle on slot "${e.slot}" in animation "${e.animation}"; an exception that excepts nothing is taken out of the file`,
3734
+ detail: `declares a fold, and rigc render --folds at ${fps} fps${physics(e.animation)} reads no folded triangle on slot "${e.slot}" in animation "${e.animation}"; an exception that excepts nothing is taken out of the file`,
3717
3735
  });
3718
3736
  }
3719
3737
  const undeclared = folding.filter((r) => r.declared === null).length;
@@ -3722,6 +3740,7 @@ export function foldsLine(
3722
3740
  animations: [...named],
3723
3741
  fps,
3724
3742
  physics_left_out: physicsLeftOut,
3743
+ ...(physicsOffSkipped.length === 0 ? {} : { physics_off_skipped: [...physicsOffSkipped] }),
3725
3744
  folding,
3726
3745
  folding_undeclared: undeclared,
3727
3746
  declared_not_folding: declaredNotFolding,
@@ -3911,7 +3930,8 @@ export function levelLine(feet: readonly LevelFoot[], rig: Record<string, unknow
3911
3930
  const names = readings.map((r) => r.animation);
3912
3931
  const line: LevelLine = { status, animations: names, fps, physics_left_out: physicsLeftOut, bar_degrees: LEVEL_BAR_DEGREES, bar: LEVEL_BAR_SOURCE, feet: rows.map(row => ({ ...row, ...checkRow('FEET_STAY_LEVEL.feet', 'part', row.status === 'FAIL', [row.part]) })) };
3913
3932
  if (status === 'SKIP') {
3914
- line.reason = `no frame of ${names.map((n) => `"${n}"`).join(', ')} turns a bone above ${rows.map((r) => `"${r.bone}" (which "${r.part}" rides)`).join(', ')}, so no foot was seen while its leg was posed`;
3933
+ line.reason = names.length === 0 ? 'no animation remains in the physics-off build'
3934
+ : `no frame of ${names.map((n) => `"${n}"`).join(', ')} turns a bone above ${rows.map((r) => `"${r.bone}" (which "${r.part}" rides)`).join(', ')}, so no foot was seen while its leg was posed`;
3915
3935
  }
3916
3936
  return line;
3917
3937
  }
@@ -6961,7 +6981,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
6961
6981
  let loopSet: FrameSet | null = null;
6962
6982
  let loopPhysics: LoopPhysics[] | null = null;
6963
6983
  // The keyed build (issues #183, #320): with a physics constraint, the same rig and motion with every one left out,
6964
- // built once the same way, which the loop and the folds of every animation are both read from.
6984
+ // built once the same way for the loop and the physics-off reading of the remaining animations.
6965
6985
  const stripped = withoutPhysics(inp.rig, inp.motion);
6966
6986
  let keyed: string | null = null;
6967
6987
  const keyedBuild = (what: string): string => {
@@ -7116,17 +7136,21 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
7116
7136
  const offDir = join(foldDir, 'off');
7117
7137
  const frOn = measured(['render', '--candidate', buildDir, '--folds', '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', onDir]);
7118
7138
  if (frOn.status !== 0) refuseIfAny(rigcFailed(`render --folds --fps ${fps}`, frOn, frOn.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
7119
- // The physics-off half takes no schedule (issue #538): its candidate declares no physics constraint, so no
7120
- // world moves it, and rigc render refuses a schedule on it by name.
7121
- const frOff = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', ...geometry, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', offDir]);
7122
- if (frOff.status !== 0) refuseIfAny(rigcFailed(`render --folds${geometry.map((g) => ` ${g}`).join('')} --fps ${fps} (physics constraint(s) left out)`, frOff, frOff.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
7123
7139
  const readingsOn = filterFolds(readFoldSets(onDir, animationNames, fps, frOn.out));
7124
- const readingsOff = filterFolds(readFoldSets(offDir, animationNames, fps, frOff.out));
7125
- folds = foldsLine(animationNames, fps, stripped.physics.length, readingsOn, mayFoldForRun, reqFile === null ? null : reqFile.path, foldProblems, readingsOff, inp.rig, stripped.physics, inp.motion, { config, stage: inp.stage }, checkSlotParts(inp.rig, inp.parts?.parts.map(p => p.name) ?? [], inp.parts?.alternates?.map(set => set.name) ?? []));
7140
+ const keyedNames = isRecord(stripped.motion.animations) ? Object.keys(stripped.motion.animations) : [];
7141
+ let readingsOff = new Map<string, FoldingMesh[]>();
7142
+ if (keyedNames.length > 0) {
7143
+ // The physics-off half takes no schedule (issue #538): its candidate declares no physics constraint, so no
7144
+ // world moves it, and rigc render refuses a schedule on it by name.
7145
+ const frOff = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', ...geometry, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', offDir]);
7146
+ if (frOff.status !== 0) refuseIfAny(rigcFailed(`render --folds${geometry.map((g) => ` ${g}`).join('')} --fps ${fps} (physics constraint(s) left out)`, frOff, frOff.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
7147
+ readingsOff = filterFolds(readFoldSets(offDir, keyedNames, fps, frOff.out));
7148
+ }
7149
+ folds = foldsLine(animationNames, fps, stripped.physics.length, readingsOn, mayFoldForRun, reqFile === null ? null : reqFile.path, foldProblems, readingsOff, inp.rig, stripped.physics, inp.motion, { config, stage: inp.stage }, checkSlotParts(inp.rig, inp.parts?.parts.map(p => p.name) ?? [], inp.parts?.alternates?.map(set => set.name) ?? []), stripped.droppedAnimations);
7126
7150
  if (feet.length > 0) {
7127
- const sets = readJson(join(offDir, 'frames.json'), []);
7151
+ const sets = keyedNames.length === 0 ? null : readJson(join(offDir, 'frames.json'), []);
7128
7152
  const listed = sets !== null && Array.isArray(sets.sets) ? sets.sets.filter(isRecord) : [];
7129
- const levelReadings = animationNames.map((name) => {
7153
+ const levelReadings = keyedNames.map((name) => {
7130
7154
  const dir = join(offDir, String((listed.find((x) => x.animation === name) as Record<string, unknown>).dir));
7131
7155
  return { animation: name, set: readFrameSet(dir), geometryPath: join(dir, GEOMETRY_FILE) };
7132
7156
  });
@@ -7857,7 +7881,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
7857
7881
  pack,
7858
7882
  packOpaque,
7859
7883
  idle: idle === null || loop === null ? null : { frames: idle.frames.length, fps: idle.fps, duration: idle.duration, lastIndex: idle.frames[idle.frames.length - 1].index, loopAt: { x: loop.x, y: loop.y } },
7860
- loopPhysics: loopPhysics === null ? null : loopPhysicsLine(loopPhysics),
7884
+ loopPhysics: loopPhysics === null ? null : loopPhysicsLine(loopPhysics, stripped?.droppedAnimations),
7861
7885
  seamViewport,
7862
7886
  bars,
7863
7887
  problems,