rig-play 1.4.0 → 1.6.0

package/dist/index.js

@@ -377,7 +377,7 @@ function timelineIdentity(slot, shown) {
   return `${shown.skin}/${slot}/${shown.placeholder}`;
 }
 const nameOf = (a) => `${a.skin}/${a.slot}/${a.attachment}`;
-function attachmentStates(doc, resolve, placeholders, sample, sliders, plant = {}) {
+function attachmentStates(doc, resolve, placeholders, sample, sliders, plant = {}, mixed) {
   const evalDeform = plant.deform ?? deformAt;
   const blendOf = plant.deformBlend ?? blendDeform;
   const evalFrame = plant.sequence ?? sequenceFrameAt;
@@ -388,9 +388,10 @@ function attachmentStates(doc, resolve, placeholders, sample, sliders, plant = {
   for (const slot of doc.slots) {
     const live = gate(doc, slot, active);
     let placeholder = placeholders.get(slot.name) ?? null;
-    let deform = null;
+    const base = live ? mixed?.get(slot.name) : void 0;
+    let deform = base?.deform ?? null;
     let frame2 = null;
-    const seen = [];
+    const seen = base === void 0 ? [] : [...base.seen];
     const state = () => {
       if (placeholder === null) return null;
       const s = resolve(doc, { ...slot, setup: placeholder });
@@ -2450,7 +2451,7 @@ function applySliderPhysics(r, at, alpha, target) {
     }
   }
 }
-const clamp01$1 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const clamp01$2 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 const COLOUR_CHANNELS = { 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] };
 function applySliderSlots(slot, pose, applications) {
   for (const app of applications) {
@@ -2465,8 +2466,8 @@ function applySliderSlots(slot, pose, applications) {
         const v = valuesAt$1(tl.keys, app.at);
         if (v === null) continue;
         COLOUR_CHANNELS[tl.kind].forEach((at, i) => {
-          if (at < 4) pose.light[at] = app.alpha === 1 ? clamp01$1(v[i]) : clamp01$1(pose.light[at] + (v[i] - pose.light[at]) * app.alpha);
-          else if (pose.dark !== null) pose.dark[at - 4] = app.alpha === 1 ? clamp01$1(v[i]) : clamp01$1(pose.dark[at - 4] + (v[i] - pose.dark[at - 4]) * app.alpha);
+          if (at < 4) pose.light[at] = app.alpha === 1 ? clamp01$2(v[i]) : clamp01$2(pose.light[at] + (v[i] - pose.light[at]) * app.alpha);
+          else if (pose.dark !== null) pose.dark[at - 4] = app.alpha === 1 ? clamp01$2(v[i]) : clamp01$2(pose.dark[at - 4] + (v[i] - pose.dark[at - 4]) * app.alpha);
         });
       }
     }
@@ -3922,23 +3923,15 @@ function adjustLocals(doc, bones, adjust) {
     }
   });
 }
-const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const clamp01$1 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function posedSlots(doc, timelines, t, plant = {}, sliders = [], placeholders) {
-  const resolve = plant.shown ?? shownAttachment;
   const colour = plant.colour ?? readColour;
-  const blend = plant.blend ?? readBlend;
-  const round = plant.round ?? gridRound;
   const byName = new Map(timelines.slots.map((s) => [s.name, s]));
-  const rows = [];
-  const conflicts = [];
-  const active = activeBones(doc);
-  const gate = plant.slotTimelines ?? slotTimelinesApply;
-  for (const slot of doc.slots) {
+  return slotRowsFrom(doc, plant, sliders, placeholders, (slot, live) => {
     let placeholder = slot.setup;
     const light = slot.color === void 0 ? [1, 1, 1, 1] : colour(slot.color);
     const setupDark = slot.dark === void 0 ? null : readColour(slot.dark);
     const dark = setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]];
-    const live = gate(doc, slot, active);
     for (const tl of live ? byName.get(slot.name)?.timelines ?? [] : []) {
       if (tl.kind === "attachment") {
         const key = keyAt(tl.keys, t, plant);
@@ -3950,10 +3943,26 @@ function posedSlots(doc, timelines, t, plant = {}, sliders = [], placeholders) {
       const channels = SLOT_COLOUR_TIMELINES[tl.kind].channels;
       channels.forEach((name, i) => {
         const at = { r: 0, g: 1, b: 2, a: 3, r2: 4, g2: 5, b2: 6 }[name];
-        if (at < 4) light[at] = v === null ? setupLight[at] : clamp01(v[i]);
-        else if (dark !== null && setupDark !== null) dark[at - 4] = v === null ? setupDark[at - 4] : clamp01(v[i]);
+        if (at < 4) light[at] = v === null ? setupLight[at] : clamp01$1(v[i]);
+        else if (dark !== null && setupDark !== null) dark[at - 4] = v === null ? setupDark[at - 4] : clamp01$1(v[i]);
       });
     }
+    return { placeholder, light, dark };
+  });
+}
+function slotRowsFrom(doc, plant, sliders, placeholders, baseOf) {
+  const resolve = plant.shown ?? shownAttachment;
+  const blend = plant.blend ?? readBlend;
+  const round = plant.round ?? gridRound;
+  const rows = [];
+  const conflicts = [];
+  const active = activeBones(doc);
+  const gate = plant.slotTimelines ?? slotTimelinesApply;
+  for (const slot of doc.slots) {
+    const live = gate(doc, slot, active);
+    const base = baseOf(slot, live);
+    let placeholder = base.placeholder;
+    const { light, dark } = base;
     placeholders?.set(slot.name, placeholder);
     const pose = { placeholder, light, dark };
     if (live) applySliderSlots(slot.name, pose, sliders);
@@ -3996,14 +4005,12 @@ function stepRows(posed) {
   return posed.rows;
 }
 function posedBoneStep(doc, timelines, t, plant, constraints, sliders, step) {
-  const active = activeBones(doc);
   const bones = posedBones(doc, timelines, t, plant);
+  if (constraints !== void 0 && step !== void 0) return steppedLocals(doc, bones, plant, () => pathDeformed(doc, posedRecords(constraintRecords(doc), constraints, t), timelines, t, plant), constraints.physicsKeyed ?? [], t, sliders, step);
+  const active = activeBones(doc);
   if (step?.adjust !== void 0) adjustLocals(doc, bones, step.adjust);
   let world = (plant.evaluate ?? worldTransforms)(bones, active);
-  if (constraints !== void 0 && step !== void 0) {
-    const records = stepPhysicsRecords(pathDeformed(doc, posedRecords(constraintRecords(doc), constraints, t), timelines, t, plant), constraints.physicsKeyed ?? [], t, active, step.ctx, step.before);
-    world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(records) : records, null, sliders, step.ctx, void 0, solverRules(plant.solver));
-  } else if (constraints !== void 0) {
+  if (constraints !== void 0) {
     const setupRecords = constraintRecords(doc);
     const records = pathDeformed(doc, posedRecords(setupRecords, constraints, t), timelines, t, plant);
     const previous = setupRecords.some((r) => r.kind === "path") ? applyConstraints(doc.bones, (plant.evaluate ?? worldTransforms)(doc.bones, active), active, plant.constraints ? plant.constraints(setupRecords) : setupRecords, null, void 0, void 0, void 0, solverRules(plant.solver)) : null;
@@ -4012,6 +4019,20 @@ function posedBoneStep(doc, timelines, t, plant, constraints, sliders, step) {
   for (const b of bones) if (world.get(b.name) === void 0) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
   return { bones, world, active, round: plant.round ?? gridRound };
 }
+function steppedLocals(doc, bones, plant, records, physicsKeyed, t, sliders, step) {
+  const active = activeBones(doc);
+  if (step.adjust !== void 0) adjustLocals(doc, bones, step.adjust);
+  let world = (plant.evaluate ?? worldTransforms)(bones, active);
+  const stepped = stepPhysicsRecords(records(), physicsKeyed, t, active, step.ctx, step.before);
+  world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(stepped) : stepped, null, sliders, step.ctx, void 0, solverRules(plant.solver));
+  for (const b of bones) if (world.get(b.name) === void 0) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
+  return { bones, world, active, round: plant.round ?? gridRound };
+}
+function steppedLocalsWorld(doc, bones, plant, sliders, step, rows) {
+  const posed = steppedLocals(doc, bones, plant, () => constraintRecords(doc), [], 0, sliders, step);
+  stepRows(posed);
+  return posed.world;
+}
 function pathDeformed(doc, records, timelines, t, plant) {
   if (timelines.attachments.every((a) => a.deform === null)) return records;
   return records.map((r) => {
@@ -4929,6 +4950,14 @@ function openWalk(doc, anim, plant, reset, mode, shape, adjust) {
   const ctx = freshStepContext(plant.physicsStep);
   if (mode.loop && mode.wrapResets !== false) ctx.loop = true;
   const track = { doc, anim, duration: anim.timelines.duration, mode, plant, raw: { ...plant, ...roundPlant(mode) }, resolve: plant.shown ?? shownAttachment, shape, ctx, adjust, trackTime: 0, last: -1 };
+  if (reset === "setup") {
+    const setup = poseSetup(doc, { ...plant, ...roundPlant(mode) }, ctx);
+    const absent = setup.absent.filter(([block]) => block !== "setup.clipped");
+    if (absent.length > 0) throw new CoreInputError(`the raw walk's reset pose leaves ${absent.map(([b, w]) => `${b} out (${w})`).join("; ")}`);
+    if (setup.world === null || setup.shown === null || setup.setup.slots === null || setup.setup.drawOrder === null) throw new CoreInputError("the raw walk's reset pose was not posed");
+    ctx.phase = "update";
+    return { track, first: shape.setup(doc, setup.world, setup.setup.slots, setup.setup.drawOrder, setup.shown, plant, mode) };
+  }
   return { track, first: stepWalk(track, 0, true) };
 }
 function stepWalk(track, dt, first = false) {
@@ -4939,26 +4968,56 @@ function stepWalk(track, dt, first = false) {
   const t = mode.loop ? (mode.time ?? loopedTime)(trackTime, duration, trackTime - dt) : trackTime < duration ? trackTime : duration;
   const before = ctx.time;
   ctx.time += mode.clock === void 0 ? dt : mode.clock(dt, t - (first ? 0 : Math.max(last, 0)));
+  const fire = plant.events ?? eventsFired;
+  const keys = anim.timelines.events;
+  const pose = poseStepFrom(doc, plant, resolve, shape, mode, ctx, first, trackTime, t, {
+    world: (sliders) => shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust }),
+    slots: (sliders, placeholders) => posedSlots(doc, anim.timelines, t, raw, sliders, placeholders),
+    drawOrder: anim.timelines.drawOrder,
+    at: t,
+    sample: { timelines: anim.timelines, t },
+    events: () => mode.loop && mode.live !== true ? [] : mode.loop ? fire(keys, last, t, rawNumber, t < last) : fire(keys, last, t, rawNumber)
+  });
+  track.last = t;
+  return pose;
+}
+function poseStepFrom(doc, plant, resolve, shape, mode, ctx, first, trackTime, animationTime, posers) {
   const sliders = [];
-  const world = shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust });
+  const world = posers.world(sliders);
   if (first) ctx.phase = "update";
   const placeholders = /* @__PURE__ */ new Map();
-  const slots = posedSlots(doc, anim.timelines, t, raw, sliders, placeholders);
+  const slots = posers.slots(sliders, placeholders);
   if (slots.conflicts.length > 0) throw new CoreInputError(`the raw walk leaves the slots out: ${slots.conflicts.join("; ")}`);
   const evalOrder = plant.drawOrder ?? drawOrderAt;
-  let order = evalOrder(doc.slots.length, anim.timelines.drawOrder, t) ?? doc.slots.map((_s, k) => k);
+  let order = evalOrder(doc.slots.length, posers.drawOrder, posers.at) ?? doc.slots.map((_s, k) => k);
   for (const app of sliders) order = evalOrder(doc.slots.length, app.timelines.drawOrder, app.at) ?? order;
   const drawOrder = order.map((k) => doc.slots[k].name);
-  const states = attachmentStates(doc, resolve, placeholders, { timelines: anim.timelines, t }, sliders, plant);
+  const states = attachmentStates(doc, resolve, placeholders, posers.sample, sliders, plant, posers.mixed);
   if (states.why.length > 0) throw new CoreInputError(`the raw walk leaves the attachments out: ${states.why.join("; ")}`);
   const rank = new Map(drawOrder.map((n, r) => [n, r]));
   const shown = [...states.shown].sort((a, b) => (rank.get(a.slot) ?? 0) - (rank.get(b.slot) ?? 0));
-  const fire = plant.events ?? eventsFired;
-  const keys = anim.timelines.events;
-  const events = () => mode.loop && mode.live !== true ? [] : (mode.loop ? fire(keys, last, t, rawNumber, t < last) : fire(keys, last, t, rawNumber)).map((e) => [e[0], finite(e[1], "event time"), e[2], finite(e[3], "event float"), e[4]]);
-  const pose = shape.step(doc, { trackTime, animationTime: t, world, slots: slots.rows, drawOrder, shown, events }, plant, mode);
-  track.last = t;
-  return pose;
+  const events = () => posers.events().map((e) => [e[0], finite(e[1], "event time"), e[2], finite(e[3], "event float"), e[4]]);
+  return shape.step(doc, { trackTime, animationTime, world, slots: slots.rows, drawOrder, shown, events }, plant, mode);
+}
+function openRawTracksPath(doc, plant) {
+  const why = constraintsAbsentWhy(doc) ?? pathAnimationsWhy(doc) ?? steppedPreviousPassWhy(doc);
+  if (why !== null) throw new CoreInputError(`the raw walk leaves the bones out: ${why}`);
+  const ctx = freshStepContext(plant.physicsStep);
+  const raw = { ...plant, ...roundPlant(RAW_MODE) };
+  const resolve = plant.shown ?? shownAttachment;
+  return {
+    ctx,
+    raw,
+    setupPose: () => {
+      const setup = poseSetup(doc, raw, ctx);
+      const absent = setup.absent.filter(([block]) => block !== "setup.clipped");
+      if (absent.length > 0) throw new CoreInputError(`the raw walk's reset pose leaves ${absent.map(([b, w]) => `${b} out (${w})`).join("; ")}`);
+      if (setup.world === null || setup.shown === null || setup.setup.slots === null || setup.setup.drawOrder === null) throw new CoreInputError("the raw walk's reset pose was not posed");
+      ctx.phase = "update";
+      return RAW_SHAPE.setup(doc, setup.world, setup.setup.slots, setup.setup.drawOrder, setup.shown, plant, RAW_MODE);
+    },
+    step: (first, trackTime, animationTime, posers) => poseStepFrom(doc, plant, resolve, RAW_SHAPE, RAW_MODE, ctx, first, trackTime, animationTime, posers)
+  };
 }
 function openRawTrack(doc, animation, plant, reset, mode, adjust) {
   return openWalk(doc, animationOf(doc, animation), plant, reset, mode, RAW_SHAPE, adjust);
@@ -4970,6 +5029,7 @@ const HELD = { loop: false, keep: false };
 const LOOPED = { loop: true, keep: false, live: true };
 function openTrack(doc, animation, options, plant = {}) {
   if (typeof options !== "object" || options === null || typeof options.loop !== "boolean") throw new CoreInputError(`the live track's options.loop is ${JSON.stringify(options?.loop)}, not true or false`);
+  if (options.reset !== "animation" && options.reset !== "setup") throw new CoreInputError(`the live track's options.reset is ${JSON.stringify(options.reset)}, not "animation" or "setup"`);
   if (options.adjust !== void 0 && typeof options.adjust !== "function") throw new CoreInputError(`the live track's options.adjust is ${typeof options.adjust}, not a function`);
   const { track, first } = openRawTrack(doc, animation, plant, options.reset, options.loop ? LOOPED : HELD, options.adjust);
   return new Track(track, first);
@@ -5006,6 +5066,940 @@ class Track {
     }
   }
 }
+const CURRENT = 0;
+const SETUP = 1;
+const FIRST = 2;
+const MODE = 3;
+const HOLD = 4;
+const EMPTY = { name: null, duration: 0, timelines: [], ids: /* @__PURE__ */ new Set() };
+const BONE_PROPERTIES = {
+  rotate: ["rotate"],
+  translate: ["x", "y"],
+  translatex: ["x"],
+  translatey: ["y"],
+  scale: ["scaleX", "scaleY"],
+  scalex: ["scaleX"],
+  scaley: ["scaleY"],
+  shear: ["shearX", "shearY"],
+  shearx: ["shearX"],
+  sheary: ["shearY"],
+  inherit: ["inherit"]
+};
+const COLOUR_PROPERTIES = { rgba: ["rgb", "alpha"], rgb: ["rgb"], alpha: ["alpha"], rgba2: ["rgb", "alpha", "rgb2"], rgb2: ["rgb", "rgb2"] };
+function mixAnimationOf(doc, name) {
+  const anim = doc.animations.find((a) => a.name === name);
+  if (anim === void 0) throw new CoreInputError(`animation "${name}" is not one of this document's [${doc.animations.map((a) => a.name).join(", ")}]`);
+  const t = anim.timelines;
+  const c = anim.constraints;
+  const left = [];
+  for (const [kind, n] of [["ik", c.ik.length], ["transform", c.transform.length], ["path", c.path.length], ["physics", c.physics + (c.physicsKeyed?.length ?? 0)], ["slider", c.slider.length]]) if (n > 0) left.push(`${kind} constraint timelines`);
+  if (t.attachments.some((a) => a.sequence !== null)) left.push("a sequence timeline");
+  if (t.drawOrder.length > 0) left.push("the draw order");
+  for (const a of t.attachments) {
+    if (a.deform === null) continue;
+    const g = doc.skins.find((k) => k.name === a.skin)?.attachments[a.slot]?.[a.attachment]?.geometry;
+    if (g?.kind === "path") left.push(`a deform of path attachment "${a.skin}/${a.slot}/${a.attachment}"`);
+  }
+  if (left.length > 0) throw new CoreInputError(`animation "${name}" keys ${left.join(", ")}, which the live tracks do not mix — they mix bone, slot colour, attachment and deform timelines, and fire events (issue #1336)`);
+  const boneIndex2 = new Map(doc.bones.map((b, i) => [b.name, i]));
+  const slotIndex = new Map(doc.slots.map((s, i) => [s.name, i]));
+  const timelines = [];
+  for (const target of t.slots) {
+    const slot = slotIndex.get(target.name);
+    for (const tl of target.timelines) {
+      if (tl.kind === "attachment") timelines.push({ type: "attachment", slot, keys: tl.keys, ids: [`attachment|${target.name}`], instant: true });
+      else timelines.push({ type: "colour", slot, kind: tl.kind, keys: tl.keys, ids: COLOUR_PROPERTIES[tl.kind].map((p) => `${p}|${target.name}`), instant: false });
+    }
+  }
+  for (const target of t.bones) {
+    const bone2 = boneIndex2.get(target.name);
+    for (const tl of target.timelines) timelines.push({ type: "bone", bone: bone2, kind: tl.kind, keys: tl.keys, ids: BONE_PROPERTIES[tl.kind].map((p) => `${p}|${target.name}`), instant: tl.kind === "inherit" });
+  }
+  for (const a of t.attachments) {
+    if (a.deform === null) continue;
+    const identity = `${a.skin}/${a.slot}/${a.attachment}`;
+    timelines.push({ type: "deform", identity, timeline: a, ids: [`deform|${a.slot}|${identity}`], instant: false });
+  }
+  if (t.events.length > 0) timelines.push({ type: "events", keys: t.events, ids: ["event"], instant: true });
+  return { name, duration: t.duration, timelines, ids: new Set(timelines.flatMap((x) => x.ids)) };
+}
+function newEntry(anim, loop) {
+  return {
+    anim,
+    loop,
+    previous: null,
+    next: null,
+    mixingFrom: null,
+    mixingTo: null,
+    delay: 0,
+    trackTime: 0,
+    trackLast: -1,
+    nextTrackLast: -1,
+    trackEnd: Number.MAX_VALUE,
+    animationLast: -1,
+    nextAnimationLast: -1,
+    mixTime: 0,
+    mixDuration: 0,
+    totalAlpha: 0,
+    keepHold: false,
+    timelineMode: [],
+    timelineHoldMix: [],
+    timelinesRotation: []
+  };
+}
+function animationTimeOf(e) {
+  if (!e.loop) return Math.min(e.trackTime + 0, e.anim.duration);
+  const d = e.anim.duration;
+  if (d === 0) return 0;
+  return e.trackTime % d + 0;
+}
+function trackComplete(e) {
+  const d = e.anim.duration;
+  if (d !== 0) {
+    if (e.loop) return d * (1 + (e.trackTime / d | 0));
+    if (e.trackTime < d) return d;
+  }
+  return e.trackTime;
+}
+const signum = (v) => v > 0 ? 1 : v < 0 ? -1 : 0;
+const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const ATTACH_NONE = 0;
+const ATTACH_SETUP = 1;
+const ATTACH_RETAIN = 2;
+class Pose {
+  constructor(doc, plant) {
+    this.doc = doc;
+    this.plant = plant;
+    this.events = [];
+    this.resolved = /* @__PURE__ */ new Map();
+    this.bones = [...doc.bones];
+    this.active = activeBones(doc);
+    const colour = plant.colour ?? readColour;
+    const gate = plant.slotTimelines ?? slotTimelinesApply;
+    this.live = doc.slots.map((s) => gate(doc, s, this.active));
+    this.slots = doc.slots.map((slot) => {
+      const setupDark = slot.dark === void 0 ? null : readColour(slot.dark);
+      return { placeholder: slot.setup, light: slot.color === void 0 ? [1, 1, 1, 1] : colour(slot.color), dark: setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]], deform: null, seen: [], attachmentState: ATTACH_NONE };
+    });
+  }
+  /** Bone `i`'s locals to write: the setup bone copied on its first write, as `posedBones` copies a keyed one. */
+  bone(i) {
+    const b = this.bones[i];
+    if (!this.active.has(b.name)) return null;
+    if (b === this.doc.bones[i]) this.bones[i] = { ...b };
+    return this.bones[i];
+  }
+  slotLive(i) {
+    return this.live[i];
+  }
+  /** What `placeholder` shows in slot `i` (`Resolved`). */
+  resolve(i, placeholder) {
+    if (placeholder === null) return { key: null, vertex: false, timeline: null, vertices: null };
+    const slot = this.doc.slots[i];
+    const memo = `${i}\0${placeholder}`;
+    const known = this.resolved.get(memo);
+    if (known !== void 0) return known;
+    const s = (this.plant.shown ?? shownAttachment)(this.doc, { ...slot, setup: placeholder });
+    let out;
+    if (s === null) out = { key: null, vertex: false, timeline: null, vertices: null };
+    else if ("conflict" in s) out = { key: `conflict\0${placeholder}`, vertex: false, timeline: null, vertices: null };
+    else out = resolvedOf(this.doc, slot, s);
+    this.resolved.set(memo, out);
+    return out;
+  }
+  /** `SlotPose.setAttachment`: a different attachment clears the deform unless both play the same record's timelines. */
+  setAttachment(i, placeholder) {
+    const s = this.slots[i];
+    const was = this.resolve(i, s.placeholder);
+    const now = this.resolve(i, placeholder);
+    s.placeholder = placeholder;
+    if (was.key === now.key) return;
+    if (!now.vertex || !was.vertex || now.timeline !== was.timeline) s.deform = null;
+  }
+}
+function resolvedOf(doc, slot, s) {
+  const g = s.record.geometry;
+  const key = `${s.skin}\0${s.placeholder}`;
+  if (g === void 0 || g.kind === "region") return { key, vertex: false, timeline: null, vertices: null };
+  if (g.kind === "linkedmesh") {
+    const source = doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
+    const vertices = source !== void 0 && source.kind !== "region" && source.kind !== "linkedmesh" ? source.vertices : null;
+    return { key, vertex: true, timeline: s.record.timelines === true ? `${g.skin}/${g.slot}/${g.source}` : `${s.skin}/${slot.name}/${s.placeholder}`, vertices };
+  }
+  return { key, vertex: true, timeline: `${s.skin}/${slot.name}/${s.placeholder}`, vertices: g.vertices };
+}
+class Mixer {
+  constructor(doc, plant) {
+    this.doc = doc;
+    this.plant = plant;
+    this.tracks = [];
+    this.animationsChanged = false;
+    this.propertyIds = /* @__PURE__ */ new Map();
+    this.anims = /* @__PURE__ */ new Map();
+  }
+  animation(name) {
+    let a = this.anims.get(name);
+    if (a === void 0) {
+      a = mixAnimationOf(this.doc, name);
+      this.anims.set(name, a);
+    }
+    return a;
+  }
+  changed() {
+    this.animationsChanged = true;
+  }
+  expandToIndex(index) {
+    while (this.tracks.length <= index) this.tracks.push(null);
+    return this.tracks[index];
+  }
+  clearNext(entry) {
+    entry.next = null;
+  }
+  setTrack(index, current) {
+    const from = this.expandToIndex(index);
+    this.tracks[index] = current;
+    current.previous = null;
+    if (from !== null) {
+      from.next = null;
+      current.mixingFrom = from;
+      from.mixingTo = current;
+      current.mixTime = 0;
+      from.timelinesRotation.length = 0;
+    }
+    this.changed();
+  }
+  setAnimation(track, anim, loop) {
+    let current = this.expandToIndex(track);
+    if (current !== null) {
+      if (current.nextTrackLast === -1 && current.anim === anim) {
+        this.tracks[track] = current.mixingFrom;
+        this.changed();
+        this.clearNext(current);
+        current = current.mixingFrom;
+      } else this.clearNext(current);
+    }
+    const entry = newEntry(anim, loop);
+    this.setTrack(track, entry);
+    return entry;
+  }
+  addAnimation(track, anim, loop, delay) {
+    let last = this.expandToIndex(track);
+    if (last !== null) while (last.next !== null) last = last.next;
+    const entry = newEntry(anim, loop);
+    if (last === null) {
+      this.setTrack(track, entry);
+      if (delay < 0) delay = 0;
+    } else {
+      last.next = entry;
+      entry.previous = last;
+      if (delay <= 0) delay = Math.max(delay + this.complete(last) - entry.mixDuration, 0);
+    }
+    entry.delay = delay;
+    return entry;
+  }
+  /** `TrackEntry.setMixDuration(mixDuration, delay)`. */
+  setMixDuration(entry, mixDuration, delay) {
+    entry.mixDuration = mixDuration;
+    if (delay <= 0) delay = entry.previous === null ? 0 : Math.max(delay + this.complete(entry.previous) - mixDuration, 0);
+    entry.delay = delay;
+  }
+  /** `getTrackComplete`, or 0 under the plant that reads a queued delay as "now". */
+  complete(e) {
+    return this.plant.queueDelayNow === true ? e.trackTime : trackComplete(e);
+  }
+  /** `TrackEntry.mix()`: `mixTime / mixDuration` clamped to 1, 1 over a mix of 0 — reversed under the plant. */
+  mixOf(e) {
+    let m;
+    if (e.mixDuration === 0) m = 1;
+    else {
+      m = e.mixTime / e.mixDuration;
+      if (m >= 1) m = 1;
+    }
+    return this.plant.mixReversed === true ? 1 - m : m;
+  }
+  update(delta) {
+    const tracks = this.tracks;
+    for (let i = 0, n = tracks.length; i < n; i++) {
+      const current = tracks[i];
+      if (current === null) continue;
+      current.animationLast = current.nextAnimationLast;
+      current.trackLast = current.nextTrackLast;
+      let currentDelta = delta;
+      if (current.delay > 0) {
+        current.delay -= currentDelta;
+        if (current.delay > 0) continue;
+        currentDelta = -current.delay;
+        current.delay = 0;
+      }
+      let next = current.next;
+      if (next !== null) {
+        const nextTime = current.trackLast - next.delay;
+        if (nextTime >= 0) {
+          next.delay = 0;
+          next.trackTime += nextTime + delta;
+          current.trackTime += currentDelta;
+          this.setTrack(i, next);
+          while (next.mixingFrom !== null) {
+            next.mixTime += delta;
+            next = next.mixingFrom;
+          }
+          continue;
+        }
+      } else if (current.trackLast >= current.trackEnd && current.mixingFrom === null) {
+        tracks[i] = null;
+        this.changed();
+        this.clearNext(current);
+        continue;
+      }
+      if (current.mixingFrom !== null && this.updateMixingFrom(current, delta)) {
+        const from = current.mixingFrom;
+        current.mixingFrom = null;
+        if (from !== null) from.mixingTo = null;
+        this.changed();
+      }
+      current.trackTime += currentDelta;
+    }
+  }
+  updateMixingFrom(to, delta) {
+    const from = to.mixingFrom;
+    if (from === null) return true;
+    const finished = this.updateMixingFrom(from, delta);
+    from.animationLast = from.nextAnimationLast;
+    from.trackLast = from.nextTrackLast;
+    if (to.nextTrackLast !== -1 && to.mixTime >= to.mixDuration) {
+      if (from.totalAlpha === 0 || to.mixDuration === 0) {
+        to.mixingFrom = from.mixingFrom;
+        if (from.mixingFrom !== null) from.mixingFrom.mixingTo = to;
+        if (from.totalAlpha === 0) for (let next = to; next.mixingTo !== null; next = next.mixingTo) next.keepHold = true;
+        this.changed();
+      }
+      return finished;
+    }
+    from.trackTime += delta;
+    to.mixTime += delta;
+    return false;
+  }
+  /** `AnimationState.apply` onto one step's pose, every track in order; returns track 0's current entry's animation time (0 where it applied none). */
+  apply(pose) {
+    if (this.animationsChanged) this.computeModes();
+    let base = 0;
+    const tracks = this.tracks;
+    for (let i = 0, n = tracks.length; i < n; i++) {
+      const current = tracks[i];
+      if (current === null || current.delay > 0) continue;
+      let alpha = 1;
+      if (current.mixingFrom !== null) alpha *= this.applyMixingFrom(current, pose, i);
+      else if (current.trackTime >= current.trackEnd && current.next === null) alpha = 0;
+      const animationLast = current.animationLast;
+      const animationTime = animationTimeOf(current);
+      const timelines = current.anim.timelines;
+      const count = timelines.length;
+      if (i === 0 && alpha === 1) {
+        for (const tl of timelines) {
+          if (tl.type === "attachment") this.applyAttachment(pose, tl, animationTime, SETUP, true);
+          else this.applyTimeline(pose, tl, animationLast, animationTime, true, 1, SETUP, false);
+        }
+      } else {
+        const modes = current.timelineMode;
+        const retain = alpha >= 0;
+        const firstFrame = current.timelinesRotation.length !== count << 1;
+        if (firstFrame) current.timelinesRotation.length = count << 1;
+        timelines.forEach((tl, ii) => {
+          const from = this.fromOf(modes[ii] & MODE, i);
+          if (tl.type === "bone" && tl.kind === "rotate") this.applyRotate(pose, tl, animationTime, alpha, from, current.timelinesRotation, ii << 1, firstFrame);
+          else if (tl.type === "attachment") this.applyAttachment(pose, tl, animationTime, from, retain);
+          else this.applyTimeline(pose, tl, animationLast, animationTime, true, alpha, from, false);
+        });
+      }
+      if (i === 0) base = animationTime;
+      current.nextAnimationLast = animationTime;
+      current.nextTrackLast = current.trackTime;
+    }
+    pose.slots.forEach((s, k) => {
+      if (s.attachmentState === ATTACH_SETUP) pose.setAttachment(k, this.doc.slots[k].setup);
+    });
+    return base;
+  }
+  /** Where a timeline mixes from — `CURRENT` read as `SETUP` above track 0 under the plant. */
+  fromOf(from, track) {
+    return this.plant.higherTracksFromSetup === true && track > 0 && from === CURRENT ? SETUP : from;
+  }
+  applyMixingFrom(to, pose, track) {
+    const from = to.mixingFrom;
+    const fromMix = from.mixingFrom !== null ? this.applyMixingFrom(from, pose, track) : 1;
+    const mix = this.mixOf(to);
+    const a = 1 * fromMix;
+    const keep = 1 - mix * 1;
+    const alphaMix = a * (1 - mix);
+    const alphaHold = keep > 0 ? alphaMix / keep : a;
+    const timelines = from.anim.timelines;
+    const count = timelines.length;
+    const modes = from.timelineMode;
+    const holdMix = from.timelineHoldMix;
+    const firstFrame = from.timelinesRotation.length !== count << 1;
+    if (firstFrame) from.timelinesRotation.length = count << 1;
+    const animationLast = from.animationLast;
+    const animationTime = animationTimeOf(from);
+    const fire = this.plant.eventsUntilHalfMix === true && mix < 0.5;
+    from.totalAlpha = 0;
+    timelines.forEach((tl, i) => {
+      const mode = modes[i];
+      const mixFrom = this.fromOf(mode & MODE, track);
+      let alpha;
+      if ((mode & HOLD) !== 0 && this.plant.holdFaded !== true) {
+        const h = holdMix[i];
+        alpha = h === null || h === void 0 ? alphaHold : alphaHold * (1 - this.mixOf(h));
+      } else alpha = alphaMix;
+      from.totalAlpha += alpha;
+      if (tl.type === "bone" && tl.kind === "rotate") this.applyRotate(pose, tl, animationTime, alpha, mixFrom, from.timelinesRotation, i << 1, firstFrame);
+      else if (tl.type === "attachment") this.applyAttachment(pose, tl, animationTime, mixFrom, false);
+      else this.applyTimeline(pose, tl, animationLast, animationTime, fire, alpha, mixFrom, true);
+    });
+    from.nextAnimationLast = animationTime;
+    from.nextTrackLast = from.trackTime;
+    return mix;
+  }
+  /** `_animationsChanged`: every track's entries' modes, oldest first, the property owners cleared after. */
+  computeModes() {
+    this.animationsChanged = false;
+    this.tracks.forEach((top, i) => {
+      if (top === null) return;
+      let entry = top;
+      while (entry.mixingFrom !== null) entry = entry.mixingFrom;
+      do {
+        this.computeHold(entry, i);
+        entry = entry.mixingTo;
+      } while (entry !== null);
+    });
+    this.propertyIds.clear();
+  }
+  computeHold(entry, track) {
+    const timelines = entry.anim.timelines;
+    const modes = entry.timelineMode;
+    modes.length = timelines.length;
+    const holdMix = entry.timelineHoldMix;
+    holdMix.length = 0;
+    const to = entry.mixingTo;
+    timelines.forEach((tl, i) => {
+      const from = this.propertyFrom(track, tl.ids);
+      let mode;
+      if (to === null || tl.instant || !hasAny(to.anim, tl.ids)) mode = from;
+      else {
+        mode = from | HOLD;
+        for (let next = to.mixingTo; next !== null; next = next.mixingTo) {
+          if (!hasAny(next.anim, tl.ids)) {
+            if (next.mixDuration > 0) holdMix[i] = next;
+            break;
+          }
+        }
+      }
+      if (entry.keepHold) mode = mode & ~HOLD | (modes[i] ?? 0) & HOLD;
+      modes[i] = mode;
+    });
+  }
+  /** `AnimationState.from`: `SETUP` for a property no one keyed yet, `FIRST` for one this track keyed first, `CURRENT` for one a lower track keyed. */
+  propertyFrom(track, ids) {
+    const owners = this.propertyIds;
+    let from = SETUP;
+    for (let i = 0, n = ids.length; i < n; i++) {
+      const owner = owners.get(ids[i]);
+      if (owner === void 0) owners.set(ids[i], track);
+      else {
+        if (owner !== track) {
+          while (++i < n) if (!owners.has(ids[i])) owners.set(ids[i], track);
+          return CURRENT;
+        }
+        from = FIRST;
+      }
+    }
+    return from;
+  }
+  // -------------------------------------------------------------------------
+  // the timelines' `apply`
+  // -------------------------------------------------------------------------
+  values(keys, t) {
+    const index = (this.plant.search ?? keyIndexAt)(keys, t);
+    if (index < 0) return null;
+    const channel2 = this.plant.channel ?? channelAt;
+    return keys[index].values.map((_v, c) => channel2(keys, index, c, t));
+  }
+  /** `Timeline.apply` for every timeline but an attachment's and a rotation mixed below full weight. */
+  applyTimeline(pose, tl, lastTime, time, fire, alpha, from, out) {
+    switch (tl.type) {
+      case "bone":
+        return this.applyBone(pose, tl, time, alpha, from, out);
+      case "colour":
+        return this.applyColour(pose, tl, time, alpha, from);
+      case "deform":
+        return this.applyDeform(pose, tl, time, alpha, from);
+      case "events":
+        if (fire) pose.events.push(...eventsFired(tl.keys, lastTime, time, rawNumber, time < lastTime));
+        return;
+      case "attachment":
+        return;
+    }
+  }
+  applyBone(pose, tl, time, alpha, from, out) {
+    const bone2 = pose.bone(tl.bone);
+    if (bone2 === null) return;
+    const setup = this.doc.bones[tl.bone];
+    if (tl.kind === "inherit") {
+      const restore = () => {
+        if (setup.inheritMode === void 0) delete bone2.inheritMode;
+        else bone2.inheritMode = setup.inheritMode;
+      };
+      if (out) {
+        if (from !== CURRENT) restore();
+        return;
+      }
+      const index = (this.plant.search ?? keyIndexAt)(tl.keys, time);
+      if (index < 0) {
+        if (from !== CURRENT) restore();
+      } else bone2.inheritMode = tl.keys[index].mode;
+      return;
+    }
+    const v = this.values(tl.keys, time);
+    const relative = (field, i) => {
+      const s = setup[field] ?? 0;
+      const c = bone2[field] ?? 0;
+      bone2[field] = v === null ? beforeFirstKey(from, alpha, c, s) : from === SETUP ? s + v[i] * alpha : c + (v[i] + s - c) * alpha;
+    };
+    const pair = (fx, fy) => {
+      const sx = setup[fx] ?? 0;
+      const sy = setup[fy] ?? 0;
+      if (v === null) {
+        if (from === SETUP) {
+          bone2[fx] = sx;
+          bone2[fy] = sy;
+        } else if (from === FIRST) {
+          bone2[fx] = (bone2[fx] ?? 0) + (sx - (bone2[fx] ?? 0)) * alpha;
+          bone2[fy] = (bone2[fy] ?? 0) + (sy - (bone2[fy] ?? 0)) * alpha;
+        }
+        return;
+      }
+      if (from === SETUP) {
+        bone2[fx] = sx + v[0] * alpha;
+        bone2[fy] = sy + v[1] * alpha;
+      } else {
+        bone2[fx] = (bone2[fx] ?? 0) + (sx + v[0] - (bone2[fx] ?? 0)) * alpha;
+        bone2[fy] = (bone2[fy] ?? 0) + (sy + v[1] - (bone2[fy] ?? 0)) * alpha;
+      }
+    };
+    const scale = (field, i) => {
+      const s = setup[field] ?? 1;
+      const c = bone2[field] ?? 1;
+      bone2[field] = v === null ? beforeFirstKey(from, alpha, c, s) : scaleValue(v[i] * s, alpha, from, out, c, s);
+    };
+    switch (tl.kind) {
+      case "rotate":
+        relative("rotation", 0);
+        break;
+      case "translate":
+        pair("x", "y");
+        break;
+      case "translatex":
+        relative("x", 0);
+        break;
+      case "translatey":
+        relative("y", 0);
+        break;
+      case "shear":
+        pair("shearX", "shearY");
+        break;
+      case "shearx":
+        relative("shearX", 0);
+        break;
+      case "sheary":
+        relative("shearY", 0);
+        break;
+      case "scale":
+        if (v === null) {
+          const sx = setup.scaleX ?? 1;
+          const sy = setup.scaleY ?? 1;
+          if (from === SETUP) {
+            bone2.scaleX = sx;
+            bone2.scaleY = sy;
+          } else if (from === FIRST) {
+            bone2.scaleX = (bone2.scaleX ?? 1) + (sx - (bone2.scaleX ?? 1)) * alpha;
+            bone2.scaleY = (bone2.scaleY ?? 1) + (sy - (bone2.scaleY ?? 1)) * alpha;
+          }
+        } else {
+          bone2.scaleX = scaleValue(v[0] * (setup.scaleX ?? 1), alpha, from, out, bone2.scaleX ?? 1, setup.scaleX ?? 1);
+          bone2.scaleY = scaleValue(v[1] * (setup.scaleY ?? 1), alpha, from, out, bone2.scaleY ?? 1, setup.scaleY ?? 1);
+        }
+        break;
+      case "scalex":
+        scale("scaleX", 0);
+        break;
+      case "scaley":
+        scale("scaleY", 0);
+        break;
+    }
+  }
+  /** `applyRotateTimeline`: a rotation mixed below full weight turns the way it first turned. */
+  applyRotate(pose, tl, time, alpha, from, rotations, i, firstFrame) {
+    if (firstFrame) rotations[i] = 0;
+    if (alpha === 1) {
+      this.applyBone(pose, tl, time, 1, from, false);
+      return;
+    }
+    const bone2 = pose.bone(tl.bone);
+    if (bone2 === null) return;
+    const setup = this.doc.bones[tl.bone].rotation ?? 0;
+    const v = this.values(tl.keys, time);
+    let r1;
+    let r2;
+    if (v === null) {
+      if (from === SETUP) {
+        bone2.rotation = setup;
+        return;
+      }
+      if (from === CURRENT) return;
+      r1 = bone2.rotation ?? 0;
+      r2 = setup;
+    } else {
+      r1 = from === SETUP ? setup : bone2.rotation ?? 0;
+      r2 = setup + v[0];
+    }
+    let total;
+    let diff = r2 - r1;
+    diff -= Math.ceil(diff / 360 - 0.5) * 360;
+    if (diff === 0) total = rotations[i];
+    else {
+      let lastTotal;
+      let lastDiff;
+      if (firstFrame) {
+        lastTotal = 0;
+        lastDiff = diff;
+      } else {
+        lastTotal = rotations[i];
+        lastDiff = rotations[i + 1] ?? Number.NaN;
+      }
+      const loops = lastTotal - lastTotal % 360;
+      total = diff + loops;
+      const current = diff >= 0;
+      let dir = lastTotal >= 0;
+      if (Math.abs(lastDiff) <= 90 && signum(lastDiff) !== signum(diff)) {
+        if (Math.abs(lastTotal - loops) > 180) {
+          total += 360 * signum(lastTotal);
+          dir = current;
+        } else if (loops !== 0) total -= 360 * signum(lastTotal);
+        else dir = current;
+      }
+      if (dir !== current) total += 360 * signum(lastTotal);
+      rotations[i] = total;
+    }
+    rotations[i + 1] = diff;
+    bone2.rotation = r1 + total * alpha;
+  }
+  /** `applyAttachmentTimeline`: shown for good when retained, else for the deform timelines only and set back at the end of the apply. */
+  applyAttachment(pose, tl, time, from, retain) {
+    if (!pose.slotLive(tl.slot)) return;
+    const s = pose.slots[tl.slot];
+    if (!retain && s.attachmentState === ATTACH_RETAIN) return;
+    const index = (this.plant.search ?? keyIndexAt)(tl.keys, time);
+    let setup = index < 0;
+    let name = null;
+    if (!setup) {
+      name = tl.keys[index].name ?? null;
+      setup = !retain && name === null;
+    }
+    if (setup) {
+      if (from === CURRENT) return;
+      name = this.doc.slots[tl.slot].setup;
+    }
+    pose.setAttachment(tl.slot, name);
+    if (retain) s.attachmentState = ATTACH_RETAIN;
+    else if (!setup) s.attachmentState = ATTACH_SETUP;
+  }
+  applyColour(pose, tl, time, alpha, from) {
+    if (!pose.slotLive(tl.slot)) return;
+    const slot = this.doc.slots[tl.slot];
+    const s = pose.slots[tl.slot];
+    const l = s.light;
+    const d = s.dark;
+    const sl = slot.color === void 0 ? [1, 1, 1, 1] : (this.plant.colour ?? readColour)(slot.color);
+    const sdFull = slot.dark === void 0 ? null : readColour(slot.dark);
+    const sd = sdFull === null ? [0, 0, 0] : [sdFull[0], sdFull[1], sdFull[2]];
+    const clampLight = () => {
+      for (let k = 0; k < 4; k++) l[k] = clamp01(l[k]);
+    };
+    const v = this.values(tl.keys, time);
+    const channels = SLOT_COLOUR_TIMELINES[tl.kind].channels.length;
+    switch (tl.kind) {
+      case "rgba": {
+        if (v === null) {
+          if (from === SETUP) for (let k = 0; k < 4; k++) l[k] = sl[k];
+          else if (from === FIRST) {
+            for (let k = 0; k < 4; k++) l[k] += (sl[k] - l[k]) * alpha;
+            clampLight();
+          }
+          return;
+        }
+        if (alpha === 1) for (let k = 0; k < 4; k++) l[k] = v[k];
+        else if (from === SETUP) for (let k = 0; k < 4; k++) l[k] = sl[k] + (v[k] - sl[k]) * alpha;
+        else for (let k = 0; k < 4; k++) l[k] += (v[k] - l[k]) * alpha;
+        clampLight();
+        return;
+      }
+      case "rgb": {
+        if (v === null) {
+          if (from === SETUP) for (let k = 0; k < 3; k++) l[k] = sl[k];
+          else if (from === FIRST) for (let k = 0; k < 3; k++) l[k] += (sl[k] - l[k]) * alpha;
+          return;
+        }
+        const rgb = [v[0], v[1], v[2]];
+        if (alpha !== 1) for (let k = 0; k < 3; k++) rgb[k] = from === SETUP ? sl[k] + (rgb[k] - sl[k]) * alpha : l[k] + (rgb[k] - l[k]) * alpha;
+        for (let k = 0; k < 3; k++) l[k] = clamp01(rgb[k]);
+        return;
+      }
+      case "alpha": {
+        if (v === null) {
+          if (from === SETUP) l[3] = sl[3];
+          else if (from === FIRST) l[3] += (sl[3] - l[3]) * alpha;
+          return;
+        }
+        let a = v[0];
+        if (alpha !== 1) a = from === SETUP ? sl[3] + (a - sl[3]) * alpha : l[3] + (a - l[3]) * alpha;
+        l[3] = clamp01(a);
+        return;
+      }
+      case "rgba2":
+      case "rgb2": {
+        if (d === null) return;
+        const withAlpha = tl.kind === "rgba2";
+        const lightN = withAlpha ? 4 : 3;
+        if (v === null) {
+          if (from === SETUP) {
+            for (let k = 0; k < lightN; k++) l[k] = sl[k];
+            for (let k = 0; k < 3; k++) d[k] = sd[k];
+          } else if (from === FIRST) {
+            for (let k = 0; k < lightN; k++) l[k] += (sl[k] - l[k]) * alpha;
+            if (withAlpha) clampLight();
+            for (let k = 0; k < 3; k++) d[k] += (sd[k] - d[k]) * alpha;
+          }
+          return;
+        }
+        const light = v.slice(0, lightN);
+        const dark = v.slice(lightN, channels);
+        if (withAlpha) {
+          if (alpha === 1) for (let k = 0; k < 4; k++) l[k] = light[k];
+          else if (from === SETUP) {
+            for (let k = 0; k < 4; k++) l[k] = sl[k] + (light[k] - sl[k]) * alpha;
+            for (let k = 0; k < 3; k++) dark[k] = sd[k] + (dark[k] - sd[k]) * alpha;
+          } else {
+            for (let k = 0; k < 4; k++) l[k] += (light[k] - l[k]) * alpha;
+            for (let k = 0; k < 3; k++) dark[k] = d[k] + (dark[k] - d[k]) * alpha;
+          }
+          clampLight();
+        } else {
+          if (alpha !== 1) {
+            for (let k = 0; k < 3; k++) {
+              light[k] = from === SETUP ? sl[k] + (light[k] - sl[k]) * alpha : l[k] + (light[k] - l[k]) * alpha;
+              dark[k] = from === SETUP ? sd[k] + (dark[k] - sd[k]) * alpha : d[k] + (dark[k] - d[k]) * alpha;
+            }
+          }
+          for (let k = 0; k < 3; k++) l[k] = clamp01(light[k]);
+        }
+        for (let k = 0; k < 3; k++) d[k] = clamp01(dark[k]);
+        return;
+      }
+    }
+  }
+  /** `DeformTimeline.apply`: every live slot showing the record the timeline keys, its deform array mixed. */
+  applyDeform(pose, tl, time, alpha, from) {
+    const keys = tl.timeline.deform;
+    if (keys === null) return;
+    pose.slots.forEach((s, k) => {
+      if (!pose.slotLive(k)) return;
+      const shown = pose.resolve(k, s.placeholder);
+      if (!shown.vertex || shown.timeline !== tl.identity || shown.vertices === null) return;
+      const vertices = shown.vertices;
+      if (!s.seen.includes(tl.identity)) s.seen.push(tl.identity);
+      const target = (this.plant.deform ?? deformAt)(vertices, keys, time);
+      let mixFrom = from;
+      if (s.deform === null) mixFrom = SETUP;
+      if (target === null) {
+        if (mixFrom === SETUP) s.deform = null;
+        else if (mixFrom === FIRST) {
+          if (alpha === 1) {
+            s.deform = null;
+            return;
+          }
+          const current = s.deform;
+          if (!vertices.weighted) {
+            const setup = setupArray(vertices);
+            s.deform = current.map((c, i) => c + (setup[i] - c) * alpha);
+          } else {
+            const keep = 1 - alpha;
+            s.deform = current.map((c) => c * keep);
+          }
+        }
+        return;
+      }
+      if (alpha === 1) s.deform = [...target];
+      else if (mixFrom === SETUP) {
+        if (!vertices.weighted) {
+          const setup = setupArray(vertices);
+          s.deform = target.map((v, i) => setup[i] + (v - setup[i]) * alpha);
+        } else s.deform = target.map((v) => v * alpha);
+      } else {
+        const current = s.deform;
+        s.deform = current.map((c, i) => c + (target[i] - c) * alpha);
+      }
+    });
+  }
+}
+function beforeFirstKey(from, alpha, current, setup) {
+  if (from === SETUP) return setup;
+  if (from === FIRST) return current + (setup - current) * alpha;
+  return current;
+}
+function scaleValue(value, alpha, from, out, current, setup) {
+  if (alpha === 1) return value;
+  let base = from === SETUP ? setup : current;
+  if (out) return base + (Math.abs(value) * Math.sign(base) - base) * alpha;
+  base = Math.abs(base) * Math.sign(value);
+  return base + (value - base) * alpha;
+}
+function hasAny(anim, ids) {
+  for (const id of ids) if (anim.ids.has(id)) return true;
+  return false;
+}
+function trackIndex(track, call) {
+  if (typeof track !== "number" || !Number.isInteger(track) || track < 0) throw new CoreInputError(`the live tracks' ${call} names track ${String(track)}, not a whole number at or above 0`);
+  return track;
+}
+function finiteAtOrAbove0(v, what, call) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) throw new CoreInputError(`the live tracks' ${call} ${what} is ${String(v)}, not a finite time at or above 0`);
+  return v;
+}
+function loopOf(options, call) {
+  if (typeof options !== "object" || options === null || typeof options.loop !== "boolean") throw new CoreInputError(`the live tracks' ${call} options.loop is ${JSON.stringify(options?.loop)}, not true or false`);
+  return options.loop;
+}
+function delayOf(v, call) {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new CoreInputError(`the live tracks' ${call} delay is ${String(v)}, not a finite number`);
+  return v;
+}
+function openTracks(doc, options, plant = {}) {
+  if (typeof options !== "object" || options === null || options.reset !== "animation" && options.reset !== "setup") throw new CoreInputError(`the live tracks' options.reset is ${JSON.stringify(options?.reset)}, not "animation" or "setup"`);
+  if (options.adjust !== void 0 && typeof options.adjust !== "function") throw new CoreInputError(`the live tracks' options.adjust is ${typeof options.adjust}, not a function`);
+  return new Tracks(doc, options.reset, options.adjust, plant, openRawTracksPath(doc, plant));
+}
+class Tracks {
+  constructor(doc, reset, adjust, plant, path) {
+    this.doc = doc;
+    this.reset = reset;
+    this.adjust = adjust;
+    this.plant = plant;
+    this.path = path;
+    this.started = false;
+    this.steps = 0;
+    this.time = 0;
+    this.refused = null;
+    this.mixer = new Mixer(doc, plant);
+  }
+  get trackTime() {
+    return this.time;
+  }
+  live(call) {
+    if (this.refused !== null) throw new CoreInputError(`the live tracks were refused at ${this.refused}, after their entries and physics had moved; open them again (${call} not made)`);
+  }
+  setAnimation(track, animation, options) {
+    this.live("setAnimation");
+    const i = trackIndex(track, "setAnimation");
+    const loop = loopOf(options, "setAnimation");
+    const mix = finiteAtOrAbove0(options.mixDuration, "mixDuration", "setAnimation");
+    const entry = this.mixer.setAnimation(i, this.mixer.animation(animation), loop);
+    entry.mixDuration = mix;
+  }
+  setEmptyAnimation(track, mixDuration) {
+    this.live("setEmptyAnimation");
+    const i = trackIndex(track, "setEmptyAnimation");
+    const mix = finiteAtOrAbove0(mixDuration, "mixDuration", "setEmptyAnimation");
+    const entry = this.mixer.setAnimation(i, EMPTY, false);
+    entry.mixDuration = mix;
+    entry.trackEnd = mix;
+  }
+  addAnimation(track, animation, options) {
+    this.live("addAnimation");
+    const i = trackIndex(track, "addAnimation");
+    const loop = loopOf(options, "addAnimation");
+    const mix = finiteAtOrAbove0(options.mixDuration, "mixDuration", "addAnimation");
+    const delay = delayOf(options.delay, "addAnimation");
+    const entry = this.mixer.addAnimation(i, this.mixer.animation(animation), loop, delay);
+    this.mixer.setMixDuration(entry, mix, delay);
+  }
+  addEmptyAnimation(track, mixDuration, delay) {
+    this.live("addEmptyAnimation");
+    const i = trackIndex(track, "addEmptyAnimation");
+    const mix = finiteAtOrAbove0(mixDuration, "mixDuration", "addEmptyAnimation");
+    const d = delayOf(delay, "addEmptyAnimation");
+    const entry = this.mixer.addAnimation(i, EMPTY, false, d);
+    if (d <= 0) entry.delay = Math.max(entry.delay + entry.mixDuration - mix, 0);
+    entry.mixDuration = mix;
+    entry.trackEnd = mix;
+  }
+  current(track) {
+    const e = this.mixer.tracks[trackIndex(track, "current")] ?? null;
+    if (e === null) return null;
+    return { animation: e.anim.name, loop: e.loop, trackTime: e.trackTime, animationTime: animationTimeOf(e), duration: e.anim.duration };
+  }
+  start() {
+    this.live("start");
+    if (this.started) throw new CoreInputError("the live tracks were started already; pose 0 is posed once");
+    this.started = true;
+    return this.guard("start", () => {
+      if (this.reset === "setup") return this.path.setupPose();
+      return this.pose(0, true);
+    });
+  }
+  step(dt) {
+    const n = this.steps + 1;
+    this.live(`step ${n}`);
+    if (!this.started) throw new CoreInputError(`the live tracks' step ${n} comes before start(), which poses pose 0`);
+    if (typeof dt !== "number" || !Number.isFinite(dt) || dt < 0) throw new CoreInputError(`the live tracks' step ${n} is ${String(dt)}, not a finite time at or above 0`);
+    return this.guard(`step ${n}`, () => {
+      this.time += dt;
+      this.mixer.update(dt);
+      const pose = this.pose(dt, false);
+      this.steps = n;
+      return pose;
+    });
+  }
+  /** `f`, the state refused for good if it throws once anything has moved. */
+  guard(call, f) {
+    try {
+      return f();
+    } catch (err) {
+      this.refused = `${call} (${err instanceof Error ? err.message : String(err)})`;
+      throw err;
+    }
+  }
+  /** One pose: the entries applied over the setup pose, then the raw pose path (`openRawTracksPath`). */
+  pose(dt, first) {
+    const { doc, path } = this;
+    const ctx = path.ctx;
+    const before = ctx.time;
+    ctx.time += dt;
+    const pose = new Pose(doc, this.plant);
+    const animationTime = this.mixer.apply(pose);
+    const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));
+    return path.step(first, this.time, animationTime, {
+      world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjust: this.adjust }),
+      slots: (sliders, placeholders) => slotRowsFrom(doc, path.raw, sliders, placeholders, (_slot, _live) => {
+        const s = pose.slots[doc.slots.indexOf(_slot)];
+        return { placeholder: s.placeholder, light: s.light, dark: s.dark };
+      }),
+      drawOrder: [],
+      at: 0,
+      sample: null,
+      mixed,
+      events: () => pose.events
+    });
+  }
+}
 function documentPageLookup(pages) {
   const first = /* @__PURE__ */ new Map();
   for (const page of pages) {
@@ -7222,7 +8216,7 @@ function trianglesOf(source, drawn) {
   }
   return kept;
 }
-function clipCover(pose, active) {
+function clipCover(pose, active, draws = () => true) {
   const polygons = new Map(pose.clips.map((c) => [c[0], { end: c[2], polygon: c[3] }]));
   const shownOf = new Map(pose.shown.map((s) => [s.slot, s]));
   const cover = /* @__PURE__ */ new Map();
@@ -7233,7 +8227,7 @@ function clipCover(pose, active) {
     const clip = g?.kind === "clipping" ? polygons.get(slot) : void 0;
     if (shown !== void 0 && g?.kind === "clipping" && clip !== void 0) {
       if (current !== null && current.end === slot) current = null;
-      if (active.has(shown.bone) && current === null) {
+      if (active.has(shown.bone) && current === null && draws(slot)) {
         current = { end: clip.end, clip: { polygon: clip.polygon, inverse: g.inverse, convex: g.convex } };
       }
       continue;
@@ -7243,16 +8237,17 @@ function clipCover(pose, active) {
   }
   return cover;
 }
-function frameOf(source, pose, color = [1, 1, 1, 1]) {
+function frameOf(source, pose, color = [1, 1, 1, 1], draws = () => true) {
   const { drawn: regions, why } = drawnRegions(source.doc, pose.shown, pose.drawOrder, source.uv);
   if (regions === null) throw new CoreInputError(`the page UVs are not posed: ${why}`);
   const regionOf = new Map(regions.map((r) => [r.slot, r]));
   const rows = new Map(pose.slots.map((row) => [row[0], row]));
   const z = new Map(pose.drawOrder.map((slot, index) => [slot, index]));
-  const cover = clipCover(pose, source.active);
+  const cover = clipCover(pose, source.active, draws);
   const [sr, sg, sb, sa] = color;
   const order = [];
   for (const d of pose.drawn) {
+    if (!draws(d.slot)) continue;
     const bone2 = source.boneOf.get(d.slot);
     if (bone2 === void 0 || !source.active.has(bone2)) continue;
     const found = regionOf.get(d.slot);
@@ -7300,6 +8295,10 @@ function frameOf(source, pose, color = [1, 1, 1, 1]) {
   }
   return { order };
 }
+function predicateOf(names) {
+  const allowed = new Set(names);
+  return (slot) => allowed.has(slot);
+}
 class RigPlayer {
   /**
    * The renderer this player draws through — its knobs and counters are the
@@ -7322,13 +8321,34 @@ class RigPlayer {
   read;
   skinName;
   seekStep;
+  /**
+   * The single live track (`openTrack`): what a plain `play` on track 0 runs
+   * on, as every 1.x player did — one animation, every construct the core
+   * poses, `seek` and a skin change by reopening. Null once the player is
+   * composed.
+   */
   track = null;
+  /**
+   * The live tracks (`openTracks`): opened by the first composing call — a
+   * `play` with a mix or on another track, a `queue`, a `clear` — from the
+   * single track's animation stepped to its time. The mixing is the Spine
+   * runtime's, which does not mix a constraint, sequence, draw-order or
+   * path-deform timeline, so such an animation is refused here and plays on
+   * the single track only.
+   */
+  tracks = null;
+  /** Track 0's animation and loop as `play` last set them — what `seek` and a skin change reopen. */
   animation = null;
   loop = true;
+  /** One past the highest track touched — how many `current(track)` reads a step takes. */
+  trackCount = 0;
   paused = false;
   pose = null;
   setup = null;
   adjustFn = null;
+  slotFilter = null;
+  /** `slotFilter` as a predicate; every slot when null. */
+  draws = () => true;
   /** Handed to every track the player opens; reads the current `adjust` so setting it later needs no reopen. */
   adjustHook = (locals) => {
     if (this.adjustFn !== null) this.adjustFn(locals);
@@ -7349,6 +8369,7 @@ class RigPlayer {
     this.assets = assets;
     this.meshBackend = options.meshBackend;
     this.adjustFn = options.adjust ?? null;
+    if (options.slots !== void 0 && options.slots !== null) this.slots = options.slots;
     this.active = this.create(options.mode ?? "dom");
   }
   /**
@@ -7388,23 +8409,118 @@ class RigPlayer {
     if (this.meshBackend) renderer.meshBackend = this.meshBackend;
     return renderer;
   }
-  /** The animation the track is playing, or null before `play`. */
+  /** What track 0 plays, or null before `play` and after a `clear` of track 0 has mixed out. */
   get current() {
-    return this.animation;
+    return this.tracks !== null ? this.tracks.current(0)?.animation ?? null : this.animation;
   }
-  /** The track time — the running sum of the steps since `play` (or the last `seek`). */
+  /** The player's time — the running sum of the steps since `play` (or the last `seek`). */
   get time() {
-    return this.track?.trackTime ?? 0;
+    return this.tracks?.trackTime ?? this.track?.trackTime ?? 0;
   }
   /**
-   * Opens `name` on the track at its first pose, the physics reset there. The
-   * pose is drawn on the next `frame`.
+   * Plays `name` on a track — track 0 by default, which is what `play(name)`
+   * has always meant: the first `play` opens the tracks at their first pose
+   * with the physics reset there, and the pose is drawn on the next `frame`.
+   * Later calls replace what the track plays: the entry it replaces mixes out
+   * over `mix` seconds (0 cuts), and every entry queued on that track is
+   * dropped. The pose the player holds is re-posed at once, so a held player
+   * shows the change on its next `draw`. The mixing is the Spine runtime's,
+   * which rig-c holds at tolerance 0; an animation keying what the tracks do
+   * not mix — a constraint, a sequence, the draw order, a path's deform — is
+   * refused here, by name, in the core's words.
    */
   play(name, options = {}) {
-    this.loop = options.loop ?? true;
-    this.animation = name;
+    const track = options.track ?? 0;
+    const loop = options.loop ?? true;
+    const mix = options.mix ?? 0;
     this.paused = false;
-    this.open();
+    if (this.tracks === null && track === 0 && mix === 0) {
+      this.animation = name;
+      this.loop = loop;
+      this.track = openTrack(this.view, name, { loop, reset: "animation", adjust: this.adjustHook });
+      this.pose = this.track.first;
+      return;
+    }
+    const tracks = this.compose();
+    tracks.setAnimation(track, name, { loop, mixDuration: mix });
+    this.trackCount = Math.max(this.trackCount, track + 1);
+    if (track === 0) {
+      this.animation = name;
+      this.loop = loop;
+    }
+    this.pose = tracks.step(0);
+  }
+  /**
+   * Queues `name` after the last entry on `track` (`QueueOptions`): with
+   * `delay` at or below 0 it starts when that entry completes less its own
+   * `mix`, so a one-shot hands over to it across a mix; on an empty track it
+   * is set. Before any `play`, the tracks are opened for it.
+   */
+  queue(name, options = {}) {
+    const track = options.track ?? 0;
+    const tracks = this.compose();
+    tracks.addAnimation(track, name, { loop: options.loop ?? true, mixDuration: options.mix ?? 0, delay: options.delay ?? 0 });
+    this.trackCount = Math.max(this.trackCount, track + 1);
+    this.pose = tracks.step(0);
+  }
+  /**
+   * Mixes `track` out to nothing over `mix` seconds — the layer or one-shot
+   * gone and the tracks below showing through. Track 0 cleared shows the
+   * setup pose. The pose the player holds is re-posed at once.
+   */
+  clear(track = 0, options = {}) {
+    const tracks = this.compose();
+    tracks.setEmptyAnimation(track, options.mix ?? 0);
+    this.trackCount = Math.max(this.trackCount, track + 1);
+    this.pose = tracks.step(0);
+  }
+  /**
+   * Queues a mix out to nothing after the last entry on `track`, over `mix`
+   * seconds; with `delay` 0 (the default) the mix ends as that entry
+   * completes, so a one-shot queued this way plays once and fades out over
+   * its last `mix` seconds.
+   */
+  queueClear(track = 0, options = {}) {
+    const tracks = this.compose();
+    tracks.addEmptyAnimation(track, options.mix ?? 0, options.delay ?? 0);
+    this.trackCount = Math.max(this.trackCount, track + 1);
+    this.pose = tracks.step(0);
+  }
+  /** `track`'s current entry, or null where it plays nothing (and before `play`). */
+  entry(track = 0) {
+    if (this.tracks !== null) {
+      const view = this.tracks.current(track);
+      return view === null ? null : { animation: view.animation, loop: view.loop, trackTime: view.trackTime, animationTime: view.animationTime, duration: view.duration };
+    }
+    const single = this.track;
+    if (track !== 0 || single === null) return null;
+    return { animation: this.animation, loop: this.loop, trackTime: single.trackTime, animationTime: single.animationTime, duration: single.duration };
+  }
+  /** Whether the player is composed: on the live tracks rather than the single track. */
+  get composed() {
+    return this.tracks !== null;
+  }
+  /**
+   * The live tracks, opened by the first composing call. A single track in
+   * play is carried over by replay: track 0 set to its animation, pose 0 taken
+   * by `start()` (the player's — nothing steps before it) and the tracks
+   * stepped to the single track's time in `seekStep` increments, so a physics
+   * rig's history restarts there and nothing is fired on the way.
+   */
+  compose() {
+    if (this.tracks !== null) return this.tracks;
+    const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook });
+    const single = this.track;
+    const time = single?.trackTime ?? 0;
+    if (single !== null && this.animation !== null) {
+      tracks.setAnimation(0, this.animation, { loop: this.loop, mixDuration: 0 });
+      this.trackCount = 1;
+    }
+    this.tracks = tracks;
+    this.track = null;
+    this.pose = tracks.start();
+    if (time > 0) this.stepTo(time);
+    return tracks;
   }
   /** Stops stepping; `frame` keeps drawing the pose it holds. */
   pause() {
@@ -7415,23 +8531,33 @@ class RigPlayer {
     this.paused = false;
   }
   /**
-   * Moves the track to `time`: the animation is reopened and stepped forward
-   * in `seekStep` increments (the last one shorter) until the track time
-   * reaches `time`. Events and completes crossed on the way are not fired.
+   * Moves a single animation on track 0 to `time`: the tracks are reopened
+   * with that animation and stepped forward in `seekStep` increments (the
+   * last one shorter) until the time is reached. Events and completes crossed
+   * on the way are not fired. It has a meaning for one animation on one
+   * track only — the player cannot replay when a mix, a second track or a
+   * queue was asked for — so after any of those it refuses by name; step the
+   * player forward instead.
    */
   seek(time) {
     if (this.animation === null) throw new Error("seek before play: no animation is open");
     if (!(time >= 0) || !Number.isFinite(time)) throw new Error(`seek time must be a finite time at or above 0, got ${String(time)}`);
-    this.open();
+    if (this.tracks !== null) throw new Error("seek is defined for a single animation on track 0; after a mix, another track, a queue or a clear the player cannot replay to a time — step it forward with frame/advance instead");
+    this.reopen();
     this.stepTo(time);
   }
-  /** Steps the freshly opened track forward to `time` in `seekStep` increments, the last one shorter. */
+  /** The single track opened again with track 0's animation as `play` last set it, at pose 0. */
+  reopen() {
+    this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook });
+    this.pose = this.track.first;
+  }
+  /** Steps whatever is open forward to `time` in `seekStep` increments, the last one shorter. */
   stepTo(time) {
-    const track = this.track;
+    const stepper = this.tracks ?? this.track;
     const steps = Math.floor(time / this.seekStep);
-    for (let i = 0; i < steps; i++) this.pose = track.step(this.seekStep);
-    const rest = time - track.trackTime;
-    if (rest > 0) this.pose = track.step(rest);
+    for (let i = 0; i < steps; i++) this.pose = stepper.step(this.seekStep);
+    const rest = time - stepper.trackTime;
+    if (rest > 0) this.pose = stepper.step(rest);
   }
   on(type, listener) {
     const set = this.listeners[type];
@@ -7453,13 +8579,22 @@ class RigPlayer {
    * checks and nothing else.
    */
   advance(dt) {
-    const track = this.track;
-    if (track === null || this.pose === null) return;
+    if (this.pose === null) return;
     const step = dt * this.timeScale;
     if (this.paused || !(step > 0)) return;
+    const tracks = this.tracks;
+    if (tracks !== null) {
+      const before2 = [];
+      for (let t = 0; t < this.trackCount; t++) before2.push(tracks.current(t));
+      this.pose = tracks.step(step);
+      this.dispatch(this.pose, before2, tracks);
+      return;
+    }
+    const track = this.track;
+    if (track === null) return;
     const before = track.trackTime;
     this.pose = track.step(step);
-    this.dispatch(this.pose, before, track);
+    this.dispatchSingle(this.pose, before, track);
   }
   /** Draws the pose the player holds. */
   draw() {
@@ -7481,6 +8616,7 @@ class RigPlayer {
   }
   set skin(name) {
     if (name === this.skinName) return;
+    if (this.tracks !== null) throw new Error("skin cannot change after a mix, another track, a queue or a clear: the player cannot replay those to the current time — set it before composing, or play again");
     const view = name === void 0 ? underNoSkin(this.read.doc) : underSkin(this.read.doc, name);
     this.view = view;
     this.source = frameSource(view, this.read.parsed);
@@ -7488,10 +8624,41 @@ class RigPlayer {
     this.setup = null;
     if (this.animation !== null && this.track !== null) {
       const time = this.track.trackTime;
-      this.open();
+      this.reopen();
       this.stepTo(time);
     }
   }
+  /**
+   * Which slots this player draws (`SlotFilter`), or null for every slot.
+   * Settable on a live player: the next `draw` shows it, and `bounds()` reads
+   * the drawn slots. An allow list naming a slot the document does not have
+   * is refused by name. The pose is the whole rig's: `bone()`, `adjust`, the
+   * events and the tracks see no filter.
+   */
+  get slots() {
+    return this.slotFilter;
+  }
+  set slots(filter) {
+    if (filter === null) {
+      this.slotFilter = null;
+      this.draws = () => true;
+      return;
+    }
+    if (typeof filter === "function") {
+      this.slotFilter = filter;
+      this.draws = filter;
+      return;
+    }
+    if (!Array.isArray(filter)) throw new Error(`slots must be an array of slot names, a function, or null, got ${typeof filter}`);
+    const known = new Set(this.read.doc.slots.map((slot) => slot.name));
+    const unknown = filter.filter((name) => !known.has(name));
+    if (unknown.length > 0) {
+      throw new Error(`no slot named ${unknown.map((n) => JSON.stringify(n)).join(", ")} in this document (slots: ${[...known].join(", ")})`);
+    }
+    const allowed = new Set(filter);
+    this.slotFilter = [...filter];
+    this.draws = (slot) => allowed.has(slot);
+  }
   /**
    * The per-pose adjustment of bone locals (`BoneAdjust`), or null for none.
    * It is applied by every track the player opens — `play`, the reopen inside
@@ -7516,8 +8683,9 @@ class RigPlayer {
    * changed, then `draw`. Nothing before `play`.
    */
   repose() {
-    if (this.track === null || this.pose === null) return;
-    this.pose = this.track.step(0);
+    const stepper = this.tracks ?? this.track;
+    if (stepper === null || this.pose === null) return;
+    this.pose = stepper.step(0);
   }
   /**
    * Where `name` is in the pose the player holds — the pose of the last
@@ -7556,7 +8724,7 @@ class RigPlayer {
    * mode; nothing is computed until called.
    */
   bounds() {
-    const frame2 = this.pose === null ? frameOf(this.source, this.posed(), this.color) : this.posedFrame();
+    const frame2 = this.pose === null ? frameOf(this.source, this.posed(), this.color, this.draws) : this.posedFrame();
     let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
     for (const slot of frame2.order) {
       const points = slot.kind === "region" ? slot.corners : slot.vertices;
@@ -7592,35 +8760,30 @@ class RigPlayer {
     if (this.setup === null) this.setup = poseRawSetup(this.view);
     return this.setup;
   }
-  /** The pose the player holds, as the frame record the renderer draws. */
-  posedFrame() {
+  /**
+   * The pose the player holds, as the frame record the renderer draws — under
+   * this player's `slots` filter, or under `slots` given here instead (a
+   * second renderer over the same assets drawing this player's pose on
+   * another root: `other.render(player.posedFrame(['hand_f']))`, the one rig
+   * posed once).
+   */
+  posedFrame(slots) {
     if (this.pose === null) return { order: [] };
-    return frameOf(this.source, this.pose, this.color);
+    const draws = slots === void 0 ? this.draws : slots === null ? () => true : typeof slots === "function" ? slots : predicateOf(slots);
+    return frameOf(this.source, this.pose, this.color, draws);
   }
   /** Removes the renderer's elements and hands its GPU pages back. The assets stay the caller's. */
   dispose() {
     this.renderer.dispose();
+    this.tracks = null;
     this.track = null;
     this.pose = null;
   }
-  open() {
-    this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook });
-    this.pose = this.track.first;
-  }
-  /**
-   * The step's events, then its complete. The core fires the keys
-   * (`pose.events`, in the runtime's order across a wrap) and leaves
-   * `complete` to the player, which derives it from the track time and the
-   * duration: on a looping track, once on a step whose whole cycles rose past
-   * 0 (rig-c `src/core/track.ts`, *Across the wrap*); on a held one, on the
-   * step that reaches the duration. The runtime queues a looping complete
-   * between the keys before the wrap and the keys after it; this player
-   * dispatches it after all of the step's keys.
-   */
-  dispatch(pose, before, track) {
+  /** The single track's step: its events (track 0) and its complete, as every 1.x player fired them. */
+  dispatchSingle(pose, before, track) {
     if (this.listeners.event.size > 0) {
       for (const [name, time, int, float, string] of pose.events) {
-        const event = { name, time, int, float, string };
+        const event = { name, time, int, float, string, track: 0 };
         for (const listener of this.listeners.event) listener(event);
       }
     }
@@ -7630,7 +8793,69 @@ class RigPlayer {
       const cycles = d > 0 ? Math.floor(after / d) : Infinity;
       const was = d > 0 ? Math.floor(before / d) : -Infinity;
       if (this.loop ? cycles > 0 && cycles > was : before < d && after >= d) {
-        const payload2 = { animation: this.animation };
+        const payload2 = { animation: this.animation, track: 0 };
+        for (const listener of this.listeners.complete) listener(payload2);
+      }
+    }
+  }
+  /**
+   * The step's events, then its completes, each with its track. The core
+   * fires a track's keys from its current entry (`pose.events`, in track
+   * order and in the runtime's order across a wrap) — an entry mixing out
+   * fires none — and leaves `complete` to the player, which derives it per
+   * track from that track's current entry: on a looping entry, once on a step
+   * whose whole cycles rose; on a held one, on the step that reaches its
+   * duration. An entry replaced inside the step — by `play`, or by a queued
+   * entry starting at its completion less the mix — is no longer current and
+   * completes no more than it fires, which is the runtime's rule too.
+   */
+  dispatch(pose, before, tracks) {
+    const after = [];
+    for (let t = 0; t < this.trackCount; t++) after.push(tracks.current(t));
+    const same = (b, a) => b !== null && a !== null && b.animation === a.animation && b.loop === a.loop && a.trackTime >= b.trackTime;
+    if (this.listeners.event.size > 0 && pose.events.length > 0) {
+      const counts = [];
+      let total = 0;
+      for (let t = 0; t < this.trackCount; t++) {
+        const a = after[t];
+        const b = before[t];
+        let n = 0;
+        if (a !== null && a.animation !== null) {
+          const keys = this.view.animations.find((anim) => anim.name === a.animation)?.timelines.events ?? [];
+          if (keys.length > 0) {
+            const last = same(b, a) ? b.animationTime : -1;
+            n = eventsFired(keys, last, a.animationTime, void 0, a.animationTime < last).length;
+          }
+        }
+        counts.push(n);
+        total += n;
+      }
+      const attributed = total === pose.events.length;
+      let track = 0;
+      let left = counts[0] ?? 0;
+      for (const [name, time, int, float, string] of pose.events) {
+        if (attributed) {
+          while (left === 0 && track < counts.length - 1) {
+            track++;
+            left = counts[track];
+          }
+          left--;
+        }
+        const event = attributed ? { name, time, int, float, string, track } : { name, time, int, float, string };
+        for (const listener of this.listeners.event) listener(event);
+      }
+    }
+    if (this.listeners.complete.size > 0) {
+      for (let t = 0; t < this.trackCount; t++) {
+        const a = after[t];
+        const b = before[t];
+        if (!same(b, a) || a === null || a.animation === null) continue;
+        const d = a.duration;
+        const cycles = d > 0 ? Math.floor(a.trackTime / d) : Infinity;
+        const was = d > 0 ? Math.floor(b.trackTime / d) : -Infinity;
+        const fired = a.loop ? cycles > 0 && cycles > was : b.trackTime < d && a.trackTime >= d;
+        if (!fired) continue;
+        const payload2 = { animation: a.animation, track: t };
         for (const listener of this.listeners.complete) listener(payload2);
       }
     }