spine-rigc 1.5.2 → 1.6.1

package/src/compile.ts

@@ -38,10 +38,9 @@ import { parseJsonWithPosition } from './json-position.ts';
 // The "did you mean" list on a missing atlas region, from the one implementation
 // of it — the same search serves `refuseUnknownKeys`, and a second copy here with
 // a threshold edited is how such a pair drifts apart.
-import { dottedPath, nearMisses, refuseNumbersTheFileCannotCarry, refuseValuesOfTheWrongType } from './keys.ts';
+import { dottedPath, nearMisses, refuseNumbersTheFileCannotCarry, refuseValuesOfTheWrongType, refuseValuesOutsideTheirSet } from './keys.ts';
 import type { ShapeVisit } from './keys.ts';
-import { MANIFEST_TYPES } from './types.ts';
-import { inEditorKeyOrder, withoutParserDefaults } from './keyorder.ts';
+import { MANIFEST_ENUMS, MANIFEST_TYPES } from './types.ts';
 import { EVERY_GLOBAL_PHYSICS, parseMotionSpec } from './motion.ts';
 import {
   BONE_INHERIT_KNOWN,
@@ -79,7 +78,7 @@ import {
   buildRibbonMesh,
   buildRingMesh,
   checkHullOrder,
-  encodeWeightedVertices,
+  bindWeightedVertices,
   formatWalk,
   measureAuthoredMeshFit,
   meshEdges,
@@ -128,6 +127,34 @@ import {
   TransformError,
   type BoneTransform,
 } from './transform.ts';
+import { emitSkeleton, PHYSICS_PARAMS, UNSTATED_REFERENCE_SCALE, type SkeletonHeader } from './emit_spine.ts';
+import {
+  isModelVertexAttachment,
+  type CarriedFromCompileResult,
+  type CompiledAnimation,
+  type ModelAttachmentTimelines,
+  type ModelBinding,
+  type ModelBone,
+  type ModelBoundingBoxAttachment,
+  type ModelClippingAttachment,
+  type ModelConstraint,
+  type ModelConstraintKind,
+  type ModelEvent,
+  type ModelKey,
+  type ModelLinkedMeshAttachment,
+  type ModelMeshAttachment,
+  type ModelPathAttachment,
+  type ModelAtlasRect,
+  type ModelRegionAttachment,
+  type ModelRegionSequence,
+  type ModelSequence,
+  type ModelSkin,
+  type ModelSlot,
+  type ModelTimelines,
+  type ModelVertices,
+  type SkinTable,
+  type SkinTableEntry,
+} from './model.ts';
 import type {
   CompileResult,
   CompiledImage,
@@ -147,20 +174,6 @@ import type {
   MotionValueKey,
   MotionValueTrack,
   RigInfo,
-  SpineAttachment,
-  SpineBone,
-  SpineBoundingBoxAttachment,
-  SpineClippingAttachment,
-  SpineConstraint,
-  SpineEvent,
-  SpineLinkedMeshAttachment,
-  SpineMeshAttachment,
-  SpinePathAttachment,
-  SpineRegionAttachment,
-  SpineSequence,
-  SpineSkeletonJson,
-  SpineSlot,
-  SpineTimelineKey,
 } from './types.ts';
 
 export { CompileError, NotImplementedError };
@@ -292,11 +305,15 @@ const FRAME = 1 / 60;
  *
  * The comparator is hand-rolled and locale-independent, which `A18` requires:
  * `localeCompare` would make the emitted bytes a property of the machine.
+ *
+ * Handed to the Spine emitter as its `AnimationOrder` (issue #921): it takes
+ * the model's names and `emitAnimations` keys the object in the order this
+ * returns, so the refusal below is raised there, inside `compile`, in these
+ * words. Exported so the selftest hands it to the emitter the way the assembly
+ * does (`MA03`, `MA08`).
  */
-function editorAnimationOrder<T>(animations: Record<string, T>): Record<string, T> {
-  const ordered: Record<string, T> = {};
-  for (const name of editorNamesInOrder(Object.keys(animations), 'animations')) ordered[name] = animations[name];
-  return ordered;
+export function editorAnimationOrder(names: readonly string[]): string[] {
+  return editorNamesInOrder(names, 'animations');
 }
 
 /**
@@ -374,8 +391,12 @@ const DEFAULT_SKIN = 'default';
  * ⇒ Every skin name in this tree is lower-case ASCII without digits, so no
  * emitted byte moves and no rig is refused. What moves is the claim, and what
  * stops being refused is a rig with capitals, folders or digits in its skins.
+ *
+ * Exported, with `editorSlotKeyOrder`, because the Spine emitter applies both
+ * (`emitSkins` takes them as its `EditorOrder`, issue #919) and the selftest
+ * hands them to it the way the assembly does (`MS07`, `MS08`).
  */
-function editorSkinOrder<T extends { name: string }>(skins: readonly T[]): T[] {
+export function editorSkinOrder<T extends { name: string }>(skins: readonly T[]): T[] {
   const pinned = skins.filter((skin) => skin.name === DEFAULT_SKIN);
   const rest = skins.filter((skin) => skin.name !== DEFAULT_SKIN);
   // Ranked rather than looked up by name: two skins answering to one name are a
@@ -421,7 +442,7 @@ function editorSkinOrder<T extends { name: string }>(skins: readonly T[]): T[] {
  * attachment name holding `/` is the common case the folder question would
  * have to answer first.
  */
-function editorSlotKeyOrder<T>(attachments: Record<string, T>): Record<string, T> {
+export function editorSlotKeyOrder<T>(attachments: Record<string, T>): Record<string, T> {
   const names = Object.keys(attachments);
   if (names.some((name) => name.includes(NAME_FOLDER))) return attachments;
   for (let i = 0; i < names.length; i++) {
@@ -839,8 +860,14 @@ const FLOAT32_BITS = new Uint32Array(FLOAT32_SCRATCH.buffer);
  * `137.5`. What this does NOT do is snap a double's residue to zero: `r6`'s grid
  * was absolute and swallowed anything under 5e-7, a float's is relative, so a
  * residue of 1e-15 is a float in its own right and is emitted as one.
+ *
+ * 🔒 Exported for one reader: `MX01` in `selftest.ts` defines "on the float32
+ * grid" as a fixed point of this function, `f32(x) === x`, and holds every
+ * number the model document spells to it or to the six-decimal grid (issue
+ * #942). `Math.fround(x) === x` is not that test: this writes `0.2`, whose
+ * float is 0.20000000298023224, so it would refuse the emitter's own output.
  */
-function f32(n: number): number {
+export function f32(n: number): number {
   const f = Math.fround(n);
   if (f === 0 || !Number.isFinite(f)) return f === 0 ? 0 : f;
   const magnitude = Math.abs(f);
@@ -1187,7 +1214,7 @@ const BONE_TRACKS: Record<string, ValueTrackShape> = {
  * `:1062` and only `mix` reassigns it (`:1090`), so an `inertia` key that omits
  * `value` reads **0** — not the 0.5 that `:306` gives a constraint that states
  * no `inertia`. Two different tables of defaults sit forty lines apart in one
- * file (`PHYSICS_PARAMS` above holds the other one), and reading the setup
+ * file (`PHYSICS_PARAMS` in `src/emit_spine.ts` holds the other one), and reading the setup
  * column into this one would emit a `damping` timeline whose omitted keys mean
  * 0.85 to the author and 0 to the runtime. Nothing here depends on the number,
  * because `compileValueTrack` writes every field explicitly — it is recorded
@@ -1418,24 +1445,15 @@ const CONSTRAINT_TIMELINES: Record<'ik' | 'transform', ConstraintTimelineShape>
 };
 
 /**
- * Physics constraint fields and their parser defaults (SkeletonJson.js:295-319).
+ * The five components a physics constraint drives. The parameters and their
+ * parser defaults are `PHYSICS_PARAMS`, which moved to `src/emit_spine.ts` with
+ * the omission it decides (issue #919).
  *
  * `PHYSICS_COMPONENTS` is exported for `ingest.ts`, which omits a constraint that
  * drives none of them (issue #731) and must read "drives" off the same five
  * names this module refuses an empty constraint with, not off a copy.
  */
 export const PHYSICS_COMPONENTS = ['x', 'y', 'rotate', 'scaleX', 'shearX'] as const;
-const PHYSICS_PARAMS: Array<[string, number]> = [
-  ['inertia', 0.5],
-  ['strength', 100],
-  ['damping', 0.85],
-  ['mass', 1],
-  ['wind', 0],
-  ['gravity', 0],
-  ['mix', 1],
-  ['fps', 60],
-  ['limit', 5000],
-];
 
 // ---------------------------------------------------------------------------
 // curves
@@ -2062,7 +2080,13 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // same rule over the other file whose numbers reach the skeleton.
   // Its values of the wrong type first (issue #890): `crop.h: "806"` built
   // green, the string coerced by whatever arithmetic read it.
-  if (manifest !== null && manifestPath !== null) refuseValuesOfTheWrongType(manifestShapeVisits(manifest), MANIFEST_TYPES, manifestPath);
+  if (manifest !== null && manifestPath !== null) {
+    const visits = manifestShapeVisits(manifest);
+    refuseValuesOfTheWrongType(visits, MANIFEST_TYPES, manifestPath);
+    // Then a name outside a stated set (issue #900): `mesh.kind: "foo"` was
+    // read as a ribbon by one reader and a ring by two others.
+    refuseValuesOutsideTheirSet(visits, MANIFEST_TYPES, MANIFEST_ENUMS, manifestPath);
+  }
   if (manifest !== null && manifestPath !== null) refuseNumbersTheFileCannotCarry(manifest, manifestPath, dottedPath);
 
   // The rig spec names its own path in every message `parseRigSpec` throws (its
@@ -2531,7 +2555,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   const axisSpineDeg = manifest?.axis ? screenToSpineDegrees(manifest.axis.deg) : null;
   const partBySlot = new Map(parts.map((part) => [part.slot, part]));
 
-  const bones: SpineBone[] = [];
+  const bones: ModelBone[] = [];
   for (const spec of rig.bones) {
     bones.push(buildBone(spec, bones, { rig, manifest, cropH, axisSpineDeg, partBySlot }));
   }
@@ -2557,9 +2581,11 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // -- 4. slots + skins ------------------------------------------------------
   // Draw order IS the slots array order. No separate field,
   // and the rig's array is that order.
-  const slots: SpineSlot[] = [];
-  const skinTables = new Map<string, Record<string, Record<string, SpineAttachment>>>();
-  const tableFor = (skinName: string): Record<string, Record<string, SpineAttachment>> => {
+  const slots: ModelSlot[] = [];
+  // Every attachment is a model record (`SkinTableEntry`); the emitter turns the
+  // tables into Spine's at assembly, and `CompiledModel.skins` holds them.
+  const skinTables = new Map<string, SkinTable>();
+  const tableFor = (skinName: string): SkinTable => {
     let table = skinTables.get(skinName);
     if (!table) {
       table = {};
@@ -2697,11 +2723,13 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     if (setup?.color && rigSlot.color !== undefined) {
       throw new CompileError(`slot "${rigSlot.name}" has a setup colour in the rig spec AND in the motion spec`);
     }
-    const slot: SpineSlot = { name: rigSlot.name, bone: rigSlot.bone };
-    if (setupAttachment !== null) slot.attachment = setupAttachment;
+    // The setup attachment is held as the value it is, `null` included; leaving
+    // the key out for `null` is the emitter's (`emitSlots`).
+    const slot: ModelSlot = { name: rigSlot.name, bone: rigSlot.bone, setup: setupAttachment };
     if (setup?.color) slot.color = rgbaHex(setup.color);
     else if (rigSlot.color !== undefined) slot.color = rigSlot.color;
     if (rigSlot.dark !== undefined) slot.dark = rigSlot.dark;
+    // As stated: `parseRigSpec` refused every spelling the runtime would read as no mode (issue #946).
     if (rigSlot.blend !== undefined) slot.blend = rigSlot.blend;
     slots.push(slot);
     // ...and nothing below this line has anything to build. An empty entry in a
@@ -2711,7 +2739,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     if (empty) continue;
 
     if (part) {
-      const perSlot: Record<string, SpineAttachment> = {};
+      const perSlot: Record<string, SkinTableEntry> = {};
       const mesh = part.mesh ? buildMesh(part, manifest!, bones, transforms, rigSlot.bone) : null;
       for (const name of names) {
         const img = images.find((im) => im.region === name);
@@ -2745,7 +2773,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     for (const skinName of skinNames) {
       const placeholders = skinParts.get(skinName)!.attachments[rigSlot.name];
       if (!placeholders) continue;
-      const perSlot: Record<string, SpineAttachment> = {};
+      const perSlot: Record<string, SkinTableEntry> = {};
       for (const [placeholder, att] of Object.entries(placeholders)) {
         const where = `skin "${skinName}" slot "${rigSlot.name}" attachment "${placeholder}"`;
         const built = buildRigAttachment(att, placeholder, where, {
@@ -2760,6 +2788,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           imagesDir,
           depths: attachmentDepths,
           slotNames: new Set(rig.slots.map((s) => s.name)),
+          atlasRegions: atlasIn === null ? null : atlasIn.byName,
           links: pendingLinks,
         });
         // The name is put on AFTER the builder rather than inside it: six
@@ -2809,7 +2838,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // (structure), then the motion spec's physics table (tuning). A name in both is
   // refused: `mix` timelines resolve by name, and two constraints answering to
   // one name is a timeline driving something nobody chose.
-  const constraints: SpineConstraint[] = [];
+  const constraints: ModelConstraint[] = [];
   const physicsReport: CompileResult['physics'] = [];
   // Deform keys that stated a model instead of a run (issue #294). Declared here
   // rather than inside the animation loop because `explain` reports it across
@@ -2845,8 +2874,8 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     constraintNamesOfKind.set(type, [...(constraintNamesOfKind.get(type) ?? []), name]);
   };
   /**
-   * ik constraint -> the booleans it declares that the timeline format would
-   * otherwise take away from it. Issue #273.
+   * ik constraint -> its three booleans IN EFFECT: the value it declares, or
+   * the parser's default where it declares none. Issue #273.
    *
    * 🚨 `SkeletonJson` reads `bendPositive`, `compress` and `stretch` in TWO
    * places with the same defaults: once on the constraint (`:155`) and once on
@@ -2855,19 +2884,23 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
    * `bendPositive: false` and an `ik` timeline that keys only `mix` produce a
    * constraint that bends the other way for the whole animation, with the field
    * still in the file and inert: four builds differing only in these flags posed
-   * one pose. What goes in this map is only the values that DIFFER from the
-   * per-key default, because a rig that says nothing and a key that says nothing
-   * already agree and there is nothing to carry.
+   * one pose. So a key that states no flag takes the constraint's from this
+   * map, and the model's ik key holds all three flags in effect (`ModelKey`).
+   * Which of them the file carries is the Spine emitter's: only those that
+   * differ from the per-key default (`emitAnimations`, issue #921), which is
+   * what this map held before — a rig that says nothing and a key that says
+   * nothing already agree, so nothing is written for them.
    */
-  const ikRigFlags = new Map<string, Record<string, boolean>>();
+  const ikFlagsInEffect = new Map<string, Record<string, boolean>>();
   // Which slots can actually show a path, for the path constraint's own check.
-  // Read off the emitted skin tables rather than the spec, so it answers the
-  // question the runtime asks: is there an attachment of that type on that slot?
+  // Read off the skin tables — the model records the file is emitted from —
+  // rather than the spec, so it answers the question the runtime asks: is
+  // there an attachment of that kind on that slot? (By `kind` since issue #919.)
   const pathSlots = new Map<string, string[]>();
   for (const [skinName, table] of skinTables) {
     for (const [slotName, perSlot] of Object.entries(table)) {
       for (const att of Object.values(perSlot)) {
-        if ((att as { type?: string }).type !== 'path') continue;
+        if (att.kind !== 'path') continue;
         pathSlots.set(slotName, [...(pathSlots.get(slotName) ?? []), skinName]);
         break;
       }
@@ -2887,12 +2920,15 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     constraints.push(buildRigConstraint(spec, constraintCtx));
     declareConstraint(spec.name, spec.type);
     if (spec.type === 'ik') {
-      const carried: Record<string, boolean> = {};
+      // `flag.dflt` is the per-key default, and the constraint's own parser
+      // default is the same value for each of the three
+      // (`PARSER_DEFAULTS['ik constraint']` and `['ik key']` in keyorder.ts).
+      const inEffect: Record<string, boolean> = {};
       for (const flag of CONSTRAINT_TIMELINES.ik.flags) {
         const declared = spec[flag.field];
-        if (typeof declared === 'boolean' && declared !== flag.dflt) carried[flag.field] = declared;
+        inEffect[flag.field] = typeof declared === 'boolean' ? declared : flag.dflt;
       }
-      if (Object.keys(carried).length) ikRigFlags.set(spec.name, carried);
+      ikFlagsInEffect.set(spec.name, inEffect);
     }
   }
   withMotionSource(() => {
@@ -2910,17 +2946,17 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
       if (!boneNames.has(spec.bone)) {
         throw new CompileError(`physics constraint "${name}" targets unknown bone "${spec.bone}"`);
       }
-      const entry: SpineConstraint = {
-        name,
-        type: 'physics',
-        bone: spec.bone,
-      };
+      // Every component and parameter the table states is held, 0 and the
+      // parser's default included; which of them Spine leaves out is the
+      // emitter's (`emitConstraint`). `components` is the report's list of the
+      // ones that DRIVE, as it always was.
+      const entry: ModelConstraint = { kind: 'physics', name, declaredIn: 'motion', bone: spec.bone };
       const components: string[] = [];
       for (const comp of PHYSICS_COMPONENTS) {
         const v = spec[comp];
-        if (v === undefined || v === 0) continue;
+        if (v === undefined) continue;
         entry[comp] = f32(v);
-        components.push(comp);
+        if (v !== 0) components.push(comp);
       }
       if (!components.length) {
         // The parser is happy with this and the constraint does nothing at all.
@@ -2929,9 +2965,9 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           `physics constraint "${name}" drives no component — set at least one of ${PHYSICS_COMPONENTS.join('/')}`,
         );
       }
-      for (const [param, dflt] of PHYSICS_PARAMS) {
+      for (const [param] of PHYSICS_PARAMS) {
         const v = spec[param as keyof typeof spec] as number | undefined;
-        if (v === undefined || v === dflt) continue;
+        if (v === undefined) continue;
         entry[param] = f32(v);
       }
       constraints.push(entry);
@@ -2977,12 +3013,15 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // the refusal below reports as the skins it looked in, so it is read from the
   // map rather than restated.
   const attachmentIndex: SlotAttachmentIndex = { bySlot: attachmentsBySlot, searched: [...skinTables.keys()] };
-  const animations: SpineSkeletonJson['animations'] = {};
+  // The model's animations, in the motion spec's order; `emitAnimations` keys
+  // them in the editor's at assembly.
+  const animations = new Map<string, CompiledAnimation>();
   const declaredDurations: Record<string, number> = {};
   const slotNames = new Set(slots.map((s) => s.name));
-  // Which slots an `rgba2` timeline may be keyed on: the ones the EMITTED file
-  // gives a `dark`, for the same reason `attachmentIndex` is built off the
-  // emitted skins — what the runtime does with a timeline depends on the file,
+  // Which slots an `rgba2` timeline may be keyed on: the model slots with a
+  // `dark` — the slots the file is emitted from, which `emitSlots` writes each
+  // `dark` of (issue #919) — for the same reason `attachmentIndex` is built off
+  // the skin tables: what the runtime does with a timeline depends on the file,
   // not on the spec that produced it. A slot whose `dark` never reached the
   // artifact is a slot the runtime allocates no dark colour for (issue #690).
   const darkSlots = new Set(slots.filter((s) => s.dark !== undefined).map((s) => s.name));
@@ -2991,13 +3030,24 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     checkMotionGroups(motion);
     for (const [animName, anim] of Object.entries(motion.animations)) {
       declaredDurations[animName] = anim.duration;
-      const slotTimelines: Record<string, Record<string, SpineTimelineKey[]>> = {};
-      const boneTimelines: Record<string, Record<string, SpineTimelineKey[]>> = {};
-      /** One table per constraint family, keyed the way the file is. */
-      const familyTimelines: Record<ConstraintTrackFamily, Record<string, Record<string, SpineTimelineKey[]>>> = {
-        physics: {},
-        path: {},
-        slider: {},
+      const slotTimelines = new Map<string, ModelTimelines>();
+      const boneTimelines = new Map<string, ModelTimelines>();
+      /**
+       * One table per constraint family, target -> timelines. The physics
+       * timeline that names no constraint is filed under its own target,
+       * `EVERY_GLOBAL_PHYSICS`, in the position its track holds among the
+       * named ones (`CompiledAnimation`).
+       */
+      const familyTimelines: Record<ConstraintTrackFamily, Map<string, ModelTimelines>> = {
+        physics: new Map(),
+        path: new Map(),
+        slider: new Map(),
+      };
+      /** `targets.get(target)`, made on first use — the map keeps the order targets are first keyed in. */
+      const timelinesOf = (targets: Map<string, ModelTimelines>, target: string): ModelTimelines => {
+        let timelines = targets.get(target);
+        if (timelines === undefined) targets.set(target, (timelines = new Map()));
+        return timelines;
       };
       const claimed = new Set<string>();
       let compiledDuration = 0;
@@ -3025,7 +3075,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
             );
           }
           if (everyGlobal) {
-            const physics = constraints.filter((one) => one.type === 'physics');
+            const physics = constraints.filter((one) => one.kind === 'physics');
             const flag = `${track.property}Global`;
             const reached =
               track.property === 'reset'
@@ -3097,7 +3147,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           // the fault is the pair, not a key.
           if (family === null && !isBoneTrack) {
             const mine = SLOT_COLOR_CHANNELS[track.property] ?? [];
-            for (const other of Object.keys(slotTimelines[target] ?? {})) {
+            for (const other of slotTimelines.get(target)?.keys() ?? []) {
               const shared = (SLOT_COLOR_CHANNELS[other] ?? []).filter((channel) => mine.includes(channel));
               if (shared.length === 0) continue;
               throw new CompileError(
@@ -3127,11 +3177,12 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
               : isBoneTrack
                 ? compileValueTrack(resolved, motion, animName, anim.duration, target, shift, BONE_TRACKS, 'bone')
                 : compileTrack(resolved, motion, animName, anim.duration, target, shift, attachmentIndex, darkSlots);
-          for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time as number);
-          // Under the empty name, which is the file's own spelling of it.
-          if (family !== null) (familyTimelines[family][everyGlobal ? '' : target] ??= {})[track.property] = keys;
-          else if (isBoneTrack) (boneTimelines[target] ??= {})[track.property] = keys;
-          else (slotTimelines[target] ??= {})[track.property] = keys;
+          for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time);
+          // The every-global physics timeline under its own target, `*`
+          // (`everyGlobal`); the empty name is the Spine emitter's spelling.
+          if (family !== null) timelinesOf(familyTimelines[family], target).set(track.property, keys);
+          else if (isBoneTrack) timelinesOf(boneTimelines, target).set(track.property, keys);
+          else timelinesOf(slotTimelines, target).set(track.property, keys);
         });
       }
 
@@ -3142,9 +3193,9 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
       // The target is resolved by name AND by type: `findConstraint(name,
       // IkConstraintData)` misses a transform constraint of the same name and the
       // parser throws in the consumer's process, so the mismatch is named here.
-      const constraintTimelines: Record<'ik' | 'transform', Record<string, SpineTimelineKey[]>> = {
-        ik: {},
-        transform: {},
+      const constraintTimelines: Record<'ik' | 'transform', Map<string, ModelKey[]>> = {
+        ik: new Map(),
+        transform: new Map(),
       };
       for (const group of ['ik', 'transform'] as const) {
         // The array, the entries and their `constraint` names are shapes, so
@@ -3169,7 +3220,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
                   : `the rig declares no ${group} constraint at all`),
             );
           }
-          if (constraintTimelines[group][name]) {
+          if (constraintTimelines[group].has(name)) {
             throw new CompileError(
               `animation "${animName}" has two ${group} timelines on constraint "${name}"; ` +
                 'the group holds one timeline per constraint, so merge them into one',
@@ -3184,18 +3235,25 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
             // The ik table, asked only by the ik group: `leg` may also be a
             // transform constraint, and a transform key set carries no flag for
             // the rig's booleans to be stamped onto (issue #692).
-            group === 'ik' ? (ikRigFlags.get(name) ?? {}) : {},
+            group === 'ik' ? (ikFlagsInEffect.get(name) ?? {}) : {},
           );
-          for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time as number);
-          constraintTimelines[group][name] = keys;
+          for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time);
+          constraintTimelines[group].set(name, keys);
         }
       }
 
       // -- deform timelines: keyed on a skin/slot/attachment triple ----------
-      // Four deep, because the format is: skin -> slot -> attachment -> timeline
-      // name -> keys. `deform` is one of two timeline names an attachment can
-      // carry (the other is `sequence`), which is why the level exists at all.
-      const deformTimelines: Record<string, Record<string, Record<string, Record<string, SpineTimelineKey[]>>>> = {};
+      // skin -> slot -> attachment -> its `deform` and `sequence` keys: the two
+      // timelines an attachment can carry, which is why the last level exists.
+      const deformTimelines = new Map<string, Map<string, Map<string, ModelAttachmentTimelines>>>();
+      /** The triple's entry, made on first use in the order triples are first keyed. */
+      const attachmentTimelinesOf = (skin: string, slot: string): Map<string, ModelAttachmentTimelines> => {
+        let bySlot = deformTimelines.get(skin);
+        if (bySlot === undefined) deformTimelines.set(skin, (bySlot = new Map()));
+        let byAttachment = bySlot.get(slot);
+        if (byAttachment === undefined) bySlot.set(slot, (byAttachment = new Map()));
+        return byAttachment;
+      };
       const deformTracks: MotionDeformTrack[] = anim.deform ?? [];
       for (const track of deformTracks) {
         const skinName = track.skin ?? 'default';
@@ -3220,7 +3278,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
               `(it has: ${Object.keys(perSlot).join(', ')})`,
           );
         }
-        if (deformTimelines[skinName]?.[track.slot]?.[track.attachment]) {
+        if (deformTimelines.get(skinName)?.get(track.slot)?.has(track.attachment)) {
           throw new CompileError(`${at}: two deform timelines on one attachment; merge them into one`);
         }
         const keys = compileDeformTrack(
@@ -3229,13 +3287,13 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           animName,
           anim.duration,
           {
-            ...deformGeometryOf(attachment, at, bones, transforms),
+            ...deformGeometryOf(attachment, at, transforms),
             depth: attachmentDepths.get(`${skinName}/${track.slot}/${track.attachment}`) ?? null,
           },
           deformTransforms,
         );
-        for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time as number);
-        ((deformTimelines[skinName] ??= {})[track.slot] ??= {})[track.attachment] = { deform: keys };
+        for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time);
+        attachmentTimelinesOf(skinName, track.slot).set(track.attachment, { deform: keys });
       }
 
       // -- sequence timelines: the other attachment timeline (issue #729) -----
@@ -3267,22 +3325,22 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           );
         }
         const keys = compileSequenceTrack(track, anim.duration, attachment, at);
-        for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time as number);
-        const slot = ((deformTimelines[skinName] ??= {})[track.slot] ??= {});
-        if (slot[track.attachment]?.sequence) {
+        for (const key of keys) compiledDuration = Math.max(compiledDuration, key.time);
+        const slot = attachmentTimelinesOf(skinName, track.slot);
+        if (slot.get(track.attachment)?.sequence) {
           throw new CompileError(`${at}: two sequence timelines on one attachment; merge them into one`);
         }
-        slot[track.attachment] = { ...(slot[track.attachment] ?? {}), sequence: keys };
+        slot.set(track.attachment, { ...(slot.get(track.attachment) ?? {}), sequence: keys });
       }
 
-      const drawOrder = anim.drawOrder ? compileDrawOrder(anim.drawOrder, animName, anim.duration, slots) : null;
-      if (drawOrder) for (const key of drawOrder) compiledDuration = Math.max(compiledDuration, key.time as number);
+      const drawOrder = anim.drawOrder ? compileDrawOrder(anim.drawOrder, animName, anim.duration, slots) : [];
+      for (const key of drawOrder) compiledDuration = Math.max(compiledDuration, key.time);
 
-      const eventKeys = anim.events ? compileEvents(anim.events, animName, anim.duration, rig.events ?? {}) : null;
+      const eventKeys = anim.events ? compileEvents(anim.events, animName, anim.duration, rig.events ?? {}) : [];
       // An event timeline counts towards the animation's length the same as any
       // other: `readAnimation` takes the duration from the longest timeline it
       // built, and `EventTimeline.getDuration()` is its last frame like the rest.
-      if (eventKeys) for (const key of eventKeys) compiledDuration = Math.max(compiledDuration, key.time as number);
+      for (const key of eventKeys) compiledDuration = Math.max(compiledDuration, key.time);
 
       // Rule 4: the declared duration is verified, because skeleton JSON does not
       // carry one — the loader takes the max key time.
@@ -3298,133 +3356,101 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           `animation "${animName}" declares duration ${anim.duration}s but its last key is at ${compiledDuration}s`,
         );
       }
-      // Group order is `readAnimation`'s own reading order, so an emitted file
-      // diffs cleanly against an editor export. Each line is conditional, which
-      // is what keeps a spec that uses none of the new groups byte-identical.
-      animations[animName] = {};
-      if (Object.keys(slotTimelines).length) animations[animName].slots = slotTimelines;
-      if (Object.keys(boneTimelines).length) animations[animName].bones = boneTimelines;
-      if (Object.keys(constraintTimelines.ik).length) animations[animName].ik = constraintTimelines.ik;
-      if (Object.keys(constraintTimelines.transform).length) {
-        animations[animName].transform = constraintTimelines.transform;
-      }
-      if (Object.keys(familyTimelines.path).length) animations[animName].path = familyTimelines.path;
-      if (Object.keys(familyTimelines.physics).length) animations[animName].physics = familyTimelines.physics;
-      if (Object.keys(familyTimelines.slider).length) animations[animName].slider = familyTimelines.slider;
-      if (Object.keys(deformTimelines).length) animations[animName].attachments = deformTimelines;
-      if (drawOrder) animations[animName].drawOrder = drawOrder;
-      if (eventKeys) animations[animName].events = eventKeys;
+      // The model's record of the animation. Which groups the file carries, in
+      // what order and under what spelling is the Spine emitter's
+      // (`emitAnimation`: `readAnimation`'s reading order, each group only when
+      // non-empty).
+      animations.set(animName, {
+        duration: anim.duration,
+        bones: boneTimelines,
+        slots: slotTimelines,
+        constraints: {
+          ik: constraintTimelines.ik,
+          transform: constraintTimelines.transform,
+          path: familyTimelines.path,
+          physics: familyTimelines.physics,
+          slider: familyTimelines.slider,
+        },
+        attachments: deformTimelines,
+        drawOrder,
+        events: eventKeys,
+      });
     }
   });
 
   // -- 6. assemble -----------------------------------------------------------
   //
-  // The stage is four fields or none of them. `x`/`y` are the origin of the box
+  // What the skeleton carries that the model does not hold: the header. The
+  // stage is four fields or none of them — `x`/`y` are the origin of the box
   // `width`/`height` give an extent to, so a header carrying an origin for a box
-  // it does not declare would be a shape no export has — and the key ORDER here
-  // is the editor's own, which is what keeps a staged build byte-identical to
-  // what it emitted before the stage could be declared absent (issue #578).
-  const header: SpineSkeletonJson['skeleton'] = { spine: SPINE_VERSION };
-  if (stageWidth !== undefined && stageHeight !== undefined) {
-    header.x = rig.skeleton?.x ?? 0;
-    header.y = rig.skeleton?.y ?? 0;
-    header.width = stageWidth;
-    header.height = stageHeight;
-  }
-  if (rig.skeleton?.fps !== undefined) header.fps = rig.skeleton.fps;
-  if (rig.skeleton?.referenceScale !== undefined) header.referenceScale = rig.skeleton.referenceScale;
-  const imagesPath = skeletonImagesPath(rig.skeleton?.images, opts, outDir, partDirs);
-  if (imagesPath !== undefined) header.images = imagesPath;
-  if (rig.skeleton?.audio !== undefined) header.audio = rig.skeleton.audio;
-
-  // Event definitions. Emitted in the order the rig spec declares them — object
-  // key order is the spec's, not a set's, so A18 stays a contract.
-  const events: Record<string, SpineEvent> = {};
+  // it does not declare would be a shape no export has (issue #578).
+  const header: SkeletonHeader = {
+    spine: SPINE_VERSION,
+    stage:
+      stageWidth !== undefined && stageHeight !== undefined
+        ? { x: rig.skeleton?.x ?? 0, y: rig.skeleton?.y ?? 0, width: stageWidth, height: stageHeight }
+        : null,
+    fps: rig.skeleton?.fps,
+    images: skeletonImagesPath(rig.skeleton?.images, opts, outDir, partDirs),
+    audio: rig.skeleton?.audio,
+  };
+
+  // Event definitions, in the order the rig spec declares them — the map's
+  // insertion order is the spec's, not a set's, so A18 stays a contract.
+  const events = new Map<string, ModelEvent>();
   for (const [name, def] of Object.entries(rig.events ?? {})) {
-    const entry: SpineEvent = {};
+    const entry: ModelEvent = {};
     if (def.int !== undefined) entry.int = def.int;
     if (def.float !== undefined) entry.float = f32(def.float);
     if (def.string !== undefined) entry.string = def.string;
     if (def.audio !== undefined) entry.audio = def.audio;
     if (def.volume !== undefined) entry.volume = f32(def.volume);
     if (def.balance !== undefined) entry.balance = f32(def.balance);
-    events[name] = entry;
+    events.set(name, entry);
   }
+  // Every skin with what it activates and its table, in the spec's order: the
+  // model's record of it. `splitRigSkin`'s lists, or none for a skin the spec
+  // does not declare (a manifest's `default`).
+  const skins: ModelSkin[] = [...skinTables].map(([name, attachments]) => {
+    const parts = skinParts.get(name);
+    return {
+      name,
+      bones: parts?.bones ?? [],
+      constraints: Object.fromEntries(RIG_SKIN_CONSTRAINT_KEYS.map((key) => [key, parts?.constraints[key] ?? []])) as ModelSkin['constraints'],
+      attachments,
+    };
+  });
 
-  const skeleton: SpineSkeletonJson = {
-    skeleton: header,
-    bones,
-    slots,
-    // A skin entry is `name`, then whatever it activates, then `attachments` —
-    // `readSkeletonData`'s own order (`:372-443`). Every member list is a
-    // conditional spread, so a rig that declares none emits the two-key entry it
-    // always did, byte for byte.
-    //
-    // Ordered the way `animations` is and for the same reason — the editor
-    // rewrites this array and the binary half addresses it by ordinal — with the
-    // sort applied HERE rather than to `skinTables`, so everything upstream (the
-    // path-slot table, every refusal that lists skins) still reads the order the
-    // rig spec declared. See `editorSkinOrder`.
-    skins: editorSkinOrder(
-      [...skinTables.entries()].map(([name, attachments]) => {
-        const parts = skinParts.get(name);
-        return {
-          name,
-          ...(parts?.bones.length ? { bones: parts.bones } : {}),
-          ...Object.fromEntries(
-            RIG_SKIN_CONSTRAINT_KEYS.filter((key) => parts?.constraints[key].length).map((key) => [
-              key,
-              parts!.constraints[key],
-            ]),
-          ),
-          attachments: editorSlotKeyOrder(attachments),
-        };
-      }),
-    ),
-    // Between `skins` and `animations`, which is where the editor writes it. A
-    // conditional spread rather than an assignment after the literal, so the key
-    // lands in that position instead of at the end.
-    ...(Object.keys(events).length ? { events } : {}),
-    // Keyed in the editor's own order rather than the motion spec's, because a
-    // slider's reference to an animation is an ordinal in the format and the
-    // editor re-sorts this object — see `editorAnimationOrder`. The sort is
-    // applied HERE and not to the loop above, so what the compiler reads, the
-    // order it reports durations in, and which animation a CompileError names
-    // first are all still the spec's own; only the emitted key order moves.
-    animations: editorAnimationOrder(animations),
-  };
-  if (constraints.length) skeleton.constraints = constraints;
+  // The skeleton: the Spine emitter's one entry (issue #922), which writes every
+  // section from the model, in the order and under the spellings the file has,
+  // and runs the parser-default and key-order passes on the finished object.
+  // What it is handed besides the model is what the model does not hold: the
+  // header above, and the editor's orders, which stay here (see `editorSkinOrder` and
+  // `editorAnimationOrder`): the sorts are applied at emission, so everything
+  // this function reads, and the model's `skins` and `animations`, keep the
+  // spec's own order.
+  // The skeleton's reference scale, which wind and gravity act over (issue
+  // #958): the rig's stated number as it is, or the value the parser reads a
+  // header stating none as. The model holds it; the emitter writes it into the
+  // header, where the parser-default pass drops it at 100 as before.
+  const referenceScale = rig.skeleton?.referenceScale ?? UNSTATED_REFERENCE_SCALE;
+  const skeleton = emitSkeleton(
+    { referenceScale, bones, slots, skins, constraints, events, animations },
+    header,
+    { skins: editorSkinOrder, slotKeys: editorSlotKeyOrder, animations: editorAnimationOrder },
+  );
 
   for (const slot of slots) {
     if (!boneNames.has(slot.bone)) throw new CompileError(`slot "${slot.name}" has no bone`);
   }
 
-  // Every object's keys in the order the editor writes them, per kind, from the
-  // one table that says so (`src/keyorder.ts`, issue #716) — applied here, once,
-  // to the finished object and before the text exists, so the constructors above
-  // are free to build in whatever order reads best and none of them states the
-  // order a second time. It moves positions and nothing else: no key is added,
-  // dropped or re-valued, and what the gate and `A18` read is this object's text.
-  //
-  // Before it, and on the same finished object: every key whose value is the
-  // one the 4.3 parser reads in its absence is left out, the way the editor
-  // leaves it out (issue #716 tranche 3). One pass beside the other rather than
-  // folded into it, because each has its own table and the selftest plants a
-  // wrong row into each on its own; both walk the object through
-  // `forEachKindedObject`, so what a kind is stays said in one place. The spec
-  // is untouched — an author may still write `x: 0`, and it is still the record
-  // of what was written — and what the parser loads does not move (`S103`).
-  inEditorKeyOrder(withoutParserDefaults(skeleton));
-
-  return {
-    skeleton,
-    skeletonText: `${JSON.stringify(skeleton, null, 2)}\n`,
-    atlasText,
+  // The fields the model carries as `CompileResult` carries them, by reference:
+  // one object, so the result and its model cannot say two different things.
+  const carried: CarriedFromCompileResult = {
     images,
     pageGrids: atlasIn === null ? [] : [...atlasIn.grids].map(([page, grid]) => ({ page, said: grid.said })),
     droppedStates,
     absentParts,
-    declaredDurations,
     meshBones: [...meshBones],
     meshes,
     physics: physicsReport,
@@ -3432,6 +3458,14 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
     trackDerivations,
     rig: buildRigInfo(rig, bones, meshes, manifest, images),
   };
+  return {
+    skeleton,
+    skeletonText: `${JSON.stringify(skeleton, null, 2)}\n`,
+    atlasText,
+    declaredDurations,
+    ...carried,
+    model: { referenceScale, bones, setupWorld: transforms, slots, skins, constraints, events, animations, ...carried },
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -3447,7 +3481,7 @@ interface BoneContext {
 }
 
 /**
- * One rig bone -> one emitted bone.
+ * One rig bone -> one model bone (`ModelBone`); `emitBones` writes it as Spine's.
  *
  * 🔑 A field is emitted exactly when the spec declared it. That is not Spine's
  * own exporter convention (it omits anything equal to the default) and the
@@ -3455,8 +3489,8 @@ interface BoneContext {
  * deciding emission from the arithmetic rather than from the author's text makes
  * the file depend on a rounding.
  */
-function buildBone(spec: RigBone, soFar: SpineBone[], ctx: BoneContext): SpineBone {
-  const bone: SpineBone = { name: spec.name };
+function buildBone(spec: RigBone, soFar: ModelBone[], ctx: BoneContext): ModelBone {
+  const bone: ModelBone = { name: spec.name };
   if (spec.parent !== undefined) bone.parent = spec.parent;
   if (spec.length !== undefined) bone.length = f32(spec.length);
 
@@ -3487,10 +3521,13 @@ function buildBone(spec: RigBone, soFar: SpineBone[], ctx: BoneContext): SpineBo
   if (spec.scaleY !== undefined) bone.scaleY = f32(spec.scaleY);
   if (spec.shearX !== undefined) bone.shearX = f32(spec.shearX);
   if (spec.shearY !== undefined) bone.shearY = f32(spec.shearY);
-  if (spec.inherit !== undefined) bone.inherit = spec.inherit;
-  if (spec.skin !== undefined) bone.skin = spec.skin;
-  if (spec.color !== undefined) bone.color = spec.color;
-  if (spec.icon !== undefined) bone.icon = spec.icon;
+  if (spec.inherit !== undefined) bone.inheritMode = spec.inherit;
+  if (spec.skin !== undefined) bone.skinRequired = spec.skin;
+  if (spec.color !== undefined || spec.icon !== undefined) {
+    bone.editor = {};
+    if (spec.color !== undefined) bone.editor.color = spec.color;
+    if (spec.icon !== undefined) bone.editor.icon = spec.icon;
+  }
   return bone;
 }
 
@@ -3615,9 +3652,9 @@ function rotationOf(spec: RigBone, ctx: BoneContext): number | null {
  * with a name was in that set, so for those types the position is the same
  * choice rather than a second measurement.
  */
-function withStatedName(att: SpineAttachment, stated: RigAttachment): SpineAttachment {
+function withStatedName(att: SkinTableEntry, stated: RigAttachment): SkinTableEntry {
   const name = (stated as { name?: string }).name;
-  return name === undefined ? att : ({ name, ...att } as SpineAttachment);
+  return name === undefined ? att : { name, ...att };
 }
 
 /**
@@ -3728,7 +3765,7 @@ function refuseDefaultSkinContests(skinNames: readonly string[], skinParts: Map<
 
 interface AttachmentContext {
   images: CompiledImage[];
-  bones: SpineBone[];
+  bones: ModelBone[];
   transforms: Map<string, BoneTransform>;
   meshBones: Set<string>;
   meshes: CompileResult['meshes'];
@@ -3755,6 +3792,12 @@ interface AttachmentContext {
   depths: Map<string, number[]>;
   /** Every slot the rig declares — a clipping attachment's `end` resolves here. */
   slotNames: Set<string>;
+  /**
+   * The `--atlas-in` pack's regions by trimmed name, first match — the map
+   * `resolveFromAtlas` reads — or `null` on the loose route, where the regions
+   * are `images`. A region record's rectangle is looked up here (`regionAtlasRect`).
+   */
+  atlasRegions: ReadonlyMap<string, { region: AtlasRegion }> | null;
   /**
    * Linked meshes whose `source` is still unresolved — `resolveLinkedMeshes`
    * empties it once every skin has been built.
@@ -3844,7 +3887,7 @@ function buildRigAttachment(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineAttachment {
+): SkinTableEntry {
   const stated = (att as { type?: unknown }).type;
   if (stated !== undefined && typeof stated !== 'string') {
     throw new CompileError(
@@ -3913,7 +3956,8 @@ function deferredAttachmentRefusal(type: string, where: string, how: string): st
 }
 
 /**
- * Encode the polygon a bounding box or a clipping attachment carries.
+ * The polygon a bounding box, a clipping attachment or a path carries, as the
+ * model's `ModelVertices`.
  *
  * 🚨 `vertexCount` is required, and everything else here is a cross-check of it.
  * The parser reads `map.vertexCount << 1` and hands that to `readVertices` as the
@@ -3923,12 +3967,12 @@ function deferredAttachmentRefusal(type: string, where: string, how: string): st
  * whatever that garbage produced. It loads. It draws nothing (a bounding box
  * never did) and clips nothing, or clips the wrong shape, in complete silence.
  *
- * The two encodings are the mesh's — `encodeNamedWeights` is the same function —
+ * The two encodings are the mesh's — `bindNamedWeights` is the same function —
  * because they are the same field with the same trap: `readVertices` decides
  * weighted vs unweighted by a length comparison alone, and a coincidental match
- * reads weight data as coordinates.
+ * reads weight data as coordinates. The model says which one it is outright.
  */
-function buildVertexGeometry(att: RigVertexGeometry, where: string, ctx: AttachmentContext): number[] {
+function buildVertexGeometry(att: RigVertexGeometry, where: string, ctx: AttachmentContext): ModelVertices {
   const count = att.vertexCount;
   if (typeof count !== 'number' || !Number.isInteger(count) || count < 3) {
     throw new CompileError(
@@ -3948,7 +3992,7 @@ function buildVertexGeometry(att: RigVertexGeometry, where: string, ctx: Attachm
     if (att.weights.length !== count) {
       throw new CompileError(`${where}: weights cover ${att.weights.length} vertices but vertexCount is ${count}`);
     }
-    return encodeNamedWeights(att.weights, where, ctx);
+    return { weighted: true, bindings: bindNamedWeights(att.weights, where, ctx) };
   }
   const raw = att.vertices;
   if (!raw || raw.length === 0) {
@@ -3967,48 +4011,89 @@ function buildVertexGeometry(att: RigVertexGeometry, where: string, ctx: Attachm
     }
     // A raw run still has to decode to exactly `vertexCount` vertices, or the
     // count and the polygon disagree and the parser believes the count.
-    let decoded = 0;
-    for (let i = 0; i < raw.length; decoded++) {
-      const bones = raw[i++];
-      if (!Number.isInteger(bones) || bones < 1) {
-        throw new CompileError(`${where}: the raw weighted run has a bone count of ${String(bones)} at index ${i - 1}`);
-      }
-      i += bones * 4;
-      if (i > raw.length) {
-        throw new CompileError(
-          `${where}: the raw weighted run is truncated — vertex ${decoded} claims ${bones} bone(s) and the array ends first`,
-        );
-      }
-    }
-    if (decoded !== count) {
-      throw new CompileError(`${where}: the raw weighted run decodes to ${decoded} vertices but vertexCount is ${count}`);
-    }
-    // Register the bones it binds so the mesh-bone reports stay complete.
-    for (let i = 0; i < raw.length; ) {
-      const bones = raw[i++];
-      for (let k = 0; k < bones; k++, i += 4) {
-        const bone = ctx.bones[raw[i]];
-        if (bone) ctx.meshBones.add(bone.name);
-      }
-    }
+    checkRawRunShape(raw, count, `vertexCount is ${count}`, where);
   }
   for (const n of raw) {
     if (!Number.isFinite(n)) throw new CompileError(`${where}: the vertex array holds a non-finite value ${String(n)}`);
   }
-  return raw.map(f32);
+  if (unweighted) return { weighted: false, xy: raw.map(f32) };
+  const bindings = bindRawRun(raw.map(f32), ctx.bones, where);
+  // Register the bones it binds so the mesh-bone reports stay complete.
+  for (const vertex of bindings) for (const binding of vertex) ctx.meshBones.add(binding.bone);
+  return { weighted: true, bindings };
+}
+
+/**
+ * Refuse a raw weighted run whose shape is not `vertices` vertices of
+ * `boneCount, (boneIndex, x, y, weight) × boneCount` each. `countSays` is the
+ * clause naming where the expected count came from.
+ */
+function checkRawRunShape(raw: readonly number[], vertices: number, countSays: string, where: string): void {
+  let decoded = 0;
+  for (let i = 0; i < raw.length; decoded++) {
+    const bones = raw[i++];
+    if (!Number.isInteger(bones) || bones < 1) {
+      throw new CompileError(`${where}: the raw weighted run has a bone count of ${String(bones)} at index ${i - 1}`);
+    }
+    i += bones * 4;
+    if (i > raw.length) {
+      throw new CompileError(
+        `${where}: the raw weighted run is truncated — vertex ${decoded} claims ${bones} bone(s) and the array ends first`,
+      );
+    }
+  }
+  if (decoded !== vertices) {
+    throw new CompileError(`${where}: the raw weighted run decodes to ${decoded} vertices but ${countSays}`);
+  }
+}
+
+/**
+ * Decode an authored raw run (`"boneIndexing": "raw"`) to bindings by name, ONCE,
+ * at intake, against the model's bone order — the order the emitter writes the
+ * indexes back in, so the emitted run is the run the spec stated.
+ *
+ * The shape is already checked (`checkRawRunShape`). An index that names no bone
+ * — past the end of the list, negative, fractional — is refused here with the
+ * sentence the path-length measurement used to raise for it; before issue #917
+ * every other reader of the run skipped it at compile time and left it to the
+ * gate (`A20` on a mesh, `A33` on the other three).
+ */
+function bindRawRun(run: readonly number[], bones: readonly ModelBone[], where: string): ModelBinding[][] {
+  const out: ModelBinding[][] = [];
+  for (let i = 0; i < run.length; ) {
+    const count = run[i++];
+    const vertex: ModelBinding[] = [];
+    for (let k = 0; k < count; k++, i += 4) {
+      const bone = bones[run[i]];
+      if (bone === undefined) {
+        throw new CompileError(`${where}: vertex ${out.length} binds bone index ${run[i]}, which is not in the bone list`);
+      }
+      vertex.push({ bone: bone.name, x: run[i + 1], y: run[i + 2], weight: run[i + 3] });
+    }
+    out.push(vertex);
+  }
+  return out;
+}
+
+/** Every number of a weighted binding list on the float32 grid — what `.map(f32)` did to the run. */
+function bindingsOnF32(vertices: Extract<ModelVertices, { weighted: true }>): Extract<ModelVertices, { weighted: true }> {
+  return {
+    weighted: true,
+    bindings: vertices.bindings.map((vertex) => vertex.map((b) => ({ bone: b.bone, x: f32(b.x), y: f32(b.y), weight: f32(b.weight) }))),
+  };
 }
 
 function buildRigBoundingBox(
   att: RigBoundingBoxAttachment,
   where: string,
   ctx: AttachmentContext,
-): SpineBoundingBoxAttachment {
-  const out: SpineBoundingBoxAttachment = {
-    type: 'boundingbox',
+): ModelBoundingBoxAttachment {
+  const out: ModelBoundingBoxAttachment = {
+    kind: 'boundingbox',
     vertexCount: att.vertexCount,
     vertices: buildVertexGeometry(att, where, ctx),
   };
-  if (att.color !== undefined) out.color = att.color;
+  if (att.color !== undefined) out.editorColor = att.color;
   return out;
 }
 
@@ -4016,7 +4101,7 @@ function buildRigClipping(
   att: RigClippingAttachment,
   where: string,
   ctx: AttachmentContext,
-): SpineClippingAttachment {
+): ModelClippingAttachment {
   if (att.end !== undefined) {
     // `skeletonData.findSlot` returns null on a miss and the parser assigns that
     // null (`:626-627`), so a typo does not fail — the clip simply never ends and
@@ -4028,57 +4113,50 @@ function buildRigClipping(
       );
     }
   }
-  // Field order is the editor's here — `end`, `convex`, `inverse` before the
-  // geometry — via conditional spreads, because a key assigned after the literal
-  // lands at the end instead. Order carries no meaning in JSON; it is read by
-  // people, and this file's diff against a reference is read a lot.
-  const out: SpineClippingAttachment = {
-    type: 'clipping',
+  // Field order is the emitter's (`emitClipping`); a present key here is one the
+  // spec declared.
+  const out: ModelClippingAttachment = {
+    kind: 'clipping',
     ...(att.end !== undefined ? { end: att.end } : {}),
     ...(att.convex !== undefined ? { convex: att.convex } : {}),
     ...(att.inverse !== undefined ? { inverse: att.inverse } : {}),
     vertexCount: att.vertexCount,
     vertices: buildVertexGeometry(att, where, ctx),
   };
-  if (att.color !== undefined) out.color = att.color;
+  if (att.color !== undefined) out.editorColor = att.color;
   return out;
 }
 
 /**
- * Setup-pose world position of every vertex of an emitted vertex run.
+ * Setup-pose world position of every vertex of a model vertex attachment.
  *
  * The two encodings again, and the same split `readVertices` makes: an unweighted
- * run is one `x, y` in the SLOT BONE's space; a weighted one is
- * `boneCount, (boneIndex, bindX, bindY, weight) × n` per vertex, and the vertex
- * is the weighted sum of each influence's bind point taken to world through its
- * own bone. This is `VertexAttachment.computeWorldVertices` at setup, restated in
- * the compiler because the compiler must not link the runtime.
+ * attachment is one `x, y` in the SLOT BONE's space; a weighted one binds each
+ * vertex to its bones by name, and the vertex is the weighted sum of each
+ * influence's bind point taken to world through its own bone. This is
+ * `VertexAttachment.computeWorldVertices` at setup, restated in the compiler
+ * because the compiler must not link the runtime.
  */
 function setupWorldVertices(
-  vertices: number[],
-  vertexCount: number,
+  vertices: ModelVertices,
   anchor: BoneTransform,
-  bones: SpineBone[],
   transforms: Map<string, BoneTransform>,
   where: string,
 ): Array<[number, number]> {
   const out: Array<[number, number]> = [];
-  if (vertices.length === vertexCount * 2) {
-    for (let i = 0; i < vertices.length; i += 2) out.push(toWorld(anchor, vertices[i], vertices[i + 1]));
+  if (!vertices.weighted) {
+    for (let i = 0; i < vertices.xy.length; i += 2) out.push(toWorld(anchor, vertices.xy[i], vertices.xy[i + 1]));
     return out;
   }
-  for (let i = 0; i < vertices.length; ) {
-    const count = vertices[i++];
+  for (const vertex of vertices.bindings) {
     let x = 0;
     let y = 0;
-    for (let n = 0; n < count; n++, i += 4) {
-      const bone = bones[vertices[i]];
-      const m = bone === undefined ? undefined : transforms.get(bone.name);
-      if (!m) throw new CompileError(`${where}: vertex ${out.length} binds bone index ${vertices[i]}, which is not in the bone list`);
-      const [wx, wy] = toWorld(m, vertices[i + 1], vertices[i + 2]);
-      const weight = vertices[i + 3];
-      x += wx * weight;
-      y += wy * weight;
+    for (const binding of vertex) {
+      const m = transforms.get(binding.bone);
+      if (!m) throw new CompileError(`${where}: vertex ${out.length} binds bone "${binding.bone}", which has no setup transform`);
+      const [wx, wy] = toWorld(m, binding.x, binding.y);
+      x += wx * binding.weight;
+      y += wy * binding.weight;
     }
     out.push([x, y]);
   }
@@ -4107,8 +4185,11 @@ function setupWorldVertices(
  * prefix, so the entries the runtime reads are the same numbers either way; the
  * trailing one is read by nothing, and is written so a rebuild is the file the
  * editor writes rather than one entry short of it.
+ *
+ * Exported, with `pathCurveLengths`, for the selftest alone: `MV07` measures a
+ * decode of the emitted run through the two and compares.
  */
-function pathChain(points: Array<[number, number]>, closed: boolean): Array<[number, number]> {
+export function pathChain(points: Array<[number, number]>, closed: boolean): Array<[number, number]> {
   if (!closed) return points.slice(1, points.length - 1);
   return [...points.slice(1), points[0], points[1]];
 }
@@ -4175,7 +4256,7 @@ function pathChain(points: Array<[number, number]>, closed: boolean): Array<[num
  * running total carried across curves rather than restarted. Each of those is a
  * place where a more accurate line would emit a different file.
  */
-function pathCurveLengths(chain: Array<[number, number]>): number[] {
+export function pathCurveLengths(chain: Array<[number, number]>): number[] {
   const out: number[] = [];
   let total = 0;
   for (let c = 0; c + 3 < chain.length; c += 3) {
@@ -4229,7 +4310,7 @@ function pathCurveLengths(chain: Array<[number, number]>): number[] {
  *   3. **An omitted one is measured**, `vertexCount / 3` entries over the closed
  *      chain (`pathChain`), on the unconstrained setup pose.
  */
-function buildRigPath(att: RigPathAttachment, where: string, ctx: AttachmentContext): SpinePathAttachment {
+function buildRigPath(att: RigPathAttachment, where: string, ctx: AttachmentContext): ModelPathAttachment {
   const vertices = buildVertexGeometry(att, where, ctx);
   const count = att.vertexCount;
   const closed = att.closed === true;
@@ -4254,7 +4335,7 @@ function buildRigPath(att: RigPathAttachment, where: string, ctx: AttachmentCont
   } else {
     const anchor = ctx.transforms.get(ctx.anchorBone);
     if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
-    const points = setupWorldVertices(vertices, count, anchor, ctx.bones, ctx.transforms, where);
+    const points = setupWorldVertices(vertices, anchor, ctx.transforms, where);
     lengths = pathCurveLengths(pathChain(points, true));
     // The total the runtime reads is the last CURVE's entry, `lengths[vertexCount
     // / 3 - (closed ? 1 : 2)]` (`PathConstraint.js:204-206`) — on an open path
@@ -4267,17 +4348,17 @@ function buildRigPath(att: RigPathAttachment, where: string, ctx: AttachmentCont
       );
     }
   }
-  // Field order is the parser's reading order (`:606-623`), and each optional key
-  // is present exactly when the spec declared it — the rule the whole rig spec
-  // follows, so Spine's own defaults stand for the rest.
+  // Each optional key is present exactly when the spec declared it — the rule
+  // the whole rig spec follows, so Spine's own defaults stand for the rest. The
+  // field order (the parser's reading order, `:606-623`) is `emitPath`'s.
   return {
-    type: 'path',
+    kind: 'path',
     ...(att.closed !== undefined ? { closed: att.closed } : {}),
     ...(att.constantSpeed !== undefined ? { constantSpeed: att.constantSpeed } : {}),
     vertexCount: count,
     vertices,
     lengths: lengths.map(f32),
-    ...(att.color !== undefined ? { color: att.color } : {}),
+    ...(att.color !== undefined ? { editorColor: att.color } : {}),
   };
 }
 
@@ -4406,8 +4487,9 @@ function attachmentPath(att: { name?: string; path?: string; image?: string }, p
 }
 
 /**
- * A mesh attachment's `path` and `color`, in that order — the two keys every
- * mesh constructor spreads right after `type` (issue #791).
+ * A mesh attachment's `path` and `color` — the two values every mesh builder
+ * spreads into its record, and which `emitMesh` (`src/emit_spine.ts`) writes
+ * right after `type` (issue #791; the position moved to the emitter with #917).
  *
  * 🔬 The editor writes a mesh `type, path, color, uvs, …`: right after `type`,
  * `path` before `color` — measured on a production set (#791), not on
@@ -4416,16 +4498,17 @@ function attachmentPath(att: { name?: string; path?: string; image?: string }, p
  * `path` before `color` is the order the two measured positions leave, not a
  * third measurement. The twelve exports carry neither key on a mesh, which is
  * why `EDITOR_KEY_ORDER`'s `mesh attachment` row does not list them: an unlisted
- * key keeps its constructor's index, so the position is stated HERE, and the
- * row stays what the public exports derive.
+ * key keeps its constructor's index, so the position is stated in the one
+ * constructor that writes the bytes, `emitMesh`, and the row stays what the
+ * public exports derive.
  *
  * ⚠️ Not a linked mesh's, and not a region's. Neither was in the measured set —
  * a region's `path` stays where `buildRigRegion` puts it, a linked mesh's
  * keys where `buildRigLinkedMesh` does — because the analogy to a mesh is
  * obvious and it is not a measurement.
  */
-function meshTextureKeys(att: { name?: string; path?: string; image?: string; color?: string }, placeholder: string): Pick<SpineMeshAttachment, 'path' | 'color'> {
-  const out: Pick<SpineMeshAttachment, 'path' | 'color'> = {};
+function meshTextureKeys(att: { name?: string; path?: string; image?: string; color?: string }, placeholder: string): Pick<ModelMeshAttachment, 'path' | 'color'> {
+  const out: Pick<ModelMeshAttachment, 'path' | 'color'> = {};
   const path = attachmentPath(att, placeholder);
   if (path !== undefined) out.path = path;
   if (att.color !== undefined) out.color = att.color;
@@ -4449,9 +4532,9 @@ function sequenceFrameRegion(stem: string, seq: RigSequence, i: number): string
   return `${stem}${'0'.repeat(Math.max(0, (seq.digits ?? 0) - frame.length))}${frame}`;
 }
 
-/** The emitted `sequence` block: the four fields exactly as the spec stated them. */
-function emitSequence(seq: RigSequence): SpineSequence {
-  const out: SpineSequence = { count: seq.count };
+/** The model's `sequence` record: the four fields exactly as the spec stated them. */
+function buildSequence(seq: RigSequence): ModelSequence {
+  const out: ModelSequence = { count: seq.count };
   if (seq.start !== undefined) out.start = seq.start;
   if (seq.digits !== undefined) out.digits = seq.digits;
   if (seq.setup !== undefined) out.setup = seq.setup;
@@ -4539,10 +4622,11 @@ function buildRigRegion(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineRegionAttachment {
+): ModelRegionAttachment {
   if (att.sequence !== undefined) {
-    const size = sequenceFrameSize(sequenceFrames(att, placeholder, where, ctx), att, where);
-    const out: SpineRegionAttachment = { width: f32(size.width!), height: f32(size.height!) };
+    const frames = sequenceFrames(att, placeholder, where, ctx);
+    const size = sequenceFrameSize(frames, att, where);
+    const out: ModelRegionAttachment = { kind: 'region', width: f32(size.width!), height: f32(size.height!) };
     if (att.path !== undefined) out.path = att.path;
     if (att.x !== undefined) out.x = f32(att.x);
     if (att.y !== undefined) out.y = f32(att.y);
@@ -4550,7 +4634,9 @@ function buildRigRegion(
     if (att.scaleX !== undefined) out.scaleX = f32(att.scaleX);
     if (att.scaleY !== undefined) out.scaleY = f32(att.scaleY);
     if (att.color !== undefined) out.color = att.color;
-    out.sequence = emitSequence(att.sequence);
+    // Each frame draws through its own rectangle (`Sequence.apply`), in frame order.
+    const sequence: ModelRegionSequence = { ...buildSequence(att.sequence), atlas: frames.map(imageAtlasRect) };
+    out.sequence = sequence;
     return out;
   }
   const img = att.image === undefined ? null : atlasedImage(att.image, where, ctx);
@@ -4592,7 +4678,7 @@ function buildRigRegion(
       `${where}: a region needs width and height — give them, or give an "image" and rigc will measure the PNG`,
     );
   }
-  const out: SpineRegionAttachment = { width: f32(width), height: f32(height) };
+  const out: ModelRegionAttachment = { kind: 'region', width: f32(width), height: f32(height) };
   const path = attachmentPath(att, placeholder);
   if (path !== undefined) out.path = path;
   if (att.x !== undefined) out.x = f32(att.x);
@@ -4601,41 +4687,89 @@ function buildRigRegion(
   if (att.scaleX !== undefined) out.scaleX = f32(att.scaleX);
   if (att.scaleY !== undefined) out.scaleY = f32(att.scaleY);
   if (att.color !== undefined) out.color = att.color;
+  // The region the runtime asks the atlas for: `path`, else the name
+  // (`getValue(map, "path", name)`), which is the stated `name`, else the placeholder.
+  out.atlas = regionAtlasRect(path ?? att.name ?? placeholder, ctx.images, ctx.atlasRegions);
   return out;
 }
 
 /**
- * Resolve an authored mesh's by-name weights into Spine's index run.
+ * The rectangle a region draws through, as the atlas states it — the six
+ * fields `ModelAtlasRect` holds, copied, nothing derived.
+ */
+function atlasRectOf(region: AtlasRegion): ModelAtlasRect {
+  return {
+    width: region.width,
+    height: region.height,
+    offsetX: region.offsetX,
+    offsetY: region.offsetY,
+    originalWidth: region.originalWidth,
+    originalHeight: region.originalHeight,
+  };
+}
+
+/**
+ * The rectangle an atlased image draws through: the pack's region under
+ * `--atlas-in`, else the loose PNG as its own page, which is exactly the region
+ * `buildAtlasText` writes for it — kept size and original size the PNG's,
+ * offsets 0.
+ */
+function imageAtlasRect(img: CompiledImage): ModelAtlasRect {
+  if (img.atlas !== undefined) return atlasRectOf(img.atlas);
+  return { width: img.width, height: img.height, offsetX: 0, offsetY: 0, originalWidth: img.width, originalHeight: img.height };
+}
+
+/**
+ * The rectangle of the region named `name` in the build's one atlas source —
+ * the `--atlas-in` pack when there is one, else the images atlased from loose
+ * PNGs — or `null` when that source has no region of the name (issue #935).
  *
- * 🚨 This is the whole point of the `weights` form. The run is
+ * `null` is the build saying it has no source, never a guessed trim of 0: the
+ * atlas this build emits is that same source, so the region is missing from it
+ * too, and `A08_REGION_NAMES_MATCH_ATTACHMENTS` refuses the build by the name.
+ */
+function regionAtlasRect(
+  name: string,
+  images: readonly CompiledImage[],
+  atlasRegions: ReadonlyMap<string, { region: AtlasRegion }> | null,
+): ModelAtlasRect | null {
+  if (atlasRegions !== null) {
+    const found = atlasRegions.get(name);
+    return found === undefined ? null : atlasRectOf(found.region);
+  }
+  const img = images.find((im) => im.region === name);
+  return img === undefined ? null : imageAtlasRect(img);
+}
+
+/**
+ * Resolve an authored attachment's by-name weights into the model's bindings.
+ *
+ * 🚨 This is the whole point of the `weights` form. Spine's run is
  * `boneCount, (boneIndex, bindX, bindY, weight) x n` per vertex and those
  * indices are positions in the emitted bone array — a thing the rig spec never
- * writes. Resolving them here, from names, is what makes "insert a bone" a
+ * writes. Keeping the NAME here, and letting the emitter write the index from
+ * the model's bone order (`emitVertices`), is what makes "insert a bone" a
  * renumbering rather than a rebinding: the names still point at the same bones,
  * so the emitted indices move and the mesh does not.
  *
  * An unknown name is a `CompileError`, the same as a bone's `parent`, a slot's
  * `bone` or a constraint's `target`. The alternative — the raw form — cannot
- * refuse anything, because an index has no name to be wrong.
+ * refuse a rebind, because an index has no name to be wrong.
  */
-function encodeNamedWeights(weights: RigMeshBinding[][], where: string, ctx: AttachmentContext): number[] {
-  const out: number[] = [];
-  weights.forEach((vertex, i) => {
+function bindNamedWeights(weights: RigMeshBinding[][], where: string, ctx: AttachmentContext): ModelBinding[][] {
+  return weights.map((vertex, i) => {
     if (!Array.isArray(vertex) || vertex.length === 0) {
       throw new CompileError(`${where}: vertex ${i} has no bone bindings; a weighted vertex names at least one bone`);
     }
-    out.push(vertex.length);
-    for (const binding of vertex) {
-      const index = ctx.bones.findIndex((b) => b.name === binding.bone);
-      if (index < 0) {
+    return vertex.map((binding) => {
+      if (!ctx.bones.some((b) => b.name === binding.bone)) {
         throw new CompileError(
           `${where}: vertex ${i} binds bone ${JSON.stringify(binding.bone)}, which the rig does not declare as a bone`,
         );
       }
-      out.push(index, f32(binding.x), f32(binding.y), f32(binding.weight));
-    }
+      return { bone: binding.bone, x: f32(binding.x), y: f32(binding.y), weight: f32(binding.weight) };
+    });
   });
-  return out;
 }
 
 /**
@@ -4780,7 +4914,7 @@ function buildRigMesh(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineMeshAttachment {
+): ModelMeshAttachment {
   const authored =
     att.uvs !== undefined || att.triangles !== undefined || att.vertices !== undefined || att.weights !== undefined;
   if (authored && att.generator) {
@@ -4796,7 +4930,7 @@ function buildRigMesh(
     throw new CompileError(`${where}: an authored mesh needs uvs, triangles and vertices or weights (or a "generator")`);
   }
   const uvCount = att.uvs.length;
-  let vertices: number[];
+  let vertices: ModelVertices;
   let boundBones: string[] = [];
   if (att.weights) {
     if (att.boneIndexing === 'raw') {
@@ -4807,7 +4941,7 @@ function buildRigMesh(
         `${where}: weights cover ${att.weights.length} vertices but there are ${uvCount / 2} uv pairs`,
       );
     }
-    vertices = encodeNamedWeights(att.weights, where, ctx);
+    vertices = { weighted: true, bindings: bindNamedWeights(att.weights, where, ctx) };
     boundBones = [...new Set(att.weights.flat().map((b) => b.bone))];
   } else {
     const raw = att.vertices!;
@@ -4822,17 +4956,17 @@ function buildRigMesh(
           'or say "boneIndexing": "raw" on this attachment to keep the index form deliberately.',
       );
     }
-    vertices = raw.map(f32);
     if (weighted) {
-      const names = new Set<string>();
-      for (let i = 0; i < raw.length; ) {
-        const n = raw[i++];
-        for (let k = 0; k < n; k++, i += 4) {
-          const bone = ctx.bones[raw[i]];
-          if (bone) names.add(bone.name);
-        }
-      }
-      boundBones = [...names];
+      // Decoded to names once, here, against the model's bone order — which is
+      // the order the emitter writes the indexes back in, so the emitted run is
+      // the run the spec stated. A run the model cannot hold is refused by name
+      // rather than left to `A20` at the gate (issue #917).
+      checkRawRunShape(raw, uvCount / 2, `there are ${uvCount / 2} uv pairs`, where);
+      const bindings = bindRawRun(raw.map(f32), ctx.bones, where);
+      vertices = { weighted: true, bindings };
+      boundBones = [...new Set(bindings.flat().map((b) => b.bone))];
+    } else {
+      vertices = { weighted: false, xy: raw.map(f32) };
     }
   }
   const { hull, edges } = authoredHullAndEdges(att, uvCount / 2, att.triangles, where);
@@ -4852,8 +4986,8 @@ function buildRigMesh(
       `${where}: a mesh needs width and height — give them, or give an "image" and rigc will measure the PNG`,
     );
   }
-  const out: SpineMeshAttachment = {
-    type: 'mesh',
+  const out: ModelMeshAttachment = {
+    kind: 'mesh',
     ...meshTextureKeys(att, placeholder),
     uvs: att.uvs.map(f32),
     triangles: att.triangles,
@@ -4863,7 +4997,7 @@ function buildRigMesh(
     width: f32(width),
     height: f32(height),
   };
-  if (att.sequence !== undefined) out.sequence = emitSequence(att.sequence);
+  if (att.sequence !== undefined) out.sequence = buildSequence(att.sequence);
   // Register it as `authored`: geometry rigc did not build and whose topology it
   // therefore gets to assume nothing about. The generator-topology assertions
   // read this and skip rather than measuring a ring that was never a ring.
@@ -4916,7 +5050,7 @@ function buildRigLinkedMesh(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineLinkedMeshAttachment {
+): ModelLinkedMeshAttachment {
   // The mesh keys the parser does not reach on this branch. Named one by one,
   // because "remove what does not belong" is not an instruction an author can
   // act on and the remedy for each of these is the same single sentence.
@@ -4968,17 +5102,23 @@ function buildRigLinkedMesh(
       `${where}: a linked mesh needs width and height — give them, or give an "image" and rigc will measure the PNG`,
     );
   }
-  const out: SpineLinkedMeshAttachment = { type: 'linkedmesh', source, width: f32(width), height: f32(height) };
+  // The link in full — skin, slot and `timelines` as the parser resolves them.
+  // Writing each only where it differs from the parser's own default (a
+  // `timelines: true` or a `skin` of "default" would be a byte the editor's own
+  // export does not carry) is the emitter's (`emitLinkedMesh`).
+  const out: ModelLinkedMeshAttachment = {
+    kind: 'linkedmesh',
+    source,
+    skin: att.skin ?? 'default',
+    slot: att.slot ?? ctx.slotName,
+    timelines: att.timelines !== false,
+    width: f32(width),
+    height: f32(height),
+  };
   const path = attachmentPath(att, placeholder);
   if (path !== undefined) out.path = path;
-  // Only where they differ from the parser's own defaults. Writing `timelines:
-  // true`, or a `skin` of "default", would be a byte the editor's own export
-  // does not carry.
-  if (att.slot !== undefined && att.slot !== ctx.slotName) out.slot = att.slot;
-  if (att.skin !== undefined && att.skin !== 'default') out.skin = att.skin;
-  if (att.timelines === false) out.timelines = false;
   if (att.color !== undefined) out.color = att.color;
-  if (att.sequence !== undefined) out.sequence = emitSequence(att.sequence);
+  if (att.sequence !== undefined) out.sequence = buildSequence(att.sequence);
   // 🚫 NOT registered in `ctx.meshes`, and that is a decision rather than an
   // omission. `meshKinds` is keyed by SLOT and the commonest linked mesh shares
   // its source's slot from another skin, so an entry here would overwrite the
@@ -5005,7 +5145,7 @@ function buildRigLinkedMesh(
  */
 function resolveLinkedMeshes(
   links: readonly PendingLink[],
-  tables: Map<string, Record<string, Record<string, SpineAttachment>>>,
+  tables: ReadonlyMap<string, SkinTable>,
 ): void {
   const skinNames = [...tables.keys()];
   for (const link of links) {
@@ -5046,7 +5186,7 @@ function resolveLinkedMeshes(
           "Left to the round trip this is the runtime's `Source mesh not found`.",
       );
     }
-    const type = (found as { type?: string }).type ?? 'region';
+    const type = found.kind;
     if (type === 'linkedmesh') {
       throw new CompileError(
         `${link.where}: "source" is ${JSON.stringify(link.source)}, which is itself a linked mesh, and a chain of ` +
@@ -5081,25 +5221,24 @@ function buildGeneratedMesh(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineMeshAttachment {
+): ModelMeshAttachment {
   if (generator.kind === 'contour') return buildContourAttachment(att, generator, placeholder, where, ctx);
   if (generator.kind === 'grid') return buildGridAttachment(att, generator, placeholder, where, ctx);
   if (generator.kind === 'segments') return buildSegmentsAttachment(att, generator, placeholder, where, ctx);
   const controls = generator.kind === 'ring' ? generator.controls : generator.chain;
-  // Resolving the bone list and the setup transform is one step with two named
-  // refusals, because the ring's control angles need the transform and the encode
-  // needs the index — and the two must refuse a bone the rig lacks in the same
+  // Resolving the bone and its setup transform is one step with two named
+  // refusals, because the ring's control angles need the transform and the bind
+  // needs the bone — and the two must refuse a bone the rig lacks in the same
   // words whichever of them asks for it first.
-  const resolve = (name: string): { index: number; transform: BoneTransform } => {
-    const index = ctx.bones.findIndex((b) => b.name === name);
-    if (index < 0) throw new CompileError(`${where}: mesh bone "${name}" is not in the rig's bone list`);
+  const resolve = (name: string): BoneTransform => {
+    if (!ctx.bones.some((b) => b.name === name)) throw new CompileError(`${where}: mesh bone "${name}" is not in the rig's bone list`);
     const transform = ctx.transforms.get(name);
     if (!transform) throw new CompileError(`${where}: no setup transform for mesh bone "${name}"`);
-    return { index, transform };
+    return transform;
   };
   const refFor = (name: string): MeshBoneRef => {
-    const { index, transform } = resolve(name);
-    return { index, toBind: (wx, wy) => toBoneLocal(transform, wx, wy) };
+    const transform = resolve(name);
+    return { name, toBind: (wx, wy) => toBoneLocal(transform, wx, wy) };
   };
   // The generator works in part-local pixels, y down. Without a manifest there is
   // no crop to flip against, so the part window is centred on its own slot bone.
@@ -5123,7 +5262,7 @@ function buildGeneratedMesh(
             size: generator.size,
             bias: generator.bias,
             controlAngles: ringControlAngles(controls, generator.center, (name) => {
-              const { transform } = resolve(name);
+              const transform = resolve(name);
               return toPartLocal(transform.worldX, transform.worldY);
             }),
           });
@@ -5131,7 +5270,7 @@ function buildGeneratedMesh(
     if (err instanceof MeshError) throw new CompileError(`${where}: ${err.message}`);
     throw err;
   }
-  const vertices = encodeWeightedVertices(
+  const vertices = bindWeightedVertices(
     geometry,
     // The world point is an INTERMEDIATE — `toBind` makes it local and the
     // result is what is emitted, through `f32` below — so it carries the double.
@@ -5150,12 +5289,12 @@ function buildGeneratedMesh(
     triangles: geometry.triangles.length / 3,
     bones: [ctx.anchorBone, ...controls],
   });
-  const out: SpineMeshAttachment = {
-    type: 'mesh',
+  const out: ModelMeshAttachment = {
+    kind: 'mesh',
     ...meshTextureKeys(att, placeholder),
     uvs: geometry.uvs.map(f32),
     triangles: geometry.triangles,
-    vertices: vertices.map(f32),
+    vertices: bindingsOnF32(vertices),
     ...generatedHullAndEdges(geometry, where),
     width: f32(w),
     height: f32(h),
@@ -5231,7 +5370,7 @@ function sampleMeshDepth(
   triangles: ReadonlyArray<number>,
   /**
    * A part-local pixel to the BIND space this mesh's vertices are emitted in —
-   * the same composition `encodeWeightedVertices` applies, handed in rather than
+   * the same composition `bindWeightedVertices` applies, handed in rather than
    * rebuilt so the two cannot diverge.
    *
    * 🚨 The ceiling has to be taken in bind space and in no other. A deform
@@ -5391,13 +5530,12 @@ function sampleMeshDepth(
   };
 }
 
-/** One bone of the rig as `encodeWeightedVertices` wants it. */
+/** One bone of the rig as `bindWeightedVertices` wants it: by name, with its setup inverse. */
 function meshBoneRef(name: string, where: string, ctx: AttachmentContext): MeshBoneRef {
   const transform = ctx.transforms.get(name);
   if (!transform) throw new CompileError(`${where}: bone "${name}" has no setup transform`);
-  const index = ctx.bones.findIndex((b) => b.name === name);
-  if (index < 0) throw new CompileError(`${where}: bone "${name}" is not in the rig's bone list`);
-  return { index, toBind: (wx, wy) => toBoneLocal(transform, wx, wy) };
+  if (!ctx.bones.some((b) => b.name === name)) throw new CompileError(`${where}: bone "${name}" is not in the rig's bone list`);
+  return { name, toBind: (wx, wy) => toBoneLocal(transform, wx, wy) };
 }
 
 /**
@@ -5602,7 +5740,7 @@ function buildGridAttachment(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineMeshAttachment {
+): ModelMeshAttachment {
   if (att.image === undefined) {
     throw new CompileError(
       `${where}: a "grid" generator lays its lattice over the part's own window, so the attachment needs an ` +
@@ -5663,8 +5801,9 @@ function buildGridAttachment(
   }
   const anchor = ctx.transforms.get(ctx.anchorBone);
   if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
-  const index = ctx.bones.findIndex((b) => b.name === ctx.anchorBone);
-  if (index < 0) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
+  if (!ctx.bones.some((b) => b.name === ctx.anchorBone)) {
+    throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
+  }
   // Sampled BEFORE the encode, because `bind` rewrites the weights the encode
   // then writes out.
   const depth =
@@ -5691,11 +5830,11 @@ function buildGridAttachment(
       ? undefined
       : softRegionWeights(generator.soft, geometry.points, sheetGridOf(img, plate), where, ctx);
   if (bound) geometry = { ...geometry, weights: bound.weights };
-  const vertices = encodeWeightedVertices(
+  const vertices = bindWeightedVertices(
     geometry,
     (px, py) => [anchor.worldX + px * toArt - w / 2, anchor.worldY + h / 2 - py * toArt],
     {
-      anchor: { index, toBind: (wx, wy) => toBoneLocal(anchor, wx, wy) },
+      anchor: { name: ctx.anchorBone, toBind: (wx, wy) => toBoneLocal(anchor, wx, wy) },
       controls: bound ? [meshBoneRef(bound.bone, where, ctx)] : [],
     },
   );
@@ -5715,12 +5854,12 @@ function buildGridAttachment(
         ? undefined
         : { mask: bound.mask, digest: bound.digest, bone: bound.bone, carried: bound.carried, ramped: bound.ramped },
   });
-  const out: SpineMeshAttachment = {
-    type: 'mesh',
+  const out: ModelMeshAttachment = {
+    kind: 'mesh',
     ...meshTextureKeys(att, placeholder),
     uvs: geometry.uvs.map(f32),
     triangles: geometry.triangles,
-    vertices: vertices.map(f32),
+    vertices: bindingsOnF32(vertices),
     ...generatedHullAndEdges(geometry, where),
     width: f32(w),
     height: f32(h),
@@ -5772,7 +5911,7 @@ function buildSegmentsAttachment(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineMeshAttachment {
+): ModelMeshAttachment {
   if (att.image === undefined) {
     throw new CompileError(
       `${where}: a "segments" generator lays its lattice over the part's own alpha, so the attachment needs an ` +
@@ -5999,7 +6138,7 @@ function buildSegmentsAttachment(
     weights,
     hullVertices: lattice.hullVertices,
   };
-  const vertices = encodeWeightedVertices(geometry, place, {
+  const vertices = bindWeightedVertices(geometry, place, {
     anchor: meshBoneRef(ctx.anchorBone, where, ctx),
     controls: refs,
   });
@@ -6046,11 +6185,11 @@ function buildSegmentsAttachment(
     },
   });
   return {
-    type: 'mesh',
+    kind: 'mesh',
     ...meshTextureKeys(att, placeholder),
     uvs: geometry.uvs.map(f32),
     triangles: geometry.triangles,
-    vertices: vertices.map(f32),
+    vertices: bindingsOnF32(vertices),
     ...generatedHullAndEdges(geometry, where),
     width: f32(w),
     height: f32(h),
@@ -6088,7 +6227,7 @@ function buildContourAttachment(
   placeholder: string,
   where: string,
   ctx: AttachmentContext,
-): SpineMeshAttachment {
+): ModelMeshAttachment {
   if (att.image === undefined) {
     throw new CompileError(
       `${where}: a "contour" generator traces the part's own alpha, so the attachment needs an "image" — ` +
@@ -6161,12 +6300,13 @@ function buildContourAttachment(
   }
   const anchor = ctx.transforms.get(ctx.anchorBone);
   if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
-  const index = ctx.bones.findIndex((b) => b.name === ctx.anchorBone);
-  if (index < 0) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
-  const vertices = encodeWeightedVertices(
+  if (!ctx.bones.some((b) => b.name === ctx.anchorBone)) {
+    throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
+  }
+  const vertices = bindWeightedVertices(
     geometry,
     (px, py) => [anchor.worldX + px * toArt - w / 2, anchor.worldY + h / 2 - py * toArt],
-    { anchor: { index, toBind: (wx, wy) => toBoneLocal(anchor, wx, wy) }, controls: [] },
+    { anchor: { name: ctx.anchorBone, toBind: (wx, wy) => toBoneLocal(anchor, wx, wy) }, controls: [] },
   );
   ctx.meshBones.add(ctx.anchorBone);
   // The vertices are on the TRACED grid — the plate's — and the depth map is
@@ -6211,12 +6351,12 @@ function buildContourAttachment(
   // this comment used to be the rule's only statement, beside four emit sites
   // that disagreed with it — and spread right after `type` by
   // `meshTextureKeys` since #791.
-  const out: SpineMeshAttachment = {
-    type: 'mesh',
+  const out: ModelMeshAttachment = {
+    kind: 'mesh',
     ...meshTextureKeys(att, placeholder),
     uvs: geometry.uvs.map(f32),
     triangles: geometry.triangles,
-    vertices: vertices.map(f32),
+    vertices: bindingsOnF32(vertices),
     ...generatedHullAndEdges(geometry, where),
     width: f32(w),
     height: f32(h),
@@ -6270,7 +6410,7 @@ interface ConstraintContext {
  * type matches no case is dropped with no error and no `default:` branch, so an
  * unimplemented type is refused here by name rather than emitted and lost.
  */
-function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): SpineConstraint {
+function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): ModelConstraint {
   const where = `rig constraint "${spec.name}"`;
   const boneNames = ctx.boneNames;
   const needBone = (name: unknown, field: string): string => {
@@ -6303,7 +6443,11 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
     }
     return value;
   };
-  const out: SpineConstraint = { name: spec.name, type: spec.type };
+  // The constraint's fields under their spec names; `made` puts the kind the
+  // branch has established and the name on them. `name, type` first and each
+  // kind's field order are the emitter's (`emitConstraint`).
+  const out: Record<string, unknown> = {};
+  const made = (kind: ModelConstraintKind): ModelConstraint => ({ kind, name: spec.name, declaredIn: 'rig', ...out });
   const copy = (fields: readonly string[]) => {
     for (const field of fields) {
       const v = spec[field];
@@ -6327,7 +6471,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
     // see `RIG_SCALE_Y_MODES`.
     if (spec.scaleY !== undefined) out.scaleY = needEnum(spec.scaleY, 'scaleY', RIG_SCALE_Y_MODES);
     copy(['mix', 'softness', 'bendPositive', 'compress', 'stretch', 'skin']);
-    return out;
+    return made('ik');
   }
   if (spec.type === 'transform') {
     out.bones = boneList();
@@ -6366,7 +6510,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
       'mixShearY',
       'skin',
     ]);
-    return out;
+    return made('transform');
   }
   if (spec.type === 'path') {
     out.bones = boneList();
@@ -6400,7 +6544,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
       if (spec[field] !== undefined) out[field] = f32(needNumber(spec[field], field));
     }
     copy(['skin']);
-    return out;
+    return made('path');
   }
   if (spec.type === 'slider') {
     // ⭐ The one field in a rig spec that points at the MOTION spec. It is
@@ -6792,7 +6936,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
       }
     }
     copy(['skin']);
-    return out;
+    return made('slider');
   }
   if (spec.type === 'physics') {
     out.bone = needBone(spec.bone, 'bone');
@@ -6823,7 +6967,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
       'mixGlobal',
       'skin',
     ]);
-    return out;
+    return made('physics');
   }
   // Every type 4.3 has is implemented, so this is now only reachable from a typo
   // — and a typo is exactly what the parser drops in silence (no `default:`
@@ -6846,7 +6990,7 @@ function buildRigConstraint(spec: RigConstraintInput, ctx: ConstraintContext): S
  */
 function buildRigInfo(
   rig: RigSpec,
-  bones: SpineBone[],
+  bones: ModelBone[],
   meshes: CompileResult['meshes'],
   manifest: FaceManifest | null,
   images: CompiledImage[],
@@ -6959,26 +7103,23 @@ function checkAxisSelfConsistency(manifest: FaceManifest): void {
  * without it every slot hanging off a rotated axis bone would render tilted by
  * the cut's axis angle.
  *
- * On an unrotated bone sitting at its window centre both terms are zero and the
- * fields are omitted, which is why a formation with no axis emits the same
- * bytes it always did.
+ * On an unrotated bone sitting at its window centre both terms are zero, and the
+ * emitter leaves a zero out, which is why a formation with no axis emits the
+ * same bytes it always did.
  */
 function placeRegion(
   part: FaceManifestPart,
   manifest: FaceManifest,
   bone: BoneTransform,
   img: CompiledImage,
-): SpineRegionAttachment {
+): ModelRegionAttachment {
   const win = partWindow(part, manifest);
   // width/height are NOT optional: omitting them loads as NaN with no error.
   // The compiler fills them from the PNG.
-  const att: SpineRegionAttachment = { width: img.width, height: img.height };
   const [ax, ay] = toBoneLocal(bone, win.x + win.w / 2, cropToSpineY(win.y + win.h / 2, manifest.crop.h)).map(f32);
-  if (ax !== 0) att.x = ax;
-  if (ay !== 0) att.y = ay;
   const rotation = f32(normaliseDegrees(-bone.worldRotation));
-  if (rotation !== 0) att.rotation = rotation;
-  return att;
+  // All three held, 0 included: leaving a 0 out is the emitter's (`emitRegion`).
+  return { kind: 'region', width: img.width, height: img.height, x: ax, y: ay, rotation, atlas: imageAtlasRect(img) };
 }
 
 /**
@@ -6992,10 +7133,10 @@ function placeRegion(
 function buildMesh(
   part: FaceManifestPart,
   manifest: FaceManifest,
-  bones: SpineBone[],
+  bones: ModelBone[],
   transforms: Map<string, BoneTransform>,
   anchorName: string,
-): { attachment: SpineMeshAttachment; kind: 'ring' | 'ribbon' } {
+): { attachment: ModelMeshAttachment; kind: 'ring' | 'ribbon' } {
   const spec = part.mesh!;
   const kind = spec.kind ?? 'ring';
   const win = partWindow(part, manifest);
@@ -7003,11 +7144,10 @@ function buildMesh(
   const controls = meshControlBones(part);
 
   const refFor = (name: string): MeshBoneRef => {
-    const index = bones.findIndex((b) => b.name === name);
-    if (index < 0) throw new CompileError(`internal: mesh bone "${name}" is not in the bone list`);
+    if (!bones.some((b) => b.name === name)) throw new CompileError(`internal: mesh bone "${name}" is not in the bone list`);
     const m = transforms.get(name);
     if (!m) throw new CompileError(`internal: no setup transform for mesh bone "${name}"`);
-    return { index, toBind: (wx, wy) => toBoneLocal(m, wx, wy) };
+    return { name, toBind: (wx, wy) => toBoneLocal(m, wx, wy) };
   };
 
   let geometry;
@@ -7047,7 +7187,7 @@ function buildMesh(
     throw err;
   }
 
-  const vertices = encodeWeightedVertices(
+  const vertices = bindWeightedVertices(
     geometry,
     (px, py) => [win.x + px, cropToSpineY(win.y + py, cropH)],
     { anchor: refFor(anchorName), controls: controls.map(refFor) },
@@ -7056,10 +7196,10 @@ function buildMesh(
   return {
     kind: geometry.kind,
     attachment: {
-      type: 'mesh',
+      kind: 'mesh',
       uvs: geometry.uvs.map(f32),
       triangles: geometry.triangles,
-      vertices: vertices.map(f32),
+      vertices: bindingsOnF32(vertices),
       ...generatedHullAndEdges(geometry, `slot "${part.slot}" mesh`),
       width: win.w,
       height: win.h,
@@ -7123,13 +7263,13 @@ function compileValueTrack(
   shift: number,
   shapes: Record<string, ValueTrackShape>,
   kind: string,
-): SpineTimelineKey[] {
+): ModelKey[] {
   const shape = shapes[track.property];
   if (!shape) throw new CompileError(`animation "${animName}": ${kind} "${target}" has no property "${track.property}"`);
   const where = `animation "${animName}" ${kind} "${target}" ${track.property}`;
   if (!track.keys.length) throw new CompileError(`${where}: no keys`);
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const next = track.keys[i + 1];
@@ -7169,7 +7309,7 @@ function compileValueTrack(
     if (!Array.isArray(key.v) || key.v.length !== shape.fields.length) {
       throw new CompileError(`${where}: key value must be an array of ${shape.fields.length} number(s)`);
     }
-    const entry: SpineTimelineKey = { time };
+    const entry: ModelKey = { time };
     shape.fields.forEach((field, c) => {
       const v = key.v as number[];
       if (!Number.isFinite(v[c])) throw new CompileError(`${where}: non-finite value ${String(v[c])}`);
@@ -7234,7 +7374,8 @@ function compileValueTrack(
  *      than loading wrong. The author states a set of moves; the array order in
  *      the file is the parser's requirement and not a decision, so rigc sorts
  *      rather than making every caller remember. Deterministic: the key is the
- *      emitted slot index.
+ *      emitted slot index. The model holds the moves as stated and the Spine
+ *      emitter sorts them (`emitDrawOrderKey`, issue #921).
  *   2. **One slot per key.** Two entries for the same slot means two writes at
  *      one cursor position; the second silently wins and the first slot's place
  *      is left to the unchanged-fill.
@@ -7254,13 +7395,13 @@ function compileDrawOrder(
   keys: MotionDrawOrderKey[],
   animName: string,
   duration: number,
-  slots: SpineSlot[],
-): SpineTimelineKey[] {
+  slots: readonly ModelSlot[],
+): ModelKey[] {
   const where = `animation "${animName}" drawOrder`;
   if (!keys.length) throw new CompileError(`${where}: no keys`);
   const indexOf = new Map(slots.map((s, i) => [s.name, i]));
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     const time = keyTime(key.t);
@@ -7276,7 +7417,7 @@ function compileDrawOrder(
       continue;
     }
     const seen = new Set<string>();
-    const entries: Array<{ slot: string; offset: number; index: number }> = [];
+    const entries: Array<{ slot: string; offset: number }> = [];
     for (const off of key.offsets) {
       const index = indexOf.get(off.slot);
       if (index === undefined) {
@@ -7296,10 +7437,11 @@ function compileDrawOrder(
         );
       }
       seen.add(off.slot);
-      entries.push({ slot: off.slot, offset: off.offset, index });
+      entries.push({ slot: off.slot, offset: off.offset });
     }
-    entries.sort((a, b) => a.index - b.index);
-    out.push({ time, offsets: entries.map((e) => ({ slot: e.slot, offset: e.offset })) });
+    // In the order the spec states the moves: the setup-order sort the parser
+    // needs is the Spine emitter's (`emitDrawOrderKey`, issue #921).
+    out.push({ time, offsets: entries });
   }
   return out;
 }
@@ -7334,11 +7476,11 @@ function compileEvents(
   animName: string,
   duration: number,
   events: Record<string, RigEvent>,
-): SpineTimelineKey[] {
+): ModelKey[] {
   const where = `animation "${animName}" events`;
   if (!keys.length) throw new CompileError(`${where}: no keys`);
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     if (typeof key.name !== 'string' || key.name.length === 0) {
@@ -7361,7 +7503,7 @@ function compileEvents(
     }
     checkKeyTime(where, time, key.t, duration);
 
-    const entry: SpineTimelineKey = { time, name: key.name };
+    const entry: ModelKey = { time, name: key.name };
     if (key.int !== undefined) {
       if (!Number.isInteger(key.int)) {
         throw new CompileError(`${where} at t=${key.t}: int ${String(key.int)} is not an integer`);
@@ -7448,9 +7590,9 @@ function compileConstraintTrack(
   motion: MotionSpec,
   animName: string,
   duration: number,
-  /** Non-default ik booleans the rig declared, by field. Empty for `transform`. */
+  /** The ik constraint's three booleans in effect, by field. Empty for `transform`. */
   rigFlags: Record<string, boolean>,
-): SpineTimelineKey[] {
+): ModelKey[] {
   const shape = CONSTRAINT_TIMELINES[group];
   const article = group === 'ik' ? 'an' : 'a';
   const where = `animation "${animName}" ${group} constraint "${track.constraint}"`;
@@ -7499,7 +7641,7 @@ function compileConstraintTrack(
     return inherited === undefined ? channel.dflt : (inherited as number);
   };
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     const next = keys[i + 1];
@@ -7509,7 +7651,7 @@ function compileConstraintTrack(
     }
     checkKeyTime(where, time, key.t, duration);
 
-    const entry: SpineTimelineKey = { time };
+    const entry: ModelKey = { time };
     for (const channel of shape.channels) {
       const v = read(key, channel.field);
       if (v === undefined) continue;
@@ -7529,10 +7671,10 @@ function compileConstraintTrack(
     for (const flag of shape.flags) {
       const v = read(key, flag.field);
       if (v === undefined) {
-        // The rig's value, stamped on this key because nothing else will carry
-        // it there. Absent from `rigFlags` means the rig's value IS the per-key
-        // default, so omitting the field says the same thing and the emitted
-        // bytes do not move.
+        // The constraint's flag in effect, held on this key because the parser
+        // reads the flag per key and does not inherit it. The model key holds
+        // every flag in effect; the Spine emitter writes one only where it
+        // differs from the per-key default (`emitAnimations`, issue #921).
         const carried = rigFlags[flag.field];
         if (carried !== undefined) entry[flag.field] = carried;
         continue;
@@ -7594,7 +7736,7 @@ function defaultOf(shape: ConstraintTimelineShape, field: string): number | bool
  * Same shape, two meanings, and picking the wrong one writes a run that silently
  * lands on the wrong vertices.
  */
-interface DeformGeometry {
+export interface DeformGeometry {
   weighted: boolean;
   /** How long the array the key edits is. */
   deformLength: number;
@@ -7641,7 +7783,7 @@ interface DeformGeometry {
   /**
    * Per-vertex `z`, when this attachment's generator named a depth map.
    *
-   * Not measured from the emitted attachment like everything else here — there
+   * Not measured from the attachment like everything else here — there
    * is nowhere in the format to measure it FROM, which is the whole reason the
    * sampler keeps it beside the skeleton instead of in it. Filled in by the
    * caller, which is where the skin, slot and attachment names live.
@@ -7650,25 +7792,35 @@ interface DeformGeometry {
 }
 
 /**
- * Measure one emitted attachment's deform array.
+ * Measure one attachment's deform array, off its model record (issue #917): the
+ * bindings name their bones, so each influence's setup transform is looked up by
+ * name and no index into any bone array is read.
  *
  * A region attachment is refused rather than measured: it has no `vertices` at
  * all, so `attachment.vertices.length` throws inside the parser — one of the very
  * few places this format fails loudly, and it fails in the consumer's process.
+ * A linked mesh is refused the same way, by its type.
+ *
+ * Exported for the selftest alone: `MV06` holds it to the decoder of the emitted
+ * run it replaced, to the bit.
  */
-function deformGeometryOf(
-  att: SpineAttachment,
+export function deformGeometryOf(
+  att: SkinTableEntry,
   where: string,
-  /** The emitted bone array, which a weight run's `boneIndex` indexes into. */
-  rigBones: SpineBone[],
-  /** Their setup world transforms, by name. */
+  /** Every bone's setup world transform, by name. */
   transforms: Map<string, BoneTransform>,
 ): DeformGeometry {
-  const type = (att as { type?: string }).type ?? 'region';
+  const type = att.kind;
   let worldVerticesLength: number;
-  if (type === 'mesh') {
-    worldVerticesLength = (att as SpineMeshAttachment).uvs.length;
-  } else if (type === 'boundingbox' || type === 'clipping' || type === 'path') {
+  if (!isModelVertexAttachment(att)) {
+    throw new CompileError(
+      `${where}: a deform timeline keys the vertices of an attachment, and this one is a "${type}" — ` +
+        'it has no vertex array to deform. Deformable types: mesh, boundingbox, clipping, path.',
+    );
+  }
+  if (att.kind === 'mesh') {
+    worldVerticesLength = att.uvs.length;
+  } else {
     // ⭐ A `path` reaches this line as of issue #696, and it is the SAME line the
     // other two vertex-and-no-triangles types take: the array the parser sizes
     // is `vertexCount * 2`, the two encodings below are the mesh's own, and a
@@ -7697,16 +7849,11 @@ function deformGeometryOf(
     // file twice. `docs/AUTHORING.md` §4.11 states the `constantSpeed: false`
     // reading instead, which is the honest home for it: a fact about the format
     // the author is choosing, not a fault rigc can measure.
-    worldVerticesLength = (att as SpineBoundingBoxAttachment | SpinePathAttachment).vertexCount * 2;
-  } else {
-    throw new CompileError(
-      `${where}: a deform timeline keys the vertices of an attachment, and this one is a "${type}" — ` +
-        'it has no vertex array to deform. Deformable types: mesh, boundingbox, clipping, path.',
-    );
+    worldVerticesLength = att.vertexCount * 2;
   }
-  const vertices = (att as SpineMeshAttachment).vertices ?? [];
-  const weighted = vertices.length !== worldVerticesLength;
-  if (!weighted) {
+  const vertices = att.vertices;
+  const weighted = vertices.weighted;
+  if (!vertices.weighted) {
     return {
       weighted,
       deformLength: worldVerticesLength,
@@ -7714,41 +7861,37 @@ function deformGeometryOf(
       boneCounts: null,
       // An unweighted attachment IS its own space: the array is one `x, y` per
       // vertex in the slot bone's space, which is the space the offsets are in.
-      setup: vertices.slice(),
+      setup: vertices.xy.slice(),
       influenceBones: null,
       setupWhy: null,
-      // Filled in by the caller; `deformGeometryOf` reads the emitted
-      // attachment, and the depth is deliberately not in it.
+      // Filled in by the caller; `deformGeometryOf` reads the attachment's
+      // record, and the depth is deliberately not in it.
       depth: null,
     };
   }
-  // Walk the weight run for the per-vertex influence counts. The run's own shape
-  // is already assured by the attachment builders and by A33/A04; this only
-  // counts, and a malformed run stops rather than producing a plausible number.
+  // Walk the bindings for the per-vertex influence counts. Their shape is
+  // already assured by the attachment builders and by A33/A04; this only counts,
+  // and a vertex with no binding stops rather than producing a plausible number
+  // — at the index its count would hold in the emitted run, as it was worded
+  // when this walked the run.
   const boneCounts: number[] = [];
   const bindSpace: number[] = [];
-  const bones = new Set<number>();
-  /** `boneIndex, bindX, bindY, weight` per influence, in deform-array order. */
-  const influenceRun: number[] = [];
-  for (let i = 0; i < vertices.length; ) {
-    const n = vertices[i++];
-    if (!Number.isInteger(n) || n < 1) {
-      throw new CompileError(`${where}: the attachment's weighted vertex run has a bone count of ${String(n)} at index ${i - 1}`);
+  const bones = new Set<string>();
+  for (let v = 0, at = 0; v < vertices.bindings.length; v++) {
+    const vertex = vertices.bindings[v];
+    const n = vertex.length;
+    if (n < 1) {
+      throw new CompileError(`${where}: the attachment's weighted vertex run has a bone count of ${String(n)} at index ${at}`);
     }
     if (n === 1) {
-      bones.add(vertices[i]);
-      bindSpace.push(vertices[i + 1], vertices[i + 2]);
-    }
-    const from = i;
-    i += n * 4;
-    if (i > vertices.length) {
-      throw new CompileError(`${where}: the attachment's weighted vertex run is truncated at vertex ${boneCounts.length}`);
+      bones.add(vertex[0].bone);
+      bindSpace.push(vertex[0].x, vertex[0].y);
     }
-    for (let k = from; k < i; k++) influenceRun.push(vertices[k]);
     boneCounts.push(n);
+    at += 1 + n * 4;
   }
   // ⚠️ The influence count is the SUM of the per-vertex counts, not a division
-  // of the JSON array's length. The emitted array is `boneCount` followed by
+  // of the emitted JSON array's length. The emitted array is `boneCount` followed by
   // `boneIndex, x, y, weight` per influence — five numbers for a single-bone
   // vertex, not three — so `vertices.length / 3` overstated the deform array by
   // two thirds on a one-bone-per-vertex mesh (`gallery/flex`'s 77-vertex leaf
@@ -7786,17 +7929,15 @@ function deformGeometryOf(
   const setupWorld: number[] = [];
   const influenceBones: BoneTransform[] = [];
   let openWeights: string | null = null;
-  for (let v = 0, k = 0; v < boneCounts.length; v++) {
+  for (let v = 0; v < boneCounts.length; v++) {
     let wx = 0;
     let wy = 0;
     let sum = 0;
-    for (let n = 0; n < boneCounts[v]; n++, k++) {
-      const index = influenceRun[4 * k];
-      const bone = rigBones[index];
-      const m = bone === undefined ? undefined : transforms.get(bone.name);
-      if (!m) throw new CompileError(`${where}: vertex ${v} binds bone index ${index}, which is not in the bone list`);
-      const weight = influenceRun[4 * k + 3];
-      const [x, y] = toWorld(m, influenceRun[4 * k + 1], influenceRun[4 * k + 2]);
+    for (const binding of vertices.bindings[v]) {
+      const m = transforms.get(binding.bone);
+      if (!m) throw new CompileError(`${where}: vertex ${v} binds bone "${binding.bone}", which has no setup transform`);
+      const weight = binding.weight;
+      const [x, y] = toWorld(m, binding.x, binding.y);
       wx += x * weight;
       wy += y * weight;
       sum += weight;
@@ -7891,11 +8032,11 @@ function deformGeometryOf(
 function compileSequenceTrack(
   track: MotionSequenceTrack,
   duration: number,
-  attachment: SpineAttachment,
+  attachment: SkinTableEntry,
   where: string,
-): SpineTimelineKey[] {
-  const type = (attachment as { type?: string }).type ?? 'region';
-  const series = (attachment as { sequence?: SpineSequence }).sequence;
+): ModelKey[] {
+  const series =
+    attachment.kind === 'region' || attachment.kind === 'mesh' || attachment.kind === 'linkedmesh' ? attachment.sequence : undefined;
   if (series === undefined) {
     throw new CompileError(
       `${where}: attachment "${track.attachment}" carries no "sequence" block, so there is no series to step. The ` +
@@ -7904,8 +8045,8 @@ function compileSequenceTrack(
         'attachment a "sequence" in the rig spec, or remove the track.',
     );
   }
-  if (type === 'linkedmesh' && (attachment as SpineLinkedMeshAttachment).timelines !== false) {
-    const source = (attachment as SpineLinkedMeshAttachment).source;
+  if (attachment.kind === 'linkedmesh' && attachment.timelines) {
+    const source = attachment.source;
     throw new CompileError(
       `${where}: attachment "${track.attachment}" is a linked mesh that plays its source's timelines ("timelines" ` +
         `is not false), so its \`timelineAttachment\` is "${source}" (\`SkeletonJson.js:437-448\`) and ` +
@@ -7915,7 +8056,7 @@ function compileSequenceTrack(
     );
   }
   if (track.keys.length === 0) throw new CompileError(`${where}: no keys`);
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const time = keyTime(key.t);
@@ -7930,7 +8071,7 @@ function compileSequenceTrack(
           'frame it does not name. `index` is 0-based.',
       );
     }
-    const entry: SpineTimelineKey = { time };
+    const entry: ModelKey = { time };
     if (key.mode !== undefined) entry.mode = key.mode;
     if (key.index !== undefined) entry.index = key.index;
     if (key.delay !== undefined) entry.delay = f32(key.delay);
@@ -7946,7 +8087,7 @@ function compileDeformTrack(
   duration: number,
   geometry: DeformGeometry,
   generated: CompileResult['deformTransforms'],
-): SpineTimelineKey[] {
+): ModelKey[] {
   const skin = track.skin ?? 'default';
   const where = `animation "${animName}" deform ${skin}/${track.slot}/${track.attachment}`;
   const keys = track.keys;
@@ -7955,7 +8096,7 @@ function compileDeformTrack(
   // skips the timeline, which is assertion A34's silent case.
   if (keys.length === 0) throw new CompileError(`${where}: no keys`);
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     const time = keyTime(key.t);
@@ -8114,7 +8255,7 @@ function compileDeformTrack(
           'The parser copies into a Float32Array, so everything past the end is dropped without a word.',
       );
     }
-    const entry: SpineTimelineKey = { time };
+    const entry: ModelKey = { time };
     // `offset` defaults to 0 in the parser and the editor omits it there, so an
     // authored 0, an authored `fromVertex: 0` and an absent start all emit the
     // same bytes — one meaning, one file.
@@ -8242,15 +8383,15 @@ function deformStart(
  * than to a coordinate, and a raw curve is four numbers whose value axis is 0..1.
  */
 function deformKeyCurve(
-  entry: SpineTimelineKey,
+  entry: ModelKey,
   key: MotionDeformTrack['keys'][number],
   keys: MotionDeformTrack['keys'],
   index: number,
   motion: MotionSpec,
   where: string,
   /** The next key AS EMITTED, or undefined on the last key. */
-  next: SpineTimelineKey | undefined,
-): SpineTimelineKey {
+  next: ModelKey | undefined,
+): ModelKey {
   if (key.ease !== undefined && key.curve !== undefined) {
     throw new CompileError(`${where}: a key carries both a named easing and a raw curve; pick one`);
   }
@@ -8282,8 +8423,8 @@ function deformKeyCurve(
  * are three spellings of one geometry, and the comparison expands both keys onto
  * the same index range before reading them. The runs are already `f32`'d.
  */
-function sameDeform(a: SpineTimelineKey, b: SpineTimelineKey): boolean {
-  const runOf = (k: SpineTimelineKey): { start: number; run: number[] } => ({
+function sameDeform(a: ModelKey, b: ModelKey): boolean {
+  const runOf = (k: ModelKey): { start: number; run: number[] } => ({
     start: typeof k.offset === 'number' ? k.offset : 0,
     run: Array.isArray(k.vertices) ? (k.vertices as number[]) : [],
   });
@@ -8462,7 +8603,7 @@ function resolveMemberTrack(
   track: MotionTrack,
   animName: string,
   targets: readonly string[],
-  bones: readonly SpineBone[],
+  bones: readonly ModelBone[],
   derivations: CompileResult['trackDerivations'],
 ): Map<string, MotionValueTrack> {
   const carriesMap = track.keys.some((key) => isMemberValues(key.v));
@@ -8622,7 +8763,7 @@ function compileTrack(
   shift: number,
   attachments: SlotAttachmentIndex,
   darkSlots: ReadonlySet<string>,
-): SpineTimelineKey[] {
+): ModelKey[] {
   const where = `animation "${animName}" slot "${target}" ${track.property}`;
   // Before any key is shaped, and before the empty-track refusal: a property
   // the emitter has no branch for is the fault, and a track that names one has
@@ -8661,7 +8802,7 @@ function compileTrack(
   }
   if (!track.keys.length) throw new CompileError(`${where}: no keys`);
 
-  const out: SpineTimelineKey[] = [];
+  const out: ModelKey[] = [];
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const next = track.keys[i + 1];
@@ -8724,7 +8865,7 @@ function compileTrack(
           'the posed alpha to that range after interpolating, so a value outside it is one no pose ever holds',
       );
     }
-    const entry: SpineTimelineKey = { time, ...colourOf(key.v) };
+    const entry: ModelKey = { time, ...colourOf(key.v) };
     if (key.ease !== undefined && key.curve !== undefined) {
       throw new CompileError(`${where}: a key carries both a named easing and a raw curve; pick one`);
     }