@rig-c/core 2.77.0 → 2.78.0

package/docs/AUTHORING.md

@@ -12647,7 +12647,7 @@ verdict on those figures.
 | <a id="CE_COMPILE_ALPHA_CLIP_CONFLICT"></a>`CE_COMPILE_ALPHA_CLIP_CONFLICT` | Names authored fields or convex/inverse flags conflicting with generated inside-clipping geometry. Use one authored/generated form.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦: alphaClip conflicts with [⟧<br>⟦vertexCount⟧<br>⟦vertices⟧<br>⟦weights⟧<br>⟦boneIndexing⟧<br>⟦, ⟧<br>⟦], convex=⟧<br>⟦, inverse=⟧<br>⟦; required ordinary inside clipping with generated geometry only. Remove authored geometry/flags.⟧ |
 | <a id="CE_COMPILE_ALPHA_CLIP_DEFORM"></a>`CE_COMPILE_ALPHA_CLIP_DEFORM` | Names animation and source/clip key/frame counts that cannot share the existing projection contract. Give matching explicit supported transform keys in compatible actual frames, with constant world shares where needed, or author the corresponding clip geometry and motion; weighted binding does not copy source deform.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦ alphaClip from "⟧<br>⟦"⟧<br>⟦: animation "⟧<br>⟦" has ⟧<br>⟦ source and ⟧<br>⟦ clip keys; source frame=⟧<br>⟦no vertex geometry⟧<br>⟦clip frame=⟧<br>⟦, constant world influence shares=⟧<br>⟦Required matching explicit affine/depth-yaw/pitch transforms in compatible DeformGeometry frames, ⟧<br>⟦with constant shares for world-space transfer. Fix the named frame/keys or author corresponding clip motion.⟧ |
 
-## 15. Posing in place for a player — the runtime poser (stage 4)
+## 15. Posing in place for a player — the runtime poser (stage 5)
 
 rigc poses a model document twice over, on purpose (issue #1591). The **oracle**
 (`src/core/`) is the reference: each pose is a pure function of the document,
@@ -12673,8 +12673,8 @@ pose.setAnimation('walk');                                   // a refused animat
 pose.step(1 / 60);                                           // or pose.apply(t) at an animation time
 pose.computeVertices();
 // pose.world: 6 numbers per bone (a, b, c, d, worldX, worldY — W_A … W_Y), y up
-// pose.light: 4 per slot; pose.shown: per slot an index into model.attachments, or −1
-// pose.vertices: model.attachments[i].count numbers at model.attachments[i].offset
+// pose.light: 4 per slot; pose.dark: 3 per slot; pose.shown: per slot an index into model.attachments, or −1
+// pose.drawOrder: slot indices in the live frame's draw order; pose.vertices: model.attachments[i].count numbers at model.attachments[i].offset
 ```
 
 Each `model.attachments[i]` also carries readonly `skin` and `placeholder`: the
@@ -12682,11 +12682,11 @@ exact resolved table identity `(skin, model.slots[attachment.slot].name, placeho
 The display `name` may be shared by different placeholders; it is never a table
 key to guess the source from. These load-time strings do not change the pose path.
 
-| | what stage 4 poses |
+| | what stage 5 poses |
 | --- | --- |
 | bones | local and world transforms, all five inherit modes, skin-required bones under the view's skin (an inactive bone is zeros, as the oracle poses it) |
-| timelines | `rotate`, `translate(x/y)`, `scale(x/y)`, `shear(x/y)`; a slot's `attachment`, `rgba`, `rgb` and `alpha`; ik, transform and path timelines; linear, stepped and Bézier keys, each read from a per-pose key cursor |
-| constraints | physics with its exact clock, reset and parameter timelines, and optional constraint-scoped external translate/rotate; value-mapped sliders with bone/slot/deform/physics composition; path constraints across all position, spacing and rotate modes on open or closed, constant-speed or arc-length, weighted or unweighted, deformed curves; one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
+| timelines | `rotate`, `translate(x/y)`, `scale(x/y)`, `shear(x/y)`; a slot's `attachment`, light colour (`rgba`, `rgb`, `alpha`) and dark colour (`rgba2`, `rgb2`); `drawOrder`; ik, transform and path timelines; linear, stepped and Bézier keys, each read from a per-pose key cursor |
+| constraints | physics with its exact clock, reset and parameter timelines, and optional constraint-scoped external translate/rotate; value-mapped sliders with bone/slot/draw-order/deform/physics composition; path constraints across all position, spacing and rotate modes on open or closed, constant-speed or arc-length, weighted or unweighted, deformed curves; one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
 | vertices | regions, meshes, weighted meshes and linked meshes, written into the pose's buffer |
 | deform | weighted and unweighted mesh and path timelines, linear/stepped/Bézier, per-pose key cursors and in-place buffers; linked meshes inherit their source's timelines only with `timelines: true` |
 | skins and events | named/no-skin views with their skin-required bones and constraints; event delivery in key order over `(last, time]`, tail then head across a wrap |
@@ -12761,15 +12761,15 @@ values and blends from the current pose. Ordinary tracks still read only the
 last target for each bone. An earlier unsupported inherit target is refused
 when a slider applies it, even if the track's last target would hide it.
 Absolute/additive bone and
-deform blends and slot switches follow the oracle, including direct scale and
-colour targets at mix one. Slider physics writes last one pass and affect only
+deform blends, draw-order keys and slot switches follow the oracle, including direct scale and
+light/dark colour targets at mix one. Slider physics writes last one pass and affect only
 constraints later in update order. An unsupported timeline in a slider's
 animation refuses the whole model under that timeline's existing feature name,
 so an unselected track cannot hide a construct the slider always applies.
 
 **Everything else is refused at load, by name.** `RuntimeRefusal.missing` lists
 every construct met, each `{ feature, detail, animation }`, and the message
-reads `not posed by the runtime poser (stage 4), N construct(s) missing:
+reads `not posed by the runtime poser (stage 5), N construct(s) missing:
 <feature>: <detail>; …`. A model-level feature refuses the whole model; an
 animation-level one refuses that animation alone (`model.refused`;
 `model.animation(name)` and `setAnimation(name)` throw its refusal) and every
@@ -12784,7 +12784,7 @@ refused: nothing is posed approximately.
 | `clipping`, `null-atlas-region` | the model when shown at setup, else the animation that keys it | a clipping attachment; a region whose atlas rectangle the model states as `null` |
 | `skin-conflict` | as above | a placeholder the skins fill differently |
 | `oracle-absent` | the model | a pose the oracle itself leaves out (`constraintsAbsentWhy`, `pathAnimationsWhy`, `steppedPreviousPassWhy`, `sliderDeformsWalkedPathWhy`) |
-| `inherit-timeline`, `sequence-timeline`, `draw-order-timeline`, `dark-colour-timeline` | the animation | a timeline of that kind (`dark-colour` is `rgba2` / `rgb2`) |
+| `inherit-timeline`, `sequence-timeline` | the animation | a timeline of that kind |
 
 A call it cannot answer throws `RuntimeInputError`, naming the call:
 `apply: no animation is set (setAnimation first)`, `animation "x" is not one of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.77.0",
+  "version": "2.78.0",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/runtime/curves.ts

@@ -46,8 +46,13 @@ export interface RuntimeCurve {
   readonly polylines: Float64Array;
 }
 
-/** A timeline's keys compiled; `channels` is how many values each key carries (0 for an attachment timeline). */
-export function compileCurve(keys: readonly CoreKey[], channels: number): RuntimeCurve {
+/** A timeline's keys compiled; `channels` is how many values each key carries (0 for an attachment or draw-order timeline). */
+export function compileCurve(keys: readonly { readonly time: number }[], channels: 0): RuntimeCurve;
+export function compileCurve(keys: readonly CoreKey[], channels: number): RuntimeCurve;
+export function compileCurve(
+  keys: readonly { readonly time: number; readonly values?: readonly number[]; readonly stated?: CoreKey['stated']; readonly curve?: CoreKey['curve'] }[],
+  channels: number,
+): RuntimeCurve {
   const n = keys.length;
   const times = new Float64Array(n);
   const values = new Float64Array(n * channels);
@@ -56,20 +61,24 @@ export function compileCurve(keys: readonly CoreKey[], channels: number): Runtim
   for (let i = 0; i < n; i++) {
     const a = keys[i];
     times[i] = a.time;
-    for (let c = 0; c < channels; c++) values[i * channels + c] = a.values[c];
-    const curve = a.curve;
+    const av = a.values;
+    if (av !== undefined) for (let c = 0; c < channels; c++) values[i * channels + c] = av[c];
+    const curve = a.curve ?? 'stepped';
     kinds[i] = curve === 'linear' ? CURVE_LINEAR : curve === 'stepped' ? CURVE_STEPPED : CURVE_BEZIER;
     if (typeof curve === 'string' || i + 1 >= n) continue;
     const b = keys[i + 1];
+    const aStated = a.stated!;
+    const bStated = b.stated!;
+    const bValues = b.values!;
     for (let c = 0; c < channels; c++) {
       // The oracle's polyline (`channelAt`): the segment's float32 ends around the recurrence over the numbers as the document states them.
-      const inner = bezierPolyline(a.stated.time, a.stated.values[c], curve[c * 4], curve[c * 4 + 1], curve[c * 4 + 2], curve[c * 4 + 3], b.stated.time, b.stated.values[c]);
+      const inner = bezierPolyline(aStated.time, aStated.values[c], curve[c * 4], curve[c * 4 + 1], curve[c * 4 + 2], curve[c * 4 + 3], bStated.time, bStated.values[c]);
       const o = (i * channels + c) * POLYLINE;
       polylines[o] = a.time;
-      polylines[o + 1] = a.values[c];
+      polylines[o + 1] = av![c];
       for (let q = 0; q < inner.length; q++) polylines[o + 2 + q] = inner[q];
       polylines[o + POLYLINE - 2] = b.time;
-      polylines[o + POLYLINE - 1] = b.values[c];
+      polylines[o + POLYLINE - 1] = bValues[c];
     }
   }
   return { keys: n, channels, times, values, kinds, polylines };

package/src/runtime/index.ts

@@ -21,11 +21,12 @@
  * corpus through both at the oracle's samples and compares full doubles at
  * tolerance 0 (*The runtime poser* there). The oracle is not changed for it.
  *
- * ## Stage 4: what it poses, and what it refuses
+ * ## Stage 5: what it poses, and what it refuses
  *
  * Bones and their five inherit modes; the rotate, translate, scale and shear
- * timelines; a slot's attachment and colour (`rgba`, `rgb`, `alpha`)
- * timelines; weighted/unweighted deform timelines; region, mesh, weighted mesh and linked mesh vertices; one- and
+ * timelines; a slot's attachment, light colour (`rgba`, `rgb`, `alpha`) and
+ * dark colour (`rgba2`, `rgb2`) timelines; draw-order timelines (including
+ * slider draw-order application); weighted/unweighted deform timelines; region, mesh, weighted mesh and linked mesh vertices; one- and
  * two-bone ik, world-space absolute transforms, path constraints, physics (with optional movement scope) and value-mapped sliders with their
  * timelines; skin-required bones and constraints under the view's skin. One
  * animation at full weight from the setup pose, at a time or stepped as a
@@ -43,7 +44,7 @@
  * const pose = new RuntimePose(model);
  * pose.setAnimation('walk');
  * pose.step(1 / 60);       // or pose.apply(t)
- * pose.computeVertices();  // pose.world, pose.light, pose.shown, pose.vertices
+ * pose.computeVertices();  // pose.world, pose.light, pose.dark, pose.shown, pose.drawOrder, pose.vertices
  * ```
  *
  * This module is the `rig-c/runtime` entry (`exports` in package.json), which

package/src/runtime/model.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's load-time half (issue #1591, stage 4): a skin view of
+ * The runtime poser's load-time half (issue #1591, stage 5): a skin view of
  * the compiled model (`readModel`, then `underSkin` / `underNoSkin` — the
  * oracle's reader and its views, read and never written) compiled once into
  * index-resolved bones and slots, a constraint plan, compiled timelines and
@@ -21,12 +21,11 @@
  *   differently, or a block the oracle itself leaves out;
  * - **refuses an animation** (`RuntimeModel.refused`; `animation(name)`
  *   throws the same `RuntimeRefusal`) when the construct is the animation's
- *   — an `inherit` timeline, a sequence timeline, a draw-order
- *   timeline, a dark-colour (`rgba2`, `rgb2`) timeline, or an
+ *   — an `inherit` timeline, a sequence timeline, or an
  *   attachment key showing a clipping attachment or a region with no atlas
  *   rectangle. Every other animation of the model is posed.
  *
- * `RUNTIME_FEATURES` is the closed list of what can be named. Stage 4 adds path constraints and scoped physics movement (`physicsTranslate`/`physicsRotate` with an optional constraint scope) on top of Stage 3's indexed physics and value-mapped sliders. Mesh and path deforms, named/no-skin views
+ * `RUNTIME_FEATURES` is the closed list of what can be named. Stage 5 adds draw-order timelines (including slider draw-order application) and dark-colour (`rgba2`, `rgb2`) timelines on top of Stage 4's path constraints and scoped physics movement. Mesh and path deforms, named/no-skin views
  * and immutable event deliveries remain covered. `ignore: ['events']` remains an explicit diagnostic opt-out; it is
  * never the default. A merged view with conflicting attachments still refuses
  * by name, as the oracle itself cannot resolve that view without file order.
@@ -55,7 +54,7 @@ import type { CoreSliderRecord } from '../core/constraints_slider.ts';
 import { compileCurve, compileDeformCurve, type RuntimeCurve } from './curves.ts';
 
 /** The stage of issue #1591 this poser implements. */
-export const RUNTIME_STAGE = 4;
+export const RUNTIME_STAGE = 5;
 
 /** Every construct the runtime poser can refuse, by the name its refusals carry. */
 export const RUNTIME_FEATURES = [
@@ -69,8 +68,6 @@ export const RUNTIME_FEATURES = [
   'oracle-absent',
   'inherit-timeline',
   'sequence-timeline',
-  'draw-order-timeline',
-  'dark-colour-timeline',
 ] as const;
 export type RuntimeFeature = (typeof RUNTIME_FEATURES)[number];
 
@@ -131,6 +128,8 @@ export interface RuntimePlant {
   readonly deformAfterWeights?: boolean;
   readonly omitPath?: boolean;
   readonly ignorePhysicsScope?: boolean;
+  readonly omitDrawOrder?: boolean;
+  readonly omitDarkColour?: boolean;
 }
 
 // A bone's local values, seven per bone.
@@ -354,7 +353,7 @@ export interface RuntimeBoneTimeline {
   readonly multiply: Uint8Array;
 }
 
-/** A slot timeline: an attachment timeline (each key's attachment index, −1 nothing) or a colour timeline (each channel's index into the light colour). */
+/** A slot timeline: an attachment timeline (each key's attachment index, −1 nothing) or a colour timeline (each channel's index into the light or dark colour). */
 export interface RuntimeSlotTimeline {
   readonly slot: number;
   readonly curve: RuntimeCurve;
@@ -391,6 +390,13 @@ export interface RuntimeDeformTimeline {
   readonly count: number;
 }
 
+/** An animation's draw-order timeline: each key's slot-index permutation of `slots.length` (`orderOf` in `src/core/draw_order.ts`), expanded once at load. */
+export interface RuntimeDrawOrderTimeline {
+  readonly curve: RuntimeCurve;
+  readonly cursor: number;
+  readonly orders: Int32Array;
+}
+
 /** One covered animation, compiled. */
 export interface RuntimeAnimation {
   readonly name: string;
@@ -403,6 +409,7 @@ export interface RuntimeAnimation {
   readonly sliders: ReadonlyArray<RuntimeSliderTimeline | null>;
   readonly paths: ReadonlyArray<RuntimePathTimeline | null>;
   readonly slots: readonly RuntimeSlotTimeline[];
+  readonly drawOrder: RuntimeDrawOrderTimeline | null;
   /** Per constraint of the plan, its timeline in this animation or `null`. */
   readonly constraints: ReadonlyArray<RuntimeConstraintTimeline | null>;
   /** How many key cursors a pose keeps for it. */
@@ -421,6 +428,8 @@ export interface RuntimeModel {
   readonly sliderAsTrack: boolean;
   readonly omitPath: boolean;
   readonly ignorePhysicsScope: boolean;
+  readonly omitDrawOrder: boolean;
+  readonly omitDarkColour: boolean;
   readonly hasPath: boolean;
   readonly maxPathSpaces: number;
   readonly maxPathVertices: number;
@@ -472,8 +481,8 @@ const BONE_KINDS: Record<string, ReadonlyArray<readonly [number, 0 | 1]>> = {
   sheary: [[L_SHEAR_Y, 0]],
 };
 
-/** The light colour's channels each colour timeline sets, in its curve's channel order. */
-const COLOUR_CHANNELS: Record<string, readonly number[]> = { rgba: [0, 1, 2, 3], rgb: [0, 1, 2], alpha: [3] };
+/** The light (`0 .. 3`) and dark (`4 .. 6`) colour channels each colour timeline sets, in its curve's channel order (`COLOUR_CHANNELS` in `src/core/animation.ts` and `src/core/constraints_slider.ts`). */
+const COLOUR_CHANNELS: Record<string, readonly number[]> = { rgba: [0, 1, 2, 3], rgb: [0, 1, 2], alpha: [3], rgba2: [0, 1, 2, 3, 4, 5, 6], rgb2: [0, 1, 2, 4, 5, 6] };
 
 /** Where refusals are gathered while a model compiles. */
 class Refusals {
@@ -721,6 +730,8 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
     deformAfterWeights: plant.deformAfterWeights === true,
     omitPath: plant.omitPath === true,
     ignorePhysicsScope: plant.ignorePhysicsScope === true,
+    omitDrawOrder: plant.omitDrawOrder === true,
+    omitDarkColour: plant.omitDarkColour === true,
     hasPath,
     maxPathSpaces,
     maxPathVertices,
@@ -899,7 +910,28 @@ function compileAnimation(
   const sequence = tl.attachments.filter((a) => a.sequence !== null);
 
   if (sequence.length > 0) refusals.note('sequence-timeline', `${sequence.length} sequence timeline(s): ${sequence.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(', ')}${sequence.length > 3 ? ', …' : ''}`, name);
-  if (tl.drawOrder.length > 0) refusals.note('draw-order-timeline', `${tl.drawOrder.length} draw-order key(s)`, name);
+
+  let drawOrder: RuntimeDrawOrderTimeline | null = null;
+  if (tl.drawOrder.length > 0) {
+    const ns = slots.length;
+    const orders = new Int32Array(tl.drawOrder.length * ns).fill(-1);
+    const moved = new Uint8Array(ns);
+    for (let i = 0; i < tl.drawOrder.length; i++) {
+      const base = i * ns;
+      moved.fill(0);
+      for (const m of tl.drawOrder[i].moves) {
+        orders[base + m.slot + m.offset] = m.slot;
+        moved[m.slot] = 1;
+      }
+      for (let s = 0, d = 0; s < ns; s++) {
+        if (moved[s] !== 0) continue;
+        while (orders[base + d] !== -1) d++;
+        orders[base + d] = s;
+        d++;
+      }
+    }
+    drawOrder = { curve: compileCurve(tl.drawOrder, 0), cursor: cursors++, orders };
+  }
 
   const lastBy = <T extends { name: string }>(targets: readonly T[]): Map<string, T> => new Map(targets.map((t) => [t.name, t]));
   const bones: RuntimeBoneTimeline[] = [];
@@ -941,8 +973,6 @@ function compileAnimation(
       if (t.kind === 'attachment') {
         const ids = Int32Array.from(t.keys.map((k) => resolve(si, k.name ?? null)));
         slotTimelines.push({ slot: si, curve: compileCurve(t.keys, 0), cursor: cursors++, attachments: ids, channels: null });
-      } else if (t.kind === 'rgba2' || t.kind === 'rgb2') {
-        refusals.note('dark-colour-timeline', `slot "${target.name}" keys an ${t.kind} timeline`, name);
       } else {
         const channels = COLOUR_CHANNELS[t.kind];
         slotTimelines.push({ slot: si, curve: compileCurve(t.keys, channels.length), cursor: cursors++, attachments: null, channels: Int32Array.from(channels) });
@@ -991,5 +1021,5 @@ function compileAnimation(
     const arrays = keys.map(k => heldArray(g.vertices, k));
     return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
   });
-  return { name, duration: tl.duration, physics, sliders, paths, deforms, bones, sliderBones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map(key => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
+  return { name, duration: tl.duration, physics, sliders, paths, deforms, bones, sliderBones, slots: slotTimelines, drawOrder, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map(key => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
 }

package/src/runtime/pose.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's per-instance half (issue #1591, stage 4): one
+ * The runtime poser's per-instance half (issue #1591, stage 5): one
  * `RuntimePose` per skeleton on screen, every buffer allocated when it is
  * made and overwritten in place on every pose, so that posing a frame
  * allocates nothing.
@@ -9,14 +9,15 @@
  * The oracle's sample, as `src/core/animation.ts` poses it (`poseAnimations`):
  * every pose is posed from the setup pose — the bones' setup local values,
  * then the animation's bone timelines at `t` at full weight, then the world
- * transforms parents first, then each slot's colour, attachment and own deform
- * timelines, then the ik, transform, path, physics and slider constraints in the
- * document's order with their timelines' values at `t`, each followed by the
- * bones below what it moved posed again, then the sliders' slot and deform
- * timelines; then, when asked, every shown attachment's world vertices. Nothing
- * of one unstepped pose survives but key cursors. A stepped pose also keeps
- * its physics clock, offsets, velocities and lags; sliders select values
- * within this pose rather than advancing an independent track.
+ * transforms parents first, then the draw order and each slot's light and dark
+ * colour, attachment and own deform timelines, then the ik, transform, path,
+ * physics and slider constraints in the document's order with their timelines'
+ * values at `t`, each followed by the bones below what it moved posed again,
+ * then the sliders' draw-order, slot and deform timelines; then, when asked,
+ * every shown attachment's world vertices. Nothing of one unstepped pose
+ * survives but key cursors. A stepped pose also keeps its physics clock,
+ * offsets, velocities and lags; sliders select values within this pose rather
+ * than advancing an independent track.
  *
  * ## The arithmetic is the oracle's
  *
@@ -118,7 +119,7 @@ const clamp01 = (v: number): number => (v < 0 ? 0 : v > 1 ? 1 : v);
 export interface RuntimePoseOptions { readonly clock?: (dt: number) => number }
 export type RuntimePhysicsPhase = 'none' | 'reset' | 'update';
 
-/** One skeleton's pose, every value in place. Read `world`, `light`, `shown` and `vertices` after a pose. */
+/** One skeleton's pose, every value in place. Read `world`, `light`, `dark`, `shown`, `drawOrder` and `vertices` after a pose. */
 export class RuntimePose {
   readonly model: RuntimeModel;
   /** Every bone's local values, `LOCALS` per bone (`L_*`). */
@@ -127,8 +128,12 @@ export class RuntimePose {
   readonly world: Float64Array;
   /** Every slot's light colour, four per slot. */
   readonly light: Float64Array;
+  /** Every slot's dark colour, three per slot (`r2`, `g2`, `b2`), or zeros when `model.slots[s].dark === null`. */
+  readonly dark: Float64Array;
   /** What every slot shows: an index into `model.attachments`, or −1 for nothing. */
   readonly shown: Int32Array;
+  /** The slot indices in the live frame's draw order (`0 .. model.slots.length - 1`), updated in place. */
+  readonly drawOrder: Int32Array;
   /** Every attachment's world vertices at its `offset`, written by `computeVertices` for the attachments shown. */
   readonly vertices: Float64Array;
   /** Held/interpolated deform values, one pair per binding when weighted. */
@@ -199,7 +204,10 @@ export class RuntimePose {
     this.locals = new Float64Array(nb * LOCALS);
     this.world = new Float64Array(nb * WORLDS);
     this.light = new Float64Array(ns * 4);
+    this.dark = new Float64Array(ns * 3);
     this.shown = new Int32Array(ns);
+    this.drawOrder = new Int32Array(ns);
+    for (let s = 0; s < ns; s++) this.drawOrder[s] = s;
     this.vertices = new Float64Array(model.vertexCount);
     this.deform = new Float64Array(model.deformCount);
     this.deformed = new Uint8Array(model.attachments.length);
@@ -1179,6 +1187,13 @@ export class RuntimePose {
       const k = index, c = cs[k];
       if (c.kind !== 'slider' || !c.applied || this.sliderMix[k] === 0) return;
       const a = c.animation, t = this.sliderAt[k], alpha = this.sliderMix[k];
+      if (!this.model.omitDrawOrder && a.drawOrder !== null) {
+        const di = keyAt(a.drawOrder.curve, this.cursors, a.drawOrder.cursor, t);
+        if (di >= 0) {
+          const ns = this.drawOrder.length, orders = a.drawOrder.orders, base = di * ns;
+          for (let s = 0; s < ns; s++) this.drawOrder[s] = orders[base + s];
+        }
+      }
       for (let q = 0; q < a.slots.length; q++) {
         const tl = a.slots[q], i = keyAt(tl.curve, this.cursors, tl.cursor, t);
         if (i < 0) continue;
@@ -1189,9 +1204,17 @@ export class RuntimePose {
         }
         else {
           const channels = tl.channels!;
+          const slot = this.model.slots[tl.slot];
+          const o = tl.slot * 4, d = tl.slot * 3;
           for (let f = 0; f < channels.length; f++) {
-            const n = tl.slot * 4 + channels[f], v = channelValue(tl.curve, i, f, t);
-            this.light[n] = clamp01(alpha === 1 ? v : this.light[n] + (v - this.light[n]) * alpha);
+            const at = channels[f], v = channelValue(tl.curve, i, f, t);
+            if (at < 4) {
+              const n = o + at;
+              this.light[n] = clamp01(alpha === 1 ? v : this.light[n] + (v - this.light[n]) * alpha);
+            } else if (slot.dark !== null && !this.model.omitDarkColour) {
+              const n = d + (at - 4);
+              this.dark[n] = clamp01(alpha === 1 ? v : this.dark[n] + (v - this.dark[n]) * alpha);
+            }
           }
         }
       }
@@ -1715,16 +1738,32 @@ export class RuntimePose {
   private slotValues(anim: RuntimeAnimation | null, t: number): void {
     const slots = this.model.slots;
     const light = this.light;
+    const dark = this.dark;
     for (let s = 0; s < slots.length; s++) {
       const slot = slots[s];
       this.shown[s] = slot.setupAttachment;
+      this.drawOrder[s] = s;
       const o = s * 4;
       light[o] = slot.light[0];
       light[o + 1] = slot.light[1];
       light[o + 2] = slot.light[2];
       light[o + 3] = slot.light[3];
+      const setupDark = slot.dark;
+      if (setupDark !== null) {
+        const d = s * 3;
+        dark[d] = setupDark[0];
+        dark[d + 1] = setupDark[1];
+        dark[d + 2] = setupDark[2];
+      }
     }
     if (anim === null) return;
+    if (!this.model.omitDrawOrder && anim.drawOrder !== null) {
+      const di = keyAt(anim.drawOrder.curve, this.cursors, anim.drawOrder.cursor, t);
+      if (di >= 0) {
+        const ns = slots.length, orders = anim.drawOrder.orders, base = di * ns;
+        for (let s = 0; s < ns; s++) this.drawOrder[s] = orders[base + s];
+      }
+    }
     const timelines = anim.slots;
     for (let k = 0; k < timelines.length; k++) {
       const tl = timelines[k];
@@ -1735,11 +1774,18 @@ export class RuntimePose {
         continue;
       }
       const channels = tl.channels as Int32Array;
-      const setup = slots[tl.slot].light;
+      const slot = slots[tl.slot];
+      const setup = slot.light;
+      const setupDark = slot.dark;
       const o = tl.slot * 4;
+      const d = tl.slot * 3;
       for (let c = 0; c < channels.length; c++) {
         const at = channels[c];
-        light[o + at] = i < 0 ? setup[at] : clamp01(channelValue(tl.curve, i, c, t));
+        if (at < 4) {
+          light[o + at] = i < 0 ? setup[at] : clamp01(channelValue(tl.curve, i, c, t));
+        } else if (setupDark !== null && !this.model.omitDarkColour) {
+          dark[d + (at - 4)] = i < 0 ? setupDark[at - 4] : clamp01(channelValue(tl.curve, i, c, t));
+        }
       }
     }
   }