spine-rigc 1.9.2 → 1.9.3

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';