spine-rigc 1.9.2 → 1.9.4

package/src/assertions/model/index.ts

@@ -21,11 +21,14 @@
  * 🔸 **What the entry is given.** The document's text, the directory its
  * pages resolve against, and the profile — and nothing read off a Spine file:
  * a model-side verdict that read `skeleton.json` would be a second reading of
- * the encoding, which is the round trip's subject and not the rig's. Since cut
- * 4c-1 it is also given the rig info (as `validate()` is) and, in `given`, the
- * two values a `rigc-compiled/2` or `/1` document does not hold — the stage and
- * each page's `pma` (`./given.ts`). A `/3` document states both (issue #1026)
- * and is read for them; `given` beside one is refused by name.
+ * the encoding, which is the round trip's subject and not the rig's. In
+ * `given`, the two values a `rigc-compiled/2` or `/1` document does not hold —
+ * the stage and each page's `pma` (`./given.ts`); a `/3` document states both
+ * (issue #1026) and is read for them, and `given` beside one is refused by
+ * name. The rig info and the declared durations are the document's on every
+ * spec (issue #1054, `./declared.ts`): cuts 4c-1 to 4c-3 took them from the
+ * caller, as `validate()` does, and the verdict moved with what the caller
+ * handed over — now either one given beside the document is refused by name.
  *
  * ⛔ **Not wired into any command.** `build` keeps the round trip and its
  * forty-nine lines; this entry is what the selftest and the instrument call
@@ -50,6 +53,7 @@ import type { AtlasPageFacts } from '../facts/atlas_pages.ts';
 import type { SlotColourFacts } from '../facts/slot_colour.ts';
 import type { RigInfo } from '../../types.ts';
 import type { ModelGiven } from './given.ts';
+import { modelDeclaredDurations, modelRigInfo, refuseDeclaredBeside } from './declared.ts';
 import { a08RegionNamesMatchAttachments } from '../bodies/a08.ts';
 import { a13MeshBudget } from '../bodies/a13.ts';
 import { a14NoFullFrameMesh } from '../bodies/a14.ts';
@@ -59,13 +63,11 @@ import { a38SkinMembersAreSkinRequired } from '../bodies/a38.ts';
 import { a06AtlasPageSizeMatchesPng } from '../bodies/a06.ts';
 import { a19OverlayPngsHaveAlpha } from '../bodies/a19.ts';
 import { a27RegionNameMatchesPageFilename } from '../bodies/a27.ts';
-import { modelSkinMeshes } from './skin_meshes.ts';
 import { modelAnimatedBones } from './animated_bones.ts';
 import { modelSkinMembers } from './skin_members.ts';
 import { modelRegionJoins } from './region_joins.ts';
 import { modelAtlasRegions } from './atlas_regions.ts';
 import { modelStage } from './stage.ts';
-import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
 import type { AnimatedBoneFacts } from '../facts/animated_bones.ts';
 import type { SkinMemberFacts } from '../facts/skin_members.ts';
 import type { RegionJoinFacts } from '../facts/region_joins.ts';
@@ -134,7 +136,14 @@ export interface ModelValidateInput {
   /** The directory the document's page names resolve against — the build's `--out`. */
   atlasDir: string;
   profile: AssertionProfile;
-  /** The rig info the build carries, as `validate()` is handed it — A13, A15, A19 (cut 4c-1) and A20, A21, A28, A41, A47, A48 (cut 4c-2) and A24, A25, A26, A29, A30 (cut 4c-4) read it; optional because `ValidateInput.rig` is: absent for a bare directory, on both sides. */
+  /**
+   * Refused (issue #1054): every document states the rig info in its `rig`
+   * section, and the model side reads it there (`./declared.ts`). A caller
+   * that gives it anyway is a second source for one fact, and each rule that
+   * reads the declarations refuses the call by name rather than reading
+   * either. Kept on the type so a caller still handing it over is named, not
+   * silently ignored.
+   */
   rig?: RigInfo;
   /**
    * The stage and the pages' `pma`, for a `rigc-compiled/2` or `/1` document,
@@ -144,7 +153,7 @@ export interface ModelValidateInput {
    * `given` beside it is refused by name.
    */
   given?: ModelGiven;
-  /** The motion spec's declared durations, as `validate()` is handed them — A09 reads them (cut 4c-3); absent where the caller has no motion spec, on both sides. */
+  /** Refused, as `rig` is (issue #1054): every document states each animation's declared duration, and A09 reads them there. */
   declaredDurations?: Record<string, number>;
 }
 
@@ -164,7 +173,6 @@ export interface ModelSupply {
   skinEntries: (read: ReadDocument) => SkinEntryFacts;
   atlasPages: (read: ReadDocument) => AtlasPageFacts;
   slotColour: (read: ReadDocument) => SlotColourFacts;
-  skinMeshes: (read: ReadDocument) => SkinMeshFacts;
   animatedBones: (read: ReadDocument) => AnimatedBoneFacts;
   skinMembers: (read: ReadDocument) => SkinMemberFacts;
   regionJoins: (read: ReadDocument) => RegionJoinFacts;
@@ -184,6 +192,10 @@ export interface ModelSupply {
   sliderComposition: (read: ReadDocument) => SliderCompositionFacts;
   constraintTargets: (read: ReadDocument) => ConstraintTargetFacts;
   steppedPoses: (read: ReadDocument) => SteppedPoseFacts;
+  /** The rig info the document declares (issue #1054, `./declared.ts`); a caller's `rig` beside it is refused by name. */
+  rigInfo: (read: ReadDocument, input: ModelValidateInput) => RigInfo;
+  /** Each animation's declared duration as the document states it (issue #1054); a caller's `declaredDurations` beside it is refused by name. */
+  declaredDurations: (read: ReadDocument, input: ModelValidateInput) => Record<string, number>;
 }
 
 /** The suppliers the model side runs on. */
@@ -191,7 +203,6 @@ export const MODEL_SUPPLY: ModelSupply = {
   skinEntries: modelSkinEntries,
   atlasPages: modelAtlasPages,
   slotColour: modelSlotColour,
-  skinMeshes: modelSkinMeshes,
   animatedBones: modelAnimatedBones,
   skinMembers: modelSkinMembers,
   regionJoins: modelRegionJoins,
@@ -211,12 +222,21 @@ export const MODEL_SUPPLY: ModelSupply = {
   sliderComposition: modelSliderComposition,
   constraintTargets: modelConstraintTargets,
   steppedPoses: modelSteppedPoses,
+  rigInfo: (read, input) => {
+    refuseDeclaredBeside(read, input, 'rig');
+    return modelRigInfo(read);
+  },
+  declaredDurations: (read, input) => {
+    refuseDeclaredBeside(read, input, 'declaredDurations');
+    return modelDeclaredDurations(read);
+  },
 };
 
 /**
  * One moved assertion: its code, and how the model side runs its body once the
- * document is read. The list is the registry of what has moved — each later
- * cut appends its rows — and the selftest reads it for the codes it compares.
+ * document is read. The list is the registry of what has moved — a later cut
+ * puts its rows where `validate()` runs those rules, not at the end — and the
+ * selftest reads it for the codes it compares.
  */
 export interface MovedAssertion {
   code: string;
@@ -241,53 +261,56 @@ export interface MovedAssertion {
 }
 
 /**
- * The moved assertions, in `validate()`'s report order (the order its `check`
- * calls stand in; the selftest and the instrument compare per code). `SKIP_NO_ATLAS` for
+ * The moved assertions, in `validate()`'s report order — the order its `check`
+ * calls stand in, so a model-side report lists its PASS, SKIP and FAIL lines in
+ * the order the round trip's does. The seven cuts of issue #1025 appended their
+ * rows in landing order; issue #1054 put them back, and the selftest's `VF16`
+ * names a row that stands out of that order. `SKIP_NO_ATLAS` for
  * A17 rather than `SKIP_NO_MODEL` because that is what A17 says over a missing
  * atlas on either side: its body reads only the pages, and on this side no
  * document means no pages.
  */
 export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A08_REGION_NAMES_MATCH_ATTACHMENTS', run: (v, read, _input, supply) => (read.doc.pages === null ? v.skip('A08_REGION_NAMES_MATCH_ATTACHMENTS', SKIP_NO_MODEL_PAGES) : a08RegionNamesMatchAttachments(v, supply.regionJoins(read), new Set<string>())), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A32_EVENT_KEYS_RESOLVE', run: (v, read, _input, supply) => a32EventKeysResolve(v, supply.eventKeys(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A34_CONSTRAINT_TIMELINE_TARGETS', run: (v, read, _input, supply) => a34ConstraintTimelineTargets(v, supply.constraintTargets(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A12_NO_DARK_COLOR', run: (v, read, _input, supply) => a12NoDarkColor(v, supply.skeletonRoster(read), supply.slotColour(read).slotTimelines), unread: SKIP_NO_MODEL, beforeTheParse: true },
   { code: 'A03_REGION_WIDTH_HEIGHT_FINITE', run: (v, read, _input, supply) => a03RegionWidthHeightFinite(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
   { code: 'A04_MESH_TRIANGLES_AND_ENCODING', run: (v, read, _input, supply) => a04MeshTrianglesAndEncoding(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
   { code: 'A33_VERTEX_ATTACHMENT_GEOMETRY', run: (v, read, _input, supply) => a33VertexAttachmentGeometry(v, supply.polygons(read)), unread: SKIP_NO_MODEL },
   { code: 'A11_NO_CLIPPING_ATTACHMENTS', run: (v, read, _input, supply) => a11NoClippingAttachments(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
-  { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.skinMeshes(read), input), unread: SKIP_NO_MODEL },
-  { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.skinMeshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
-  { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.skinMeshes(read), supply.animatedBones(read), input), unread: SKIP_NO_MODEL },
-  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.skinMeshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.meshes(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
+  { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.meshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.meshes(read), supply.animatedBones(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
+  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A23_PHYSICS_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a23PhysicsConstraintEffective(v, supply.constraints(read), supply.meshes(read)), unread: SKIP_NO_MODEL },
-  { code: 'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP', run: (v, read, input, supply) => a41PhysicsSurvivesEditorRoundTrip(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP', run: (v, read, input, supply) => a41PhysicsSurvivesEditorRoundTrip(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A36_PATH_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a36PathConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A37_SLIDER_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a37SliderConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
-  { code: 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a47IkConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a48TransformConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a47IkConstraintNotMutedThroughout(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a48TransformConstraintNotMutedThroughout(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', run: (v, read, _input, supply) => a40SlidersComposeOnASharedTarget(v, supply.sliderComposition(read), supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER', run: (v, read, _input, supply) => a42DrivenConstraintsUpdateAfterTheirDriver(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED', run: (v, read, _input, supply) => a38SkinMembersAreSkinRequired(v, supply.skinMembers(read)), unread: SKIP_NO_MODEL },
+  { code: 'A09_ANIMATION_DURATION_MATCHES_SPEC', run: (v, read, input, supply) => a09AnimationDurationMatchesSpec(v, supply.animationDurations(read), supply.declaredDurations(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A10_NO_NAN_AFTER_STEPPING', run: (v, read, _input, supply) => a10NoNanAfterStepping(v, supply.boneTimelines(read), supply.steppedPoses(read)), unread: SKIP_NO_MODEL },
+  { code: 'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', run: (v, read, _input, supply) => a43TwoColorTintLoadsAndPosesAsWritten(v, supply.twoColour(read)), unread: SKIP_NO_MODEL },
   { code: 'A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN', run: (v, read, _input, supply) => a45SeparableColorTimelinesOwnTheirChannelsAndPoseAsWritten(v, supply.slotColour(read)), unread: SKIP_NO_MODEL },
   { code: 'A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', run: (v, read, _input, supply) => a44LinkedMeshStatesNoGeometryOfItsOwn(v, supply.links(read)), unread: SKIP_NO_MODEL },
+  { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
   { code: 'A17_ATLAS_PAGE_FILES_EXIST', run: (v, read, input, supply) => a17AtlasPageFilesExist(v, supply.atlasPages(read), input), unread: SKIP_NO_ATLAS },
   { code: 'A06_ATLAS_PAGE_SIZE_MATCHES_PNG', run: (v, read, input, supply) => a06AtlasPageSizeMatchesPng(v, supply.atlasRegions(read, input), input, input.profile === 'spine-html'), unread: SKIP_NO_ATLAS },
-  { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), input), unread: SKIP_NO_ATLAS },
+  { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), { atlasDir: input.atlasDir, rig: supply.rigInfo(read, input) }), unread: SKIP_NO_ATLAS },
+  { code: 'A24_AXIS_SPACE_STROKE', run: (v, read, input, supply) => a24AxisSpaceStroke(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A25_DETACHED_BONE_PARENTAGE', run: (v, read, input, supply) => a25DetachedBoneParentage(v, supply.skeletonRoster(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A26_SLOT_DRAW_ORDER', run: (v, read, input, supply) => a26SlotDrawOrder(v, supply.skeletonRoster(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
   { code: 'A27_REGION_NAME_MATCHES_PAGE_FILENAME', run: (v, read, input, supply) => a27RegionNameMatchesPageFilename(v, supply.atlasRegions(read, input)), unread: SKIP_NO_ATLAS },
-  { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A32_EVENT_KEYS_RESOLVE', run: (v, read, _input, supply) => a32EventKeysResolve(v, supply.eventKeys(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A12_NO_DARK_COLOR', run: (v, read, _input, supply) => a12NoDarkColor(v, supply.skeletonRoster(read), supply.slotColour(read).slotTimelines), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A24_AXIS_SPACE_STROKE', run: (v, read, input, supply) => a24AxisSpaceStroke(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A25_DETACHED_BONE_PARENTAGE', run: (v, read, input, supply) => a25DetachedBoneParentage(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A26_SLOT_DRAW_ORDER', run: (v, read, input, supply) => a26SlotDrawOrder(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A09_ANIMATION_DURATION_MATCHES_SPEC', run: (v, read, input, supply) => a09AnimationDurationMatchesSpec(v, supply.animationDurations(read), input.declaredDurations), unread: SKIP_NO_MODEL },
-  { code: 'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', run: (v, read, _input, supply) => a43TwoColorTintLoadsAndPosesAsWritten(v, supply.twoColour(read)), unread: SKIP_NO_MODEL },
-  { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
-  { code: 'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', run: (v, read, _input, supply) => a40SlidersComposeOnASharedTarget(v, supply.sliderComposition(read), supply.constraints(read)), unread: SKIP_NO_MODEL },
-  { code: 'A34_CONSTRAINT_TIMELINE_TARGETS', run: (v, read, _input, supply) => a34ConstraintTimelineTargets(v, supply.constraintTargets(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A10_NO_NAN_AFTER_STEPPING', run: (v, read, _input, supply) => a10NoNanAfterStepping(v, supply.boneTimelines(read), supply.steppedPoses(read)), unread: SKIP_NO_MODEL },
+  { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
 ];
 
 /** The codes the model side prints: its two parse rules, then the moved assertions. */

package/src/assertions/model/mesh_attachments.ts

@@ -16,12 +16,21 @@
  *   — the two lookups the core poses a linked mesh through — and its hull
  *   the source record's, read where those two read it.
  * - **The counts the parser derives**: `worldVerticesLength` is the length
- *   of `uvs` (the length the parser hands its vertex reader for a mesh), and
+ *   of `uvs` (the length the parser hands its vertex reader for a mesh — the
+ *   reader refuses a document whose `uvs` are not one pair per vertex, so it is
+ *   also two per vertex), and
  *   `hullLength` twice the record's `hull`, which the parser reads at the
  *   mesh row's default of the parser-default table when the key is absent
  *   (`PARSER_DEFAULTS` in `src/keyorder.ts`, which the selftest holds to the
  *   parser row by row).
  *
+ * - **`width` and `height`** are the record's, off the document's JSON — a
+ *   link's its source record's, the two numbers the runtime's `setSourceMesh`
+ *   writes over the link's own: the core's geometry reader keeps a mesh's
+ *   vertices, UVs and triangles and not its size, which no pose reads. Since
+ *   issue #1054 this is the one family of the meshes; cut 4c-1's
+ *   `SkinMeshFacts` stated the same entries with these two numbers added.
+ *
  * `encoding` is empty on every entry: the document states the weighted form
  * outright and names bones, so the clauses about the flat run have no subject
  * here (`../facts/mesh_attachments.ts`'s 🔒).
@@ -35,6 +44,19 @@ import type { ModelVertices } from '../../model.ts';
 import type { MeshBinding, MeshEntry, MeshFacts } from '../facts/mesh_attachments.ts';
 import { fileOrderedEntries } from './skin_entries.ts';
 import type { ReadDocument } from './parse.ts';
+import { isObj } from '../values.ts';
+
+/** A record's own `width` and `height` as the document states them, found by skin (the first of that name, as a link resolves its skin), slot and placeholder. */
+function statedSize(read: ReadDocument, skin: string, slot: string, placeholder: string): { width: number; height: number } {
+  const skins = Array.isArray(read.json.skins) ? read.json.skins : [];
+  const found = skins.find((k: unknown) => isObj(k) && k.name === skin);
+  const table = isObj(found) && isObj(found.attachments) ? found.attachments[slot] : undefined;
+  const record = isObj(table) ? table[placeholder] : undefined;
+  if (!isObj(record) || typeof record.width !== 'number' || typeof record.height !== 'number') {
+    throw new Error(`internal: skin "${skin}" slot "${slot}" placeholder "${placeholder}" is a mesh record the document states no width and height for`);
+  }
+  return { width: record.width, height: record.height };
+}
 
 /** The parser's reading of a mesh with no `hull` key, off the parser-default table. */
 function hullDefault(): number {
@@ -58,8 +80,10 @@ export function modelMeshFacts(read: ReadDocument): MeshFacts {
     let uvs: readonly number[];
     let triangles: readonly number[];
     let hull: number | undefined;
+    let size: { width: number; height: number };
     if (g.kind === 'mesh') {
       ({ vertices, uvs, triangles, hull } = g);
+      size = statedSize(read, entry.skin, entry.slot, entry.placeholder);
     } else {
       // `readModel` resolves every link to a mesh or refuses the document, so a miss here is this module's defect.
       const found = sourceVertices(g.skin, g.slot, g.source);
@@ -69,19 +93,24 @@ export function modelMeshFacts(read: ReadDocument): MeshFacts {
       ({ uvs, triangles } = drawn);
       const source = doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
       hull = source?.kind === 'mesh' ? source.hull : undefined;
+      size = statedSize(read, g.skin, g.slot, g.source);
     }
+    const bone = slotBone.get(entry.slot);
+    if (bone === undefined) throw new Error(`internal: ${where} names a slot the reader accepted and the document does not hold`);
     const weights: MeshBinding[][] | null = vertices.weighted ? vertices.bindings.map((influences) => influences.map((b) => ({ bone: indexOf(b.bone), weight: Math.fround(b.weight) }))) : null;
     meshes.push({
       name: shownRow(entry).name,
       skin: entry.skin,
       slot: entry.slot,
-      slotBone: slotBone.get(entry.slot) ?? '',
+      slotBone: bone,
       placeholder: entry.placeholder,
       link: g.kind === 'linkedmesh' ? { source: g.source } : null,
       triangles,
       worldVerticesLength: uvs.length,
       regionUVs: uvs,
       hullLength: 2 * (hull ?? hullDefault()),
+      width: size.width,
+      height: size.height,
       weights,
       encoding: [],
     });

package/src/assertions/model/parse.ts

@@ -40,6 +40,7 @@
 import { CORE_REGION_KINDS, CoreInputError, readModel, shownRow, type CompiledDocument } from '../../core/index.ts';
 import { documentPageLookup, frameRegionName, readUvSequences } from '../../core/uvs.ts';
 import type { AssertionKind } from '../kinds.ts';
+import { rigSectionProblems } from './declared.ts';
 import type { Verdicts } from '../harness.ts';
 
 /** The reader's refusal, as a line. */
@@ -76,7 +77,14 @@ export function modelRead({ fail }: Verdicts, modelText: string): ReadDocument |
     fail(A00_MODEL_READ, err.message);
     return null;
   }
-  return { doc, json: JSON.parse(modelText) as Record<string, unknown> };
+  const json = JSON.parse(modelText) as Record<string, unknown>;
+  // Issue #1054: the rig section is a source the model side reads (`./declared.ts`), so it is read here with the rest — refused by its paths, never cast.
+  const rigProblems = rigSectionProblems(json);
+  if (rigProblems.length > 0) {
+    fail(A00_MODEL_READ, `the model document: ${rigProblems.length} problem(s) in the rig section the model side reads its declarations from: ${rigProblems.join('; ')}`);
+    return null;
+  }
+  return { doc, json };
 }
 
 /**

package/src/assertions/model/runtime_timelines.ts

@@ -0,0 +1,78 @@
+/**
+ * The runtime's words for each timeline a document's animation can hold
+ * (issue #1054): the class it loads as, the property ids it registers and what
+ * those ids carry — the values A40's sentence prints, which the document has no
+ * field for and the core has no reason to know.
+ *
+ * ⭐ **Why they live here and not beside the core's table.** Until issue #1054
+ * this table stood in `src/core/additive.ts`, beside the mode each kind's
+ * application has: 34 runtime class names and their property names as string
+ * literals in a module that otherwise speaks the document's words (#1011's
+ * second ask). The mode is the core's — it decides what the probe computes —
+ * and stays there, keyed by the document's own words (`ADDITIVE_MODE`); what
+ * the runtime calls the timeline is a fact about the validator's other
+ * supplier, and sits here with the constraint classes' names
+ * (`RUNTIME_CONSTRAINT_CLASS`, `./constraints.ts`). Both tables are keyed by
+ * the same spelling (`additiveSpelling`), and the selftest's `CO27` holds
+ * every row of both against the timeline objects spine-core loads, over a
+ * seeded population reaching every spelling.
+ *
+ * Read off the loaded timeline objects, never written from the runtime's
+ * source: the class is the object's constructor name, the properties its
+ * registered ids' names.
+ *
+ * Links nothing from the runtime.
+ */
+
+/** What a timeline's property ids are followed by: its target's index (and, for an attachment's, the attachment), or nothing. */
+export type RuntimeTimelineAddress = 'bone' | 'slot' | 'attachment' | 'constraint' | 'none';
+
+/** One timeline spelling, as the runtime loads it: its class, the properties it registers in order, and what its ids carry. */
+export interface RuntimeTimelineRow {
+  runtimeClass: string;
+  properties: readonly string[];
+  address: RuntimeTimelineAddress;
+}
+
+const row = (runtimeClass: string, properties: readonly string[], address: RuntimeTimelineAddress): RuntimeTimelineRow => ({ runtimeClass, properties, address });
+
+/** Every timeline spelling a document's animation can hold (`additiveSpelling`'s keys), as the runtime loads it. */
+export const RUNTIME_TIMELINE: Readonly<Record<string, RuntimeTimelineRow>> = {
+  'bone rotate': row('RotateTimeline', ['rotate'], 'bone'),
+  'bone translate': row('TranslateTimeline', ['x', 'y'], 'bone'),
+  'bone translatex': row('TranslateXTimeline', ['x'], 'bone'),
+  'bone translatey': row('TranslateYTimeline', ['y'], 'bone'),
+  'bone scale': row('ScaleTimeline', ['scaleX', 'scaleY'], 'bone'),
+  'bone scalex': row('ScaleXTimeline', ['scaleX'], 'bone'),
+  'bone scaley': row('ScaleYTimeline', ['scaleY'], 'bone'),
+  'bone shear': row('ShearTimeline', ['shearX', 'shearY'], 'bone'),
+  'bone shearx': row('ShearXTimeline', ['shearX'], 'bone'),
+  'bone sheary': row('ShearYTimeline', ['shearY'], 'bone'),
+  'bone inherit': row('InheritTimeline', ['inherit'], 'bone'),
+  'slot attachment': row('AttachmentTimeline', ['attachment'], 'slot'),
+  'slot rgba': row('RGBATimeline', ['rgb', 'alpha'], 'slot'),
+  'slot rgb': row('RGBTimeline', ['rgb'], 'slot'),
+  'slot alpha': row('AlphaTimeline', ['alpha'], 'slot'),
+  'slot rgba2': row('RGBA2Timeline', ['rgb', 'alpha', 'rgb2'], 'slot'),
+  'slot rgb2': row('RGB2Timeline', ['rgb', 'rgb2'], 'slot'),
+  'attachment deform': row('DeformTimeline', ['deform'], 'attachment'),
+  'attachment sequence': row('SequenceTimeline', ['sequence'], 'attachment'),
+  ik: row('IkConstraintTimeline', ['ikConstraint'], 'constraint'),
+  transform: row('TransformConstraintTimeline', ['transformConstraint'], 'constraint'),
+  'path position': row('PathConstraintPositionTimeline', ['pathConstraintPosition'], 'constraint'),
+  'path spacing': row('PathConstraintSpacingTimeline', ['pathConstraintSpacing'], 'constraint'),
+  'path mix': row('PathConstraintMixTimeline', ['pathConstraintMix'], 'constraint'),
+  'physics inertia': row('PhysicsConstraintInertiaTimeline', ['physicsConstraintInertia'], 'constraint'),
+  'physics strength': row('PhysicsConstraintStrengthTimeline', ['physicsConstraintStrength'], 'constraint'),
+  'physics damping': row('PhysicsConstraintDampingTimeline', ['physicsConstraintDamping'], 'constraint'),
+  'physics mass': row('PhysicsConstraintMassTimeline', ['physicsConstraintMass'], 'constraint'),
+  'physics wind': row('PhysicsConstraintWindTimeline', ['physicsConstraintWind'], 'constraint'),
+  'physics gravity': row('PhysicsConstraintGravityTimeline', ['physicsConstraintGravity'], 'constraint'),
+  'physics mix': row('PhysicsConstraintMixTimeline', ['physicsConstraintMix'], 'constraint'),
+  // A reset registers its property with no constraint index, named or not (measured: both read `physicsConstraintReset`).
+  'physics reset': row('PhysicsConstraintResetTimeline', ['physicsConstraintReset'], 'none'),
+  'slider time': row('SliderTimeline', ['sliderTime'], 'constraint'),
+  'slider mix': row('SliderMixTimeline', ['sliderMix'], 'constraint'),
+  drawOrder: row('DrawOrderTimeline', ['drawOrder'], 'none'),
+  events: row('EventTimeline', ['event'], 'none'),
+};

package/src/assertions/model/slider_composition.ts

@@ -16,16 +16,17 @@
  *   timelines at their three levels in the order the file keys them
  *   (`keyedOrder` over the document's order, deform before sequence —
  *   `emitAttachmentTimelines`' order), then the draw order and the events.
- * - **The words.** Each timeline's class name and properties are the core's
- *   table (`ADDITIVE_APPLY`, `src/core/additive.ts`), the one value here that
- *   is not the document's, measured off the loaded timelines; an id's index is
+ * - **The words.** Each timeline's class name and properties are the
+ *   validator's table (`RUNTIME_TIMELINE`, `./runtime_timelines.ts`; the
+ *   core's until issue #1054), the one value here that is not the document's,
+ *   measured off the loaded timelines; an id's index is
  *   the target's position in the document's bones, slots or constraints —
  *   which the emitter writes in that order — `-1` for a physics timeline
  *   naming none; a deform's attachment is named as the runtime names it, the
  *   record's `name`, else its placeholder.
  * - **The behaviour** is the core's probe over the document under no skin set
- *   (`noSkinView`, which refuses by name a document whose skins it was not
- *   measured over) and under each skin (`underSkin`): `additiveCells`, and the
+ *   (`noSkinView`, the view measured in issue #1051) and under each skin
+ *   (`underSkin`): `additiveCells`, and the
  *   class `additiveBehaviour` reads off them. The core suite's `CO27` holds
  *   both to the runtime's probe; the selftest asks this supplier every
  *   question the body asks the runtime's (`VF14`).
@@ -33,7 +34,8 @@
  * Links nothing from the runtime.
  */
 import { fileSkinOrder, keyedOrder } from '../../compile.ts';
-import { ADDITIVE_APPLY, additiveBehaviour, additiveCells, additiveSpelling, type AdditiveTimeline, type AdditiveView } from '../../core/additive.ts';
+import { additiveBehaviour, additiveCells, additiveSpelling, type AdditiveTimeline, type AdditiveView } from '../../core/additive.ts';
+import { RUNTIME_TIMELINE } from './runtime_timelines.ts';
 import { EVERY_GLOBAL_PHYSICS, type PhysicsTimelineKind } from '../../core/constraints_physics.ts';
 import { underSkin, type CompiledDocument } from '../../core/index.ts';
 import type { BoneTimelineKind, SlotTimelineKind } from '../../core/animation.ts';
@@ -57,8 +59,8 @@ const keyedFirsts = (names: readonly string[]): string[] => keyedOrder(names.fil
 
 /** The words of one timeline: the table's class and properties, each id addressed by `index` (and `attachment`), and the sentence's naming. */
 function factOf(doc: CompiledDocument, core: AdditiveTimeline): SliderTimelineFact {
-  const row = ADDITIVE_APPLY[additiveSpelling(core)];
-  if (row === undefined) throw new Error(`internal: "${additiveSpelling(core)}" is no row of the additive table`);
+  const row = RUNTIME_TIMELINE[additiveSpelling(core)];
+  if (row === undefined) throw new Error(`internal: "${additiveSpelling(core)}" is no row of the runtime's timeline table`);
   const property = (p: string, index: number | null, attachment: string | null, names: string) => ({
     id: [p, ...(index === null ? [] : [String(index)]), ...(attachment === null ? [] : [attachment])].join('|'),
     property: p,

package/src/assertions/model/stepped_poses.ts

@@ -21,8 +21,9 @@
  *   name, so on this side every bone of every pose holds one and the answer is
  *   `null` — derived from the pose rather than assumed, so a reader that
  *   started admitting such a spelling would show up here as a bone with none.
- * - **Under no skin set**, as `validate()` poses (`noSkinView`), which refuses
- *   by name a document whose default skin it cannot read that way.
+ * - **Under no skin set**, as `validate()` poses (`noSkinView`, the view
+ *   measured in issue #1051: no skin's bones or constraints applied, a slot
+ *   looked up in the default skin alone).
  *
  * Links nothing from the runtime.
  */

package/src/bonedist.ts

@@ -84,14 +84,13 @@ import {
   type BoneSnapshot,
   type Posable,
 } from './render.ts';
+import { BONEDIST_SPEC, IDENTITY_CORRESPONDENCE } from './correspondence.ts';
 
 export class BoneDistError extends Error {}
 
-/** The sidecar spec a correspondence file declares, and the report's own. */
-export const BONEDIST_SPEC = 'rigc-bonedist/1';
-
-/** What `--bones identity` is spelled as, where a file path would go. */
-export const IDENTITY_CORRESPONDENCE = 'identity';
+// `BONEDIST_SPEC` and `IDENTITY_CORRESPONDENCE` are `./correspondence.ts`'s since issue #1052: the CLI's help names
+// both, and an entry that links nothing of the runtime prints that help. Re-exported here.
+export { BONEDIST_SPEC, IDENTITY_CORRESPONDENCE };
 
 /** How many bones the report's per-bone table shows before it says "and N more". */
 export const BONE_TABLE_ROWS = 8;

package/src/check.ts

@@ -92,13 +92,14 @@ import {
   type FramesSidecar,
   type FrameSet,
   type MakeCorePoser,
-  type Posable,
   type PoseOptions,
   type Poser,
   type PoserName,
   type TextureSubstitution,
   type Viewport,
-} from './render.ts';
+} from './render_shared.ts';
+// The one name here that is the runtime's: a candidate's pages, read off the shape spine-core's loader returns.
+import type { Posable } from './render.ts';
 import {
   applyFit,
   boxHeight,

package/src/checkpics.ts

@@ -48,7 +48,7 @@ import {
   type Framing,
   type FrameCheck,
 } from './check.ts';
-import { FRAMES_SIDECAR, FRAMES_SPEC } from './render.ts';
+import { FRAMES_SIDECAR, FRAMES_SPEC } from './render_shared.ts';
 import { isContent } from './framing.ts';
 import { isAttributable } from './slots.ts';
 import { encodePng, Plate, type RGBA } from '../tools/plate.ts';