spine-rigc 1.5.3 → 1.6.2

package/src/transform.ts

@@ -31,7 +31,29 @@
  * wrong. `computeWorldTransforms` below is `BonePose.updateWorldTransform`
  * (spine-core 4.3.13, `BonePose.js:110-216`) at setup, with a skeleton scale of 1.
  */
-import type { SpineBone } from './types.ts';
+/**
+ * What `computeWorldTransforms` reads off a bone — a structural type, so both a
+ * Spine bone (`SpineBone`, what spine-parts and every skeleton reader hold) and
+ * a compiled-model bone (`ModelBone`, what `compile` holds) satisfy it as they
+ * are, without a cast.
+ *
+ * The two differ in one key, the inherit mode: Spine 4.3 spells it `inherit`
+ * and the model `inheritMode`. The union below admits exactly one of the two on
+ * any one bone (the other is `never`), so a bone carrying both is a type error
+ * rather than a question of which one wins, and the mode is read as
+ * `inheritMode ?? inherit` — whichever the bone has.
+ */
+export type PosableBone = {
+  name: string;
+  parent?: string;
+  x?: number;
+  y?: number;
+  rotation?: number;
+  scaleX?: number;
+  scaleY?: number;
+  shearX?: number;
+  shearY?: number;
+} & ({ inherit?: string; inheritMode?: never } | { inheritMode?: string; inherit?: never });
 
 export interface BoneTransform {
   a: number;
@@ -79,7 +101,7 @@ export function cropToSpineY(cropY: number, cropHeight: number): number {
  * inheriting rig emits moves by a byte. The five `inherit` cases are the
  * runtime's, transcribed.
  */
-export function computeWorldTransforms(bones: SpineBone[]): Map<string, BoneTransform> {
+export function computeWorldTransforms(bones: readonly PosableBone[]): Map<string, BoneTransform> {
   const out = new Map<string, BoneTransform>();
   for (const bone of bones) {
     const rotation = bone.rotation ?? 0;
@@ -144,8 +166,8 @@ const INHERIT_MODES: readonly InheritMode[] = ['normal', 'onlyTranslation', 'noR
  * leaves the matrix where it was, and the rig spec's parse refuses that
  * spelling first (issue #733), so reaching this throw is rigc's own defect.
  */
-function inheritMode(bone: SpineBone): InheritMode {
-  const value = bone.inherit;
+function inheritMode(bone: PosableBone): InheritMode {
+  const value = bone.inheritMode ?? bone.inherit;
   if (value === undefined) return 'normal';
   const folded = value.length === 0 ? value : value[0].toLowerCase() + value.slice(1);
   const mode = INHERIT_MODES.find((m) => m === folded);

package/src/types.ts

@@ -19,6 +19,7 @@ import type { DeformTransform, DeformTransformReport } from './deformgen.ts';
 import type { TurnCeiling } from './depth.ts';
 import type { SpecEnumTable, SpecTypeRow } from './keys.ts';
 import type { MeshKind } from './mesh.ts';
+import type { CompiledModel } from './model.ts';
 import type { TrackDerive, TrackDeriveReport } from './trackgen.ts';
 
 // ---------------------------------------------------------------------------
@@ -1320,6 +1321,12 @@ export interface SpineSkeletonJson {
   >;
 }
 
+/** One entry of the emitted `skins` array — what `emitSkins` in `src/emit_spine.ts` writes per skin. */
+export type SpineSkin = SpineSkeletonJson['skins'][number];
+
+/** One animation of the emitted `animations` object — what `emitAnimations` in `src/emit_spine.ts` writes per animation. */
+export type SpineAnimation = SpineSkeletonJson['animations'][string];
+
 /** One entry of the emitted `events` map: the payload a firing inherits. */
 export interface SpineEvent {
   int?: number;
@@ -1550,6 +1557,17 @@ export interface DroppedState {
 }
 
 export interface CompileResult {
+  /**
+   * The compiled model (`src/model.ts`): what the skeleton below was emitted
+   * from. This cut fills its `bones` and `setupWorld`; every other field is
+   * this result's own, carried by reference.
+   */
+  model: CompiledModel;
+  /**
+   * The Spine 4.3 skeleton: `emitSkeleton`'s value over `model` (issue #922),
+   * the one call the assembly makes. `build` writes its text, and beside it
+   * `modelDocument(model)` as `skeleton.model.json`.
+   */
   skeleton: SpineSkeletonJson;
   skeletonText: string;
   atlasText: string;

package/src/validate.ts

@@ -355,8 +355,14 @@ export interface ValidateInput {
   atlasDir: string;
   /** Declared durations from the motion spec. */
   declaredDurations?: Record<string, number>;
-  /** Re-emitted artifacts, for the determinism check. */
-  reEmit?: { skeletonText: string; atlasText: string };
+  /**
+   * The compiled model's document (`modelDocument`, `rigc-compiled/1`) — the
+   * third file `build` writes. Required whenever `reEmit` is given, since `A18`
+   * compares it with the second compile's (issue #922).
+   */
+  modelText?: string;
+  /** Re-emitted artifacts, for the determinism check: a second, independent compile's three texts. */
+  reEmit?: { skeletonText: string; atlasText: string; modelText: string };
   /**
    * Structural expectations the artifact cannot state about itself: which mesh is
    * a ribbon, which bone carries the axis, which parentage is forbidden, what the
@@ -1123,6 +1129,19 @@ export function timelineAddBehaviour(data: ReturnType<SkeletonJson['readSkeleton
   return wrote ? 'overwrites' : 'inert';
 }
 
+/**
+ * Where two texts first differ, as A18 names it: the 1-based line and each
+ * side's line, trimmed and cut to 120 characters.
+ */
+function firstDifferingLine(first: string, second: string): string {
+  const a = first.split('\n');
+  const b = second.split('\n');
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i += 1;
+  const cut = (line: string | undefined): string => (line === undefined ? '(end of text)' : JSON.stringify(line.trim().slice(0, 120)));
+  return `${i + 1}: ${cut(a[i])} first, ${cut(b[i])} second`;
+}
+
 export function validate(input: ValidateInput): ValidateReport {
   const failures: Failure[] = [];
   const passed: string[] = [];
@@ -6149,6 +6168,15 @@ export function validate(input: ValidateInput): ValidateReport {
     if (input.reEmit.atlasText !== input.atlasText) {
       fail('A18_DETERMINISTIC_EMIT', 'recompiling produced a different skeleton.atlas');
     }
+    // The model document is compared like the Spine pair (issue #922): it is
+    // written beside them, and a map iterated in an order nothing fixed would
+    // reach it before it reached either of them — the document writes every
+    // `Map` of the model as an array in the map's order.
+    if (input.modelText === undefined) {
+      fail('A18_DETERMINISTIC_EMIT', 'a second compile was handed over with no first model document to compare its skeleton.model.json against');
+    } else if (input.reEmit.modelText !== input.modelText) {
+      fail('A18_DETERMINISTIC_EMIT', `recompiling produced a different skeleton.model.json (first differing line ${firstDifferingLine(input.modelText, input.reEmit.modelText)})`);
+    }
   });
 
   // --- every assertion leaves a row ----------------------------------------