spine-rigc 1.9.0 → 1.9.2

package/src/assertions/model/skin_members.ts

@@ -8,7 +8,9 @@
  * - **Constraints**: the document's `constraints` in order — update order, the
  *   order the emitter writes them in — each skin-required exactly when it
  *   states `skin: true`, the field the emitter writes through unchanged.
- * - **Skins**: in the emitter's order (`editorSkinOrder`, `src/compile.ts`); a
+ * - **Skins**: in the file's order (`fileSkinOrder`, `src/compile.ts`: a
+ *   `rigc-compiled/3` document's `editorOrder`, else the emitter's
+ *   `editorSkinOrder`, issue #1034); a
  *   skin's bones as it lists them, each the FIRST bone of that name; its
  *   constraints kind by kind in the emitter's key order
  *   (`RIG_SKIN_CONSTRAINT_KEYS`, which `emitSkins` walks), each the first
@@ -20,7 +22,7 @@
  *
  * Links nothing from the runtime.
  */
-import { editorSkinOrder } from '../../compile.ts';
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
 import { RIG_SKIN_CONSTRAINT_KEYS } from '../../rig.ts';
 import type { MemberBone, MemberConstraint, MemberSkin, SkinMemberFacts } from '../facts/skin_members.ts';
 import { isObj } from '../values.ts';
@@ -42,7 +44,7 @@ export function modelSkinMembers(read: ReadDocument): SkinMemberFacts {
   for (const constraint of stated) {
     constraints.push({ name: String(constraint.name), kind: String(constraint.kind), skinRequired: constraint.skin === true });
   }
-  const skins: MemberSkin[] = editorSkinOrder(doc.skins).map((skin) => {
+  const skins: MemberSkin[] = skinsInFileOrder(doc.skins, fileSkinOrder(doc)).map(({ skin }) => {
     const listedBones = skin.bones.map((name) => {
       const found = boneByName.get(name);
       if (found === undefined) throw new Error(`skin "${skin.name}" lists bone "${name}", which is not a bone of the document`);

package/src/assertions/model/skin_meshes.ts

@@ -4,7 +4,7 @@
  * file's walk order.
  *
  * - **The order** is `fileOrderedEntries`'s (`./skin_entries.ts`): the skins by
- *   the emitter's `editorSkinOrder`, the slots in the document's slot order, a
+ *   the file's order (`fileSkinOrder`, issue #1034), the slots in the document's slot order, a
  *   slot's records in its table's order — the walk the selftest measures equal
  *   to spine-core's `getAttachments()`.
  * - **A linked mesh's geometry is its source's**, read through the core's own

package/src/assertions/model/slider_composition.ts

@@ -0,0 +1,191 @@
+/**
+ * The model side's supply of `SliderCompositionFacts` (issue #1025, cut 4c-5
+ * of step 4c of #380): the document's sliders in its `constraints` order, the
+ * timelines of each animation they apply in the order the runtime builds
+ * them, and what each does when applied additively, as the core computes it.
+ *
+ * - **A slider's fields** are the core's record (`readSliderRecord`): `mix`,
+ *   `additive` and `skin` read at the parser's value where the document
+ *   leaves them out. The skins naming it are the document's skins in the
+ *   file's order (`fileSkinOrder`), each whose `slider` list names it.
+ * - **The timelines, in the runtime's order** (`../facts/slider_composition.ts`'
+ *   ⭐): the slot and bone timelines as the file states them (`fileSlotTimelines`,
+ *   `fileBoneTimelines` — the emitter's own passes over the document's
+ *   order), the constraint timelines in the order the runtime builds them
+ *   (`modelConstraintTimelineSources`), the attachments' deform and sequence
+ *   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 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
+ *   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`).
+ *
+ * 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 { 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';
+import { noSkinView } from '../../render_core.ts';
+import { entryAddress } from '../facts/sequences.ts';
+import type { SliderCompositionFacts, SliderFact, SliderTimelineFact } from '../facts/slider_composition.ts';
+import { modelConstraintTimelineSources } from './constraints.ts';
+import { fileBoneTimelines } from './bone_timelines.ts';
+import { fileSlotTimelines } from './slot_colour.ts';
+import type { ReadDocument } from './parse.ts';
+import { isObj } from '../values.ts';
+
+/** One timeline of an animation: the facts' reading of it and the core's. */
+export interface ModelSliderTimeline {
+  fact: SliderTimelineFact;
+  core: AdditiveTimeline;
+}
+
+/** Names in the order each first appears, put in the order a JSON object keyed by them lists them (`keyedOrder`). */
+const keyedFirsts = (names: readonly string[]): string[] => keyedOrder(names.filter((name, i) => names.indexOf(name) === i));
+
+/** 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 property = (p: string, index: number | null, attachment: string | null, names: string) => ({
+    id: [p, ...(index === null ? [] : [String(index)]), ...(attachment === null ? [] : [attachment])].join('|'),
+    property: p,
+    names,
+  });
+  const slotIndex = (name: string): number => doc.slots.findIndex((s) => s.name === name);
+  let properties: SliderTimelineFact['properties'];
+  switch (core.group) {
+    case 'bone': {
+      const index = doc.bones.findIndex((b) => b.name === core.bone);
+      properties = row.properties.map((p) => property(p, index, null, `bone "${core.bone}" ${p}`));
+      break;
+    }
+    case 'slot':
+      properties = row.properties.map((p) => property(p, slotIndex(core.slot), null, `slot "${core.slot}" ${p}`));
+      break;
+    case 'attachment': {
+      const record = doc.skins.find((k) => k.name === core.skin)?.attachments[core.slot]?.[core.attachment];
+      const shown = record?.name ?? core.attachment;
+      const address = entryAddress(core.skin, core.slot, core.attachment);
+      properties = row.properties.map((p) => property(p, slotIndex(core.slot), address, core.word === 'deform' ? `slot "${core.slot}" deform of "${shown}"` : `slot "${core.slot}" ${p}`));
+      break;
+    }
+    case 'drawOrder':
+    case 'events':
+      properties = row.properties.map((p) => property(p, null, null, `the skeleton's ${p}`));
+      break;
+    default: {
+      const index = core.group === 'physics' && core.constraint === EVERY_GLOBAL_PHYSICS ? -1 : doc.constraints.findIndex((c) => c.kind === core.group && c.name === core.constraint);
+      properties = row.properties.map((p) => property(p, row.address === 'none' ? null : index, null, index >= 0 ? `constraint "${core.constraint}" ${p}` : `the skeleton's ${p}`));
+    }
+  }
+  return { runtimeClass: row.runtimeClass, properties };
+}
+
+/** Every timeline of animation `name`, in the order the runtime builds them (the header). */
+export function modelAnimationTimelines(read: ReadDocument, name: string): ModelSliderTimeline[] {
+  const { doc } = read;
+  const anim = doc.animations.find((a) => a.name === name);
+  if (anim === undefined) return [];
+  const t = anim.timelines;
+  const out: AdditiveTimeline[] = [];
+  for (const { slot, timelines } of fileSlotTimelines(read).filter((s) => s.animation === name)) {
+    const target = t.slots.find((s) => s.name === slot);
+    for (const word of Object.keys(timelines)) {
+      const keys = target?.timelines.find((x) => x.kind === word)?.keys;
+      if (keys !== undefined) out.push({ group: 'slot', word: word as SlotTimelineKind, slot, keys });
+    }
+  }
+  for (const { bone, timelines } of fileBoneTimelines(read).filter((b) => b.animation === name)) {
+    const target = t.bones.find((b) => b.name === bone);
+    for (const word of isObj(timelines) ? Object.keys(timelines) : []) {
+      const keys = target?.timelines.find((x) => x.kind === word)?.keys;
+      if (keys !== undefined) out.push({ group: 'bone', word: word as BoneTimelineKind, bone, keys });
+    }
+  }
+  for (const source of modelConstraintTimelineSources(read).filter((s) => s.animation === name)) {
+    switch (source.kind) {
+      case 'ik': {
+        const keys = anim.constraints.ik.find((x) => x.name === source.name)?.keys;
+        if (keys !== undefined) out.push({ group: 'ik', word: 'ik', constraint: source.name, keys });
+        break;
+      }
+      case 'transform':
+        out.push({ group: 'transform', word: 'transform', constraint: source.name, keys: source.keys });
+        break;
+      case 'path':
+        out.push({ group: 'path', word: source.word as 'position' | 'spacing' | 'mix', constraint: source.name, keys: source.keys });
+        break;
+      case 'physics':
+        out.push({ group: 'physics', word: source.word as PhysicsTimelineKind, constraint: source.name, keys: source.keys });
+        break;
+      case 'slider':
+        out.push({ group: 'slider', word: source.word as 'time' | 'mix', constraint: source.name, keys: source.keys });
+        break;
+    }
+  }
+  const attachments = t.attachments;
+  for (const skin of keyedFirsts(attachments.map((a) => a.skin))) {
+    const inSkin = attachments.filter((a) => a.skin === skin);
+    for (const slot of keyedFirsts(inSkin.map((a) => a.slot))) {
+      const inSlot = inSkin.filter((a) => a.slot === slot);
+      for (const attachment of keyedFirsts(inSlot.map((a) => a.attachment))) {
+        for (const a of inSlot.filter((x) => x.attachment === attachment)) {
+          if (a.deform !== null) out.push({ group: 'attachment', word: 'deform', skin, slot, attachment, keys: a.deform });
+          if (a.sequence !== null) out.push({ group: 'attachment', word: 'sequence', skin, slot, attachment, keys: a.sequence });
+        }
+      }
+    }
+  }
+  if (t.drawOrder.length > 0) out.push({ group: 'drawOrder', word: 'drawOrder', keys: t.drawOrder });
+  if (t.events.length > 0) out.push({ group: 'events', word: 'events', times: t.events.map((k) => k.time) });
+  return out.map((core) => ({ fact: factOf(doc, core), core }));
+}
+
+/** The views the probe poses under: no skin set, then every skin in the file's order. */
+export function additiveViews(doc: CompiledDocument): AdditiveView[] {
+  return [{ name: '(none)', doc: noSkinView(doc) }, ...fileSkinOrder(doc).map((skin) => ({ name: skin.name, doc: underSkin(doc, skin.name) }))];
+}
+
+export function modelSliderComposition(read: ReadDocument): SliderCompositionFacts {
+  const { doc } = read;
+  const skinOrder = fileSkinOrder(doc).map((skin) => skin.name);
+  const walked = new Map<string, ModelSliderTimeline[]>();
+  const timelinesOf = (name: string): ModelSliderTimeline[] => {
+    const held = walked.get(name);
+    if (held !== undefined) return held;
+    const fresh = modelAnimationTimelines(read, name);
+    walked.set(name, fresh);
+    return fresh;
+  };
+  const sliders: SliderFact[] = [];
+  doc.constraints.forEach((c, index) => {
+    const r = c.record;
+    if (r?.kind !== 'slider') return;
+    const animation = doc.animations.some((a) => a.name === r.animation) ? { name: r.animation, timelines: timelinesOf(r.animation).map((x) => x.fact) } : null;
+    const skins = skinOrder.filter((name) => doc.skins.some((k) => k.name === name && k.constraints.slider.includes(r.name)));
+    sliders.push({ name: r.name, index, mix: r.mix, additive: r.additive, skinRequired: r.skin, skins, animation });
+  });
+  let views: AdditiveView[] | null = null;
+  return {
+    sliders,
+    behaviour: (animation, at) => {
+      const timeline = timelinesOf(animation)[at];
+      if (timeline === undefined) throw new Error(`internal: animation "${animation}" has no timeline ${at}`);
+      views ??= additiveViews(doc);
+      return additiveBehaviour(additiveCells(views, timeline.core));
+    },
+  };
+}

package/src/assertions/model/slot_colour.ts

@@ -5,8 +5,9 @@
  *   holds each animation's slot timelines in the order they are applied, with
  *   every key as the compiler built it; the Spine file keys the animations in
  *   the editor's order and passes every key through two passes. So the
- *   animations are put in order by `editorAnimationOrder` (`src/compile.ts`,
- *   the function the emitter is handed), and the timelines are laid out as the
+ *   animations are put in the file's order by `fileAnimationOrder`
+ *   (`src/compile.ts`: a `rigc-compiled/3` document's `editorOrder`, else the
+ *   emitter's own rule over its names, issue #1034), and the timelines are laid out as the
  *   file lays them and handed to the emitter's own `withoutParserDefaults` and
  *   `inEditorKeyOrder` (`src/keyorder.ts`) — so a key field the emitter would
  *   leave out at the parser's default is left out here too, and a body
@@ -26,7 +27,7 @@
  *
  * Links nothing from the runtime.
  */
-import { editorAnimationOrder } from '../../compile.ts';
+import { fileAnimationOrder } from '../../compile.ts';
 import type { CompiledDocument } from '../../core/index.ts';
 import { poseRawAnimation } from '../../core/raw.ts';
 import { inEditorKeyOrder, withoutParserDefaults } from '../../keyorder.ts';
@@ -42,7 +43,7 @@ export function fileSlotTimelines(read: ReadDocument): SlotTimelines[] {
   const byName = new Map<string, Json>();
   for (const anim of list(read.json.animations)) if (typeof anim.name === 'string') byName.set(anim.name, anim);
   const animations: Json = {};
-  for (const name of editorAnimationOrder([...byName.keys()])) {
+  for (const name of fileAnimationOrder(read.doc)) {
     const slots: Json = {};
     for (const slot of list((byName.get(name) as Json).slots)) {
       if (typeof slot.name !== 'string') continue;

package/src/assertions/model/stepped_poses.ts

@@ -0,0 +1,89 @@
+/**
+ * The model side's supply of `SteppedPoseFacts` (issue #1025, cut 4c-5a of
+ * step 4c of #380): every pose A10 reads, posed by rigc's core.
+ *
+ * - **The roster**: the document's bones, and its animations in the file's
+ *   order (`fileAnimationOrder`, `src/compile.ts`), each with
+ *   `CoreAnimationTimelines.duration` — the last key of every timeline as
+ *   float32, the value `tools/pose_oracle.ts compare` holds equal to
+ *   spine-core's on its `animations` roster.
+ * - **The setup pose and each animation's walk**: the core's looping walk
+ *   (`src/core/walk.ts` — `poseWalkSetup`, `poseLoopingWalk`), which reads
+ *   A10's recipe as measured and returns a value that is not finite in place
+ *   rather than refusing it. It is held equal to spine-core's walk at
+ *   tolerance 0 by `tools/core_gate.ts`'s walk block and the selftest's
+ *   `CO25`, and the poses A10 asks for here are compared with spine-core's on
+ *   every call with a model in hand (`VF13`).
+ * - **A bone's mode**: the mode the core's bone timelines pose at the time
+ *   (`posedBones`, a fresh non-looping track: the time held at the duration),
+ *   folded as the runtime's lookup folds it (`foldInheritMode`). `readModel`
+ *   refuses a setup `inheritMode` and an `inherit` key that fold to no mode by
+ *   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.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileAnimationOrder } from '../../compile.ts';
+import { foldInheritMode, type CompiledDocument } from '../../core/index.ts';
+import { posedBones } from '../../core/animation.ts';
+import { poseLoopingWalk, poseWalkSetup, type WalkPose } from '../../core/walk.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { ModelBone } from '../../model.ts';
+import type { SteppedFrame, SteppedPoseFacts } from '../facts/stepped_poses.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** A bone's posed mode as the facts spell it: `null` for a mode, else the value held. */
+const modeOf = (bone: ModelBone): string | null => (foldInheritMode(bone.inheritMode ?? 'normal') === null ? String(bone.inheritMode) : null);
+
+/** A channel the walk computed; a slot row holds `null` only where a rounding wrote one, which the walk does not. */
+const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+
+/** One walk pose as A10 reads it, each bone's mode taken from `posed` (the bones the timelines posed at the pose's time). */
+function frameOf(pose: WalkPose, posed: readonly ModelBone[]): SteppedFrame {
+  const modes = new Map(posed.map((b) => [b.name, modeOf(b)]));
+  return {
+    bones: pose.bones.map((b) => ({ name: b.name, a: b.a, b: b.b, c: b.c, d: b.d, worldX: b.worldX, worldY: b.worldY, inherit: modes.get(b.name) ?? null })),
+    drawn: pose.drawn.map((d) => ({ slot: d.slot, attachment: d.attachment, vertices: d.vertices })),
+    slots: pose.slots.map((row) => ({
+      name: row[0],
+      colour: [channel(row[2]), channel(row[3]), channel(row[4]), channel(row[5])] as const,
+      dark: row[6] === null ? null : ([channel(row[6][0]), channel(row[6][1]), channel(row[6][2])] as const),
+    })),
+  };
+}
+
+export function modelSteppedPoses(read: ReadDocument): SteppedPoseFacts {
+  let view: CompiledDocument | null = null;
+  const viewOf = (): CompiledDocument => (view ??= noSkinView(read.doc));
+  const animationOf = (name: string) => {
+    const anim = viewOf().animations.find((a) => a.name === name);
+    if (anim === undefined) throw new Error(`internal: the model side was asked to pose animation "${name}", which the document does not hold`);
+    return anim;
+  };
+  return {
+    boneCount: read.doc.bones.length,
+    steppedAnimations: fileAnimationOrder(read.doc).flatMap((name) => {
+      const anim = read.doc.animations.find((a) => a.name === name);
+      return anim === undefined ? [] : [{ name, duration: anim.timelines.duration }];
+    }),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    hasBone: (name) => read.doc.bones.some((b) => b.name === name),
+    posedInherit: (animation, bone, time) => {
+      const anim = animationOf(animation);
+      const t = time < anim.timelines.duration ? time : anim.timelines.duration;
+      const posed = posedBones(viewOf(), anim.timelines, t).find((b) => b.name === bone);
+      return posed === undefined ? undefined : modeOf(posed);
+    },
+    // The document's stated mode — asked only of a bone posing none, which the reader leaves this side no document to hold.
+    statedInherit: (name) => `${JSON.stringify(read.doc.bones.find((b) => b.name === name)?.inheritMode)}`,
+    setup: () => frameOf(poseWalkSetup(viewOf()), viewOf().bones),
+    walk: (animation, step, frames) => {
+      const anim = animationOf(animation);
+      const poses = poseLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
+      return poses.slice(1).map((pose) => frameOf(pose, posedBones(viewOf(), anim.timelines, pose.animationTime)));
+    },
+  };
+}

package/src/assertions/model/two_colour.ts

@@ -0,0 +1,61 @@
+/**
+ * The model side's supply of `TwoColourFacts` (issue #1025, cut 4c-3 of step
+ * 4c of #380).
+ *
+ * - **The stated dark colours**: the document's slots in their order — the
+ *   emitted slot array's — each `dark` as the document holds it, which the
+ *   emitter writes into the slot unchanged (`emitSlot`). `readModel` refuses
+ *   a `dark` that is not six or eight hex digits, so a spelling the runtime
+ *   would load as NaN or drop has no document to arrive in.
+ * - **The loaded dark colour**: the core's reading of that hex (`readColour`,
+ *   its first three channels) — the reading the setup pose's slot rows carry,
+ *   which `tools/pose_oracle.ts compare` holds equal to spine-core's on its
+ *   `setup.slots` block, on the grid and under `--raw`.
+ * - **The slot timelines**: `fileSlotTimelines` (`./slot_colour.ts`), the walk
+ *   A45 reads — the file's order and spelling, through the emitter's own
+ *   passes.
+ * - **A slot's posed colours**: the core's raw entry (`poseRawAnimation`,
+ *   `src/core/raw.ts`) taking one step of the time on a fresh track, under the
+ *   view the core poses with no skin set (`noSkinView`), as A45's posed colour
+ *   is taken — the slot row's light channels and its dark colour, NaN where the
+ *   row reads no number. No gate samples the times A43 asks for (a key's own
+ *   time), so the selftest compares these values with spine-core's at every
+ *   time the body asks, on every call with a model in hand (`VF12`).
+ *
+ * Links nothing from the runtime.
+ */
+import { readColour, type CompiledDocument } from '../../core/index.ts';
+import { poseRawAnimation } from '../../core/raw.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { DarkColour, TwoColourFacts } from '../facts/two_colour.ts';
+import type { ReadDocument } from './parse.ts';
+import { fileSlotTimelines } from './slot_colour.ts';
+
+/** A channel the pose read as no number, as a non-finite channel reads on the runtime's side. */
+const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+
+export function modelTwoColour(read: ReadDocument): TwoColourFacts {
+  let view: CompiledDocument | null = null;
+  const slotDarks = read.doc.slots.flatMap((slot) => (typeof slot.dark === 'string' ? [{ slot: slot.name, dark: slot.dark }] : []));
+  return {
+    slotDarks,
+    loadedDark: (name): DarkColour | null => {
+      const dark = read.doc.slots.find((s) => s.name === name)?.dark;
+      if (dark === undefined) return null;
+      const [r, g, b] = readColour(dark);
+      return { r, g, b };
+    },
+    slotTimelines: fileSlotTimelines(read),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    posedTint: (animation, slot, time) => {
+      view ??= noSkinView(read.doc);
+      const row = poseRawAnimation(view, animation, [time], {}, 'animation')[1].slots.find((r) => r[0] === slot);
+      if (row === undefined) return undefined;
+      const dark = row[6];
+      return {
+        light: { r: channel(row[2]), g: channel(row[3]), b: channel(row[4]), a: channel(row[5]) },
+        dark: dark === null ? null : { r: channel(dark[0]), g: channel(dark[1]), b: channel(dark[2]) },
+      };
+    },
+  };
+}

package/src/assertions/model/vertex_polygons.ts

@@ -10,10 +10,11 @@
  *   (`readVertices`); the selftest compares it with spine-core's on every
  *   call. A path's `closed` and `lengths` are the core's reading of the record
  *   (`readGeometry`: `closed` absent reads the parser's `false`).
- * - **The clip ends** in the order the file spells them: the skins by the
- *   emitter's `editorSkinOrder`, each skin's slot keys by its
- *   `editorSlotKeyOrder` (both `src/compile.ts`, the functions `emitSkins` is
- *   handed), each slot's records in table order — every clipping record that
+ * - **The clip ends** in the order the file spells them: the skins and each
+ *   skin's slot keys in the order `fileSkinOrder` gives (`src/compile.ts`,
+ *   issue #1034: a `rigc-compiled/3` document's `editorOrder`, else the
+ *   emitter's `editorSkinOrder` and `editorSlotKeyOrder`, the functions
+ *   `emitSkins` is handed), each slot's records in table order — every clipping record that
  *   states an `end`, with the `end` as it states it.
  *
  * `encoding` is empty on every polygon: the document states the weighted
@@ -21,7 +22,7 @@
  *
  * Links nothing from the runtime.
  */
-import { editorSkinOrder, editorSlotKeyOrder } from '../../compile.ts';
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
 import { shownRow } from '../../core/index.ts';
 import type { ClipEnd, PolygonEntry, PolygonFacts } from '../facts/vertex_polygons.ts';
 import { isObj, type Json } from '../values.ts';
@@ -40,9 +41,9 @@ export function documentRecord(read: ReadDocument, skin: string, slot: string, p
 /** Every record of the document in the order the Spine file spells it: skins, then each skin's slot keys, then the slot's table. */
 export function fileSpelledEntries(read: ReadDocument): Array<{ skin: string; slot: string; placeholder: string; record: Json }> {
   const out: Array<{ skin: string; slot: string; placeholder: string; record: Json }> = [];
-  for (const skin of editorSkinOrder(read.doc.skins)) {
-    for (const [slot, table] of Object.entries(editorSlotKeyOrder(skin.attachments))) {
-      for (const placeholder of Object.keys(table)) out.push({ skin: skin.name, slot, placeholder, record: documentRecord(read, skin.name, slot, placeholder) });
+  for (const { skin, slots } of skinsInFileOrder(read.doc.skins, fileSkinOrder(read.doc))) {
+    for (const slot of slots) {
+      for (const placeholder of Object.keys(skin.attachments[slot] ?? {})) out.push({ skin: skin.name, slot, placeholder, record: documentRecord(read, skin.name, slot, placeholder) });
     }
   }
   return out;

package/src/bonedist.ts

@@ -77,7 +77,7 @@
  */
 import { readFileSync } from 'node:fs';
 import {
-  loadPosable,
+  loadPosedSkeleton,
   PROTOCOL_FPS,
   sampleAnimation,
   sampleSetupPose,
@@ -184,7 +184,7 @@ export interface SkeletonSize {
   degenerate: boolean;
 }
 
-function skeletonSize(posable: Posable): SkeletonSize {
+function skeletonSize(posable: Pick<Posable, 'data'>): SkeletonSize {
   const setup = sampleSetupPose(posable.data, { bones: true }).at(0);
   const bones = setup?.bones ?? [];
   const rootData = posable.data.bones.find((b) => b.parent === null) ?? posable.data.bones.at(0);
@@ -338,10 +338,17 @@ export interface BoneDistReport {
 export interface BoneDistOptions {
   candidateSkeleton: string;
   candidateAtlas: string;
-  candidateAtlasDir: string;
+  /**
+   * Where the candidate's atlas pages are. Not read since issue #1042: no
+   * figure here samples a pixel, so no page is opened, and a pair whose pages
+   * are elsewhere measures the same. Kept optional so a caller that passes it
+   * still compiles.
+   */
+  candidateAtlasDir?: string;
   referenceSkeleton: string;
   referenceAtlas: string;
-  referenceAtlasDir: string;
+  /** The reference's, as `candidateAtlasDir` — not read. */
+  referenceAtlasDir?: string;
   /** A correspondence file path, or `identity`. */
   bones: string;
   fps?: number;
@@ -398,8 +405,13 @@ function extremesOf(values: number[]): Extremes {
 export function boneDistance(options: BoneDistOptions): BoneDistReport {
   const fps = options.fps ?? PROTOCOL_FPS;
   if (!Number.isFinite(fps) || fps <= 0) throw new BoneDistError('fps must be a positive number');
-  const candidate = loadPosable(options.candidateSkeleton, options.candidateAtlas, options.candidateAtlasDir);
-  const reference = loadPosable(options.referenceSkeleton, options.referenceAtlas, options.referenceAtlasDir);
+  // Each side through spine-core, refused by name where its skeleton does not load against its atlas (issue #1042),
+  // and without its page images: nothing here samples a pixel (`loadPosedSkeleton`).
+  const posedFor = (side: 'candidate' | 'reference', skeleton: string, atlas: string): Pick<Posable, 'data'> => ({
+    data: loadPosedSkeleton(skeleton, atlas, `bonedist's ${side}: every bone's world transform is read off spine-core's pose of it`),
+  });
+  const candidate = posedFor('candidate', options.candidateSkeleton, options.candidateAtlas);
+  const reference = posedFor('reference', options.referenceSkeleton, options.referenceAtlas);
 
   const candidateBoneNames = candidate.data.bones.map((b) => b.name);
   const referenceBoneNames = new Set(reference.data.bones.map((b) => b.name));