@rig-c/play 1.17.1 → 1.18.0

package/dist/index.js

@@ -1,3 +1,11 @@
+const liveDrawings = /* @__PURE__ */ new WeakMap();
+function renderFrameOf(frame2) {
+  if ("order" in frame2) return frame2;
+  void frame2.generation;
+  const drawing = liveDrawings.get(frame2);
+  if (!drawing) throw new Error("LIVE_FRAME_SOURCE: renderer needs a liveFrame() borrowed from a player");
+  return drawing;
+}
 const SCALE_PROBE_PX = 100;
 const PIXEL_RATIO_DEADBAND = 1e-3;
 function syncedPixelRatio(root, current) {
@@ -27,15 +35,15 @@ function syncedPixelRatio(root, current) {
   return next;
 }
 const RUNTIME_PI = 3.1415927;
-const RAD$3 = RUNTIME_PI / 180;
+const RAD$4 = RUNTIME_PI / 180;
 const RUNTIME_DEG = 180 / RUNTIME_PI;
 const COLLAPSED_X_AXIS_SQ = 1e-5 * 1e-5;
 const RUNTIME_ARITHMETIC = {
-  radiansPerDegree: RAD$3,
+  radiansPerDegree: RAD$4,
   degreesOf: (radians) => radians * RUNTIME_DEG,
   rotationOnlyFrame: false
 };
-function frame(rotation, shearX, shearY, scaleX, scaleY, rad = RAD$3) {
+function frame(rotation, shearX, shearY, scaleX, scaleY, rad = RAD$4) {
   const xAngle = (rotation + shearX) * rad;
   const yAngle = (rotation + 90 + shearY) * rad;
   return [Math.cos(xAngle) * scaleX, Math.cos(yAngle) * scaleY, Math.sin(xAngle) * scaleX, Math.sin(yAngle) * scaleY];
@@ -52,7 +60,7 @@ function localFrame(arithmetic, rotation, shearX, shearY, scaleX, scaleY) {
 function times(p, q) {
   return [p[0] * q[0] + p[1] * q[2], p[0] * q[1] + p[1] * q[3], p[2] * q[0] + p[3] * q[2], p[2] * q[1] + p[3] * q[3]];
 }
-function noScaleDirection(p, rotation, rad = RAD$3) {
+function noScaleDirection(p, rotation, rad = RAD$4) {
   const r = rotation * rad;
   const cos = Math.cos(r);
   const sin = Math.sin(r);
@@ -584,7 +592,10 @@ function payload(raw, at, problems) {
     if (typeof raw.string !== "string") problems.push(`${at}: string is ${JSON.stringify(raw.string)}, not a string`);
     else out.string = raw.string;
   }
-  for (const key of ["volume", "balance"]) if (raw[key] !== void 0 && (typeof raw[key] !== "number" || !Number.isFinite(raw[key]))) problems.push(`${at}: ${key} is ${JSON.stringify(raw[key])}, not a finite number`);
+  for (const key of ["volume", "balance"]) if (raw[key] !== void 0) {
+    if (typeof raw[key] !== "number" || !Number.isFinite(raw[key])) problems.push(`${at}: ${key} is ${JSON.stringify(raw[key])}, not a finite number`);
+    else out[key] = raw[key];
+  }
   return out;
 }
 function readEventDefs(value, problems) {
@@ -603,7 +614,7 @@ function readEventDefs(value, problems) {
     if (raw.audio !== void 0 && typeof raw.audio !== "string") problems.push(`${at} "${raw.name}": audio is ${JSON.stringify(raw.audio)}, not a string`);
     if (out.has(raw.name)) problems.push(`${at}: event "${raw.name}" is declared twice`);
     const p = payload(raw, `${at} "${raw.name}"`, problems);
-    out.set(raw.name, { name: raw.name, int: p.int ?? 0, float: p.float ?? 0, string: p.string ?? "" });
+    out.set(raw.name, { audio: typeof raw.audio === "string" ? raw.audio : "", volume: p.volume ?? 0, balance: p.balance ?? 0, name: raw.name, int: p.int ?? 0, float: p.float ?? 0, string: p.string ?? "" });
   });
   return out;
 }
@@ -632,7 +643,7 @@ function readEventKeys(value, label, defs, problems) {
       return;
     }
     const p = payload(raw, at, problems);
-    out.push({ time: Math.fround(typeof t === "number" && Number.isFinite(t) ? t : 0), name: def.name, int: p.int ?? def.int, float: p.float ?? def.float, string: p.string ?? def.string });
+    out.push({ volume: def.audio ? p.volume ?? def.volume ?? 0 : 0, balance: def.audio ? p.balance ?? def.volume ?? 0 : 0, time: Math.fround(typeof t === "number" && Number.isFinite(t) ? t : 0), name: def.name, int: p.int ?? def.int, float: p.float ?? def.float, string: p.string ?? def.string });
   });
   return out;
 }
@@ -1017,7 +1028,7 @@ function clipThrough(shape, vertices, triangles, uvs, clip = clipTriangles, read
   }
   return { clipped, vertices: outV, uvs: outUv, triangles: outT, sources };
 }
-const RAD$2 = RUNTIME_PI / 180;
+const RAD$3 = RUNTIME_PI / 180;
 const meshArraysByGeometry = /* @__PURE__ */ new WeakMap();
 function meshArraysOf(mesh) {
   let kept = meshArraysByGeometry.get(mesh);
@@ -1039,7 +1050,7 @@ function regionCorners(region, bone2) {
   const y1 = -H / 2 * sy + r.offsetY * ky;
   const x2 = x1 + r.width * kx;
   const y2 = y1 + r.height * ky;
-  const angle = (region.rotation ?? 0) * RAD$2;
+  const angle = (region.rotation ?? 0) * RAD$3;
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
   const x = region.x ?? 0;
@@ -1052,25 +1063,64 @@ function regionCorners(region, bone2) {
   }
   return out;
 }
-function worldVertices(vertices, bone2, world, coords = Math.fround) {
-  const out = [];
-  if (!vertices.weighted) {
-    for (let i = 0; i + 1 < vertices.xy.length; i += 2) {
-      const x = coords(vertices.xy[i]);
-      const y = coords(vertices.xy[i + 1]);
-      out.push(x * bone2.a + y * bone2.b + bone2.worldX, x * bone2.c + y * bone2.d + bone2.worldY);
+const compiledWeightedByVertices = /* @__PURE__ */ new WeakMap();
+function compileWeightedVertices(vertices, mapIndex) {
+  const bones = [];
+  const indexByName = /* @__PURE__ */ new Map();
+  for (const influences of vertices.bindings) {
+    for (const binding of influences) {
+      if (!indexByName.has(binding.bone)) {
+        indexByName.set(binding.bone, bones.length);
+        bones.push(binding.bone);
+      }
     }
-    return out;
   }
-  for (const influences of vertices.bindings) {
+  bones.length;
+  const bindings = vertices.bindings.map(
+    (influences) => influences.map((binding) => {
+      const idx = indexByName.get(binding.bone);
+      return {
+        bone: idx,
+        x: binding.x,
+        y: binding.y,
+        fx: Math.fround(binding.x),
+        fy: Math.fround(binding.y),
+        weight: Math.fround(binding.weight)
+      };
+    })
+  );
+  return { bones, bindings };
+}
+function compiledWeightedOf(vertices) {
+  let kept = compiledWeightedByVertices.get(vertices);
+  if (kept === void 0) {
+    kept = compileWeightedVertices(vertices);
+    compiledWeightedByVertices.set(vertices, kept);
+  }
+  return kept;
+}
+function resolveBindingBones(bones, world) {
+  const transforms = new Array(bones.length);
+  for (let i = 0; i < bones.length; i++) {
+    const name = bones[i];
+    const t = world.get(name);
+    if (t === void 0) throw new Error(`a binding names bone "${name}", which has no world transform (readModel refuses it first)`);
+    transforms[i] = t;
+  }
+  return transforms;
+}
+function compiledWorldVertices(compiled, world, coords = Math.fround) {
+  const transforms = resolveBindingBones(compiled.bones, world);
+  const out = [];
+  const fround = coords === Math.fround;
+  for (const influences of compiled.bindings) {
     let wx = 0;
     let wy = 0;
     for (const binding of influences) {
-      const t = world.get(binding.bone);
-      if (t === void 0) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
-      const x = coords(binding.x);
-      const y = coords(binding.y);
-      const weight = Math.fround(binding.weight);
+      const t = transforms[binding.bone];
+      const x = fround ? binding.fx : coords(binding.x);
+      const y = fround ? binding.fy : coords(binding.y);
+      const weight = binding.weight;
       wx += (x * t.a + y * t.b + t.worldX) * weight;
       wy += (x * t.c + y * t.d + t.worldY) * weight;
     }
@@ -1078,27 +1128,19 @@ function worldVertices(vertices, bone2, world, coords = Math.fround) {
   }
   return out;
 }
-function deformedWorldVertices(vertices, deform, bone2, world) {
+function compiledDeformedWorldVertices(compiled, deform, world) {
+  const transforms = resolveBindingBones(compiled.bones, world);
   const out = [];
-  if (!vertices.weighted) {
-    for (let i = 0; i + 1 < deform.length; i += 2) {
-      const x = deform[i];
-      const y = deform[i + 1];
-      out.push(x * bone2.a + y * bone2.b + bone2.worldX, x * bone2.c + y * bone2.d + bone2.worldY);
-    }
-    return out;
-  }
   let k = 0;
-  for (const influences of vertices.bindings) {
+  for (const influences of compiled.bindings) {
     let wx = 0;
     let wy = 0;
     for (const binding of influences) {
-      const t = world.get(binding.bone);
-      if (t === void 0) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
-      const x = Math.fround(binding.x) + deform[k];
-      const y = Math.fround(binding.y) + deform[k + 1];
+      const t = transforms[binding.bone];
+      const x = binding.fx + deform[k];
+      const y = binding.fy + deform[k + 1];
       k += 2;
-      const weight = Math.fround(binding.weight);
+      const weight = binding.weight;
       wx += (x * t.a + y * t.b + t.worldX) * weight;
       wy += (x * t.c + y * t.d + t.worldY) * weight;
     }
@@ -1106,6 +1148,30 @@ function deformedWorldVertices(vertices, deform, bone2, world) {
   }
   return out;
 }
+function worldVertices(vertices, bone2, world, coords = Math.fround) {
+  if (!vertices.weighted) {
+    const out = [];
+    for (let i = 0; i + 1 < vertices.xy.length; i += 2) {
+      const x = coords(vertices.xy[i]);
+      const y = coords(vertices.xy[i + 1]);
+      out.push(x * bone2.a + y * bone2.b + bone2.worldX, x * bone2.c + y * bone2.d + bone2.worldY);
+    }
+    return out;
+  }
+  return compiledWorldVertices(compiledWeightedOf(vertices), world, coords);
+}
+function deformedWorldVertices(vertices, deform, bone2, world) {
+  if (!vertices.weighted) {
+    const out = [];
+    for (let i = 0; i + 1 < deform.length; i += 2) {
+      const x = deform[i];
+      const y = deform[i + 1];
+      out.push(x * bone2.a + y * bone2.b + bone2.worldX, x * bone2.c + y * bone2.d + bone2.worldY);
+    }
+    return out;
+  }
+  return compiledDeformedWorldVertices(compiledWeightedOf(vertices), deform, world);
+}
 const isRecord$7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const finite$1 = (v) => typeof v === "number" && Number.isFinite(v);
 const RECT_FIELDS = ["width", "height", "offsetX", "offsetY", "originalWidth", "originalHeight"];
@@ -1150,7 +1216,10 @@ function readVertices(value, where, bones, problems) {
       for (const key of ["x", "y", "weight"]) if (!finite$1(b[key])) problems.push(`${at}: ${key} is ${JSON.stringify(b[key]) ?? "absent"}, not a finite number`);
     });
   });
-  return problems.length === before ? { weighted: true, bindings } : void 0;
+  if (problems.length !== before) return void 0;
+  const weighted = { weighted: true, bindings };
+  compiledWeightedByVertices.set(weighted, compileWeightedVertices(weighted));
+  return weighted;
 }
 function readGeometry(raw, kind, where, bones, slots, problems) {
   const before = problems.length;
@@ -1250,6 +1319,7 @@ function roundedRow(values2, round) {
 function poseGeometry(shown, world, sourceOf, round, plant = {}, draw) {
   const region = plant.region ?? regionCorners;
   const vertices = plant.vertices ?? worldVertices;
+  const deformPoser = plant.deformedVertices ?? deformedWorldVertices;
   const attachments = [];
   const clips = [];
   const nulls = [];
@@ -1260,7 +1330,7 @@ function poseGeometry(shown, world, sourceOf, round, plant = {}, draw) {
     if (bone2 === void 0) throw new Error(`slot "${s.slot}": bone "${s.bone}" has no world transform`);
     const g = s.geometry;
     const deform = s.deform;
-    const drawn = (v) => deform === void 0 ? vertices(v, bone2, world) : plant.vertices === void 0 ? deformedWorldVertices(v, deform, bone2, world) : vertices(deformedVertices(v, deform), bone2, world, EXACT_COORDS);
+    const drawn = (v) => deform === void 0 ? vertices(v, bone2, world) : plant.vertices === void 0 || plant.deformedVertices !== void 0 ? deformPoser(v, deform, bone2, world) : vertices(deformedVertices(v, deform), bone2, world, EXACT_COORDS);
     if (g.kind === "region") {
       const rect = s.frame === void 0 ? g.region.atlas : g.region.frames?.[s.frame] ?? g.region.atlas;
       if (rect === null) {
@@ -1308,7 +1378,7 @@ function poseGeometry(shown, world, sourceOf, round, plant = {}, draw) {
   }
   return { attachments: attachmentsWhy === null ? attachments : null, attachmentsWhy, clips, clipped, clippedWhy, drawnClipped, drawnClippedWhy };
 }
-const RAD$1 = RUNTIME_PI / 180;
+const RAD$2 = RUNTIME_PI / 180;
 function curveLengthTable(chain, curveCount) {
   const curveEnds = [];
   let total = 0;
@@ -1747,7 +1817,7 @@ function solvePath(state, c, slotWorld) {
   else {
     fromTip = false;
     const p = slotWorld;
-    offsetRotation *= p.a * p.d - p.b * p.c > 0 ? RAD$1 : -RAD$1;
+    offsetRotation *= p.a * p.d - p.b * p.c > 0 ? RAD$2 : -RAD$2;
   }
   const changed = [];
   for (let i = 0, p = 3; i < boneCount; i++, p += 3) {
@@ -2593,8 +2663,8 @@ function applySliderPhysics(r, at, alpha, target) {
     }
   }
 }
-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] };
+const clamp01$3 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const COLOUR_CHANNELS$1 = { 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) {
     for (const target of app.timelines.slots) {
@@ -2607,9 +2677,9 @@ 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$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);
+        COLOUR_CHANNELS$1[tl.kind].forEach((at, i) => {
+          if (at < 4) pose.light[at] = app.alpha === 1 ? clamp01$3(v[i]) : clamp01$3(pose.light[at] + (v[i] - pose.light[at]) * app.alpha);
+          else if (pose.dark !== null) pose.dark[at - 4] = app.alpha === 1 ? clamp01$3(v[i]) : clamp01$3(pose.dark[at - 4] + (v[i] - pose.dark[at - 4]) * app.alpha);
         });
       }
     }
@@ -2632,8 +2702,8 @@ function sliderBonesWhy(doc) {
   }
   return found.length === 0 ? null : found.join("; ");
 }
-const DEG = 180 / RUNTIME_PI;
-const RAD = RUNTIME_PI / 180;
+const DEG$1 = 180 / RUNTIME_PI;
+const RAD$1 = RUNTIME_PI / 180;
 const ADMITTED_CONSTRAINT_KINDS = ["ik", "transform", "path", "physics", "slider"];
 const TRANSFORM_PROPERTIES = ["rotate", "x", "y", "scaleX", "scaleY", "shearY"];
 const TRANSFORM_MIXES = { rotate: "mixRotate", x: "mixX", y: "mixY", scaleX: "mixScaleX", scaleY: "mixScaleY", shearY: "mixShearY" };
@@ -2900,7 +2970,7 @@ function posedRecords(records, timelines, t, plant = {}) {
     return { ...r, mixes };
   });
 }
-function wrap180(r) {
+function wrap180$1(r) {
   return r > 180 ? r - 360 : r <= -180 ? r + 360 : r;
 }
 const IDENTITY = { a: 1, b: 0, c: 0, d: 1, worldX: 0, worldY: 0 };
@@ -2939,7 +3009,7 @@ const RUNTIME_SOLVER_RULES = {
 function solverRules(plant) {
   return plant === void 0 ? RUNTIME_SOLVER_RULES : { ...RUNTIME_SOLVER_RULES, ...plant };
 }
-function volumeScaleY(scaleY, s) {
+function volumeScaleY$1(scaleY, s) {
   return scaleY / (s < 0.7 ? 0.25 + s * 0.642857 : s);
 }
 function bone(state, name) {
@@ -2978,11 +3048,11 @@ function localFromWorld(b, p, w, rules = RUNTIME_SOLVER_RULES) {
       const length = Math.sqrt(w.a * w.a + w.c * w.c);
       const [ux2, uy2] = [w.a / length, w.c / length];
       decompose(b, length, 0, ux2 * w.b + uy2 * w.d, (ux2 * w.d - uy2 * w.b) * flip, rules);
-      b.rotation = Math.atan2((uy2 * p.a - ux2 * p.c) / det, (ux2 * p.d - uy2 * p.b) / det) * DEG;
+      b.rotation = Math.atan2((uy2 * p.a - ux2 * p.c) / det, (ux2 * p.d - uy2 * p.b) / det) * DEG$1;
       return;
     }
     const sign = det < 0 ? -1 : 1;
-    const rotation = Math.atan2((p.a * w.c - p.c * w.a) * sign, (p.d * w.a - p.b * w.c) * sign) * DEG;
+    const rotation = Math.atan2((p.a * w.c - p.c * w.a) * sign, (p.d * w.a - p.b * w.c) * sign) * DEG$1;
     const [ux, uy] = noScaleDirection([p.a, p.b, p.c, p.d], rotation);
     decompose(b, ux * w.a + uy * w.c, (ux * w.c - uy * w.a) * flip, ux * w.b + uy * w.d, (ux * w.d - uy * w.b) * flip, rules, "shearX");
     b.rotation = rotation;
@@ -3006,7 +3076,7 @@ function localFromWorld(b, p, w, rules = RUNTIME_SOLVER_RULES) {
       [la, lb, lc, ld] = [(cd * w.a - cb * w.c) / cdet, (cd * w.b - cb * w.d) / cdet, (ca * w.c - cc * w.a) / cdet, (ca * w.d - cc * w.b) / cdet];
     }
     decompose(b, la, lc, lb, ld, rules);
-    b.rotation = (b.rotation ?? 0) + Math.atan2(p.c, p.a) * DEG;
+    b.rotation = (b.rotation ?? 0) + Math.atan2(p.c, p.a) * DEG$1;
     return;
   } else {
     const [ia, ib, ic, id] = [p.d * pid, p.b * pid, p.c * pid, p.a * pid];
@@ -3021,12 +3091,12 @@ function decompose(b, la, lc, lb, ld, rules, xAngleIn = "rotation") {
     b.scaleX = 0;
     b.scaleY = yLength;
     b.shearY = 0;
-    b.rotation = !rules.readBackCollapsed || yLength > 1e-5 ? Math.atan2(ld, lb) * DEG - 90 : 0;
+    b.rotation = !rules.readBackCollapsed || yLength > 1e-5 ? Math.atan2(ld, lb) * DEG$1 - 90 : 0;
     return;
   }
-  const xAngle = Math.atan2(lc, la) * DEG;
+  const xAngle = Math.atan2(lc, la) * DEG$1;
   const det = la * ld - lb * lc;
-  let yAngle = Math.atan2(ld, lb) * DEG;
+  let yAngle = Math.atan2(ld, lb) * DEG$1;
   if (xAngleIn === "rotation") b.rotation = xAngle;
   else b.shearX = xAngle;
   b.scaleX = sx;
@@ -3055,7 +3125,7 @@ function solveOne(state, c, frame2 = null) {
     const k = Math.abs(pa * pd - pb * pc) / Math.max(state.rules.ikXAxisFloor, pa * pa + pc * pc);
     pb = -pc * k;
     pd = pa * k;
-    turn = Math.atan2(pc, pa) * DEG;
+    turn = Math.atan2(pc, pa) * DEG$1;
     const det = pa * pd - pb * pc;
     const x = t.worldX - p.worldX;
     const y = t.worldY - p.worldY;
@@ -3073,9 +3143,9 @@ function solveOne(state, c, frame2 = null) {
   }
   const rotation = b.rotation ?? 0;
   const scaleX = b.scaleX ?? 1;
-  let r = -(b.shearX ?? 0) - rotation + turn + Math.atan2(ly, lx) * DEG;
+  let r = -(b.shearX ?? 0) - rotation + turn + Math.atan2(ly, lx) * DEG$1;
   if (scaleX < 0) r += 180;
-  b.rotation = rotation + wrap180(r) * c.mix;
+  b.rotation = rotation + wrap180$1(r) * c.mix;
   const len = (b.length ?? 0) * scaleX;
   if ((c.compress || c.stretch) && len > state.rules.ikStretchMinLength) {
     const wx = t.worldX - bw.worldX;
@@ -3085,7 +3155,7 @@ function solveOne(state, c, frame2 = null) {
       const s = (d / len - 1) * c.mix + 1;
       b.scaleX = scaleX * s;
       if (c.scaleY === "uniform") b.scaleY = (b.scaleY ?? 1) * s;
-      else if (c.scaleY === "volume") b.scaleY = volumeScaleY(b.scaleY ?? 1, s);
+      else if (c.scaleY === "volume") b.scaleY = volumeScaleY$1(b.scaleY ?? 1, s);
     }
   }
   return [b.name];
@@ -3158,7 +3228,7 @@ function solveTwo(state, c, frame2 = null) {
         const f = (Math.sqrt(d2) / (l1 + l2) - 1) * c.mix + 1;
         sx *= f;
         if (c.scaleY === "uniform") sy *= f;
-        else if (c.scaleY === "volume") sy = volumeScaleY(sy, f);
+        else if (c.scaleY === "volume") sy = volumeScaleY$1(sy, f);
       }
     } else a2 = Math.acos(cos) * bend;
     const along = l1 + l2 * cos;
@@ -3211,14 +3281,14 @@ function solveTwo(state, c, frame2 = null) {
   const signs = state.rules.ikZeroScaleSignPositive ? (psx < 0 ? -1 : 1) * (psy < 0 ? -1 : 1) : Math.sign(psx) * Math.sign(psy);
   const offset = Math.atan2(cy, cx);
   const parentRotation = parent.rotation ?? 0;
-  const parentChange = (a1 - signs * offset) * DEG + (psx < 0 ? 180 : 0) - parentRotation;
-  parent.rotation = parentRotation + wrap180(parentChange) * c.mix;
+  const parentChange = (a1 - signs * offset) * DEG$1 + (psx < 0 ? 180 : 0) - parentRotation;
+  parent.rotation = parentRotation + wrap180$1(parentChange) * c.mix;
   parent.scaleX = sx;
   parent.scaleY = sy;
-  const childTarget = ((a2 + signs * offset) * DEG - (child.shearX ?? 0)) * signs + (csx < 0 ? 180 : 0);
+  const childTarget = ((a2 + signs * offset) * DEG$1 - (child.shearX ?? 0)) * signs + (csx < 0 ? 180 : 0);
   const childRotation = child.rotation ?? 0;
   child.y = cy;
-  child.rotation = childRotation + wrap180(childTarget - childRotation) * c.mix;
+  child.rotation = childRotation + wrap180$1(childTarget - childRotation) * c.mix;
   return [parent.name];
 }
 function sourceValue(state, c, property) {
@@ -3244,7 +3314,7 @@ function sourceValue(state, c, property) {
   switch (property) {
     case "rotate": {
       const det = w.a * w.d - w.b * w.c;
-      let r = Math.atan2(w.c, w.a) * DEG + ((state.rules.offsetNegatedAtZeroDet ? det > 0 : det >= 0) ? o.rotate : -o.rotate);
+      let r = Math.atan2(w.c, w.a) * DEG$1 + ((state.rules.offsetNegatedAtZeroDet ? det > 0 : det >= 0) ? o.rotate : -o.rotate);
       if (r < 0) r += 360;
       return r;
     }
@@ -3257,13 +3327,13 @@ function sourceValue(state, c, property) {
     case "scaleY":
       return Math.sqrt(w.b * w.b + w.d * w.d) + o.scaleY;
     case "shearY":
-      return (Math.atan2(w.d, w.b) - Math.atan2(w.c, w.a)) * DEG - 90 + o.shearY;
+      return (Math.atan2(w.d, w.b) - Math.atan2(w.c, w.a)) * DEG$1 - 90 + o.shearY;
   }
 }
-function applyWorld(w, property, v, mix, additive, rules) {
+function applyWorld$1(w, property, v, mix, additive, rules) {
   switch (property) {
     case "rotate": {
-      let r = additive ? v * RAD : v * RAD - Math.atan2(w.c, w.a);
+      let r = additive ? v * RAD$1 : v * RAD$1 - Math.atan2(w.c, w.a);
       if (r > RUNTIME_PI) r -= 2 * RUNTIME_PI;
       else if (r < -RUNTIME_PI) r += 2 * RUNTIME_PI;
       r *= mix;
@@ -3295,7 +3365,7 @@ function applyWorld(w, property, v, mix, additive, rules) {
     case "shearY": {
       const yAngle = Math.atan2(w.d, w.b);
       const xAngle = Math.atan2(w.c, w.a);
-      let r = additive && !rules.additiveShearRightAngle ? v * RAD : (v + 90) * RAD - (additive ? 90 * RAD : yAngle - xAngle);
+      let r = additive && !rules.additiveShearRightAngle ? v * RAD$1 : (v + 90) * RAD$1 - (additive ? 90 * RAD$1 : yAngle - xAngle);
       if (!additive) r = r > RUNTIME_PI ? r - 2 * RUNTIME_PI : r < -RUNTIME_PI ? r + 2 * RUNTIME_PI : r;
       const angle = yAngle + r * mix;
       const s = Math.sqrt(w.b * w.b + w.d * w.d);
@@ -3333,7 +3403,7 @@ function solveTransform(state, c) {
         }
         applied = true;
         if (c.localTarget) applyLocal(b, to.property, v, mix, c.additive);
-        else applyWorld(w, to.property, v, mix, c.additive, state.rules);
+        else applyWorld$1(w, to.property, v, mix, c.additive, state.rules);
       }
     }
     if (!applied) continue;
@@ -3917,7 +3987,7 @@ function valuesAt(keys, t, plant) {
   const channel2 = plant.channel ?? channelAt;
   return keys[index].values.map((_v, c) => channel2(keys, index, c, t));
 }
-function keyAt(keys, t, plant) {
+function keyAt$1(keys, t, plant) {
   const index = (plant.search ?? keyIndexAt)(keys, t);
   return index < 0 ? null : keys[index];
 }
@@ -3938,7 +4008,7 @@ function posedBones(doc, timelines, t, plant = {}) {
     const bone2 = { ...setup };
     for (const tl of target.timelines) {
       if (tl.kind === "inherit") {
-        const key = keyAt(tl.keys, t, plant);
+        const key = keyAt$1(tl.keys, t, plant);
         if (key === null) {
           if (setup.inheritMode === void 0) delete bone2.inheritMode;
           else bone2.inheritMode = setup.inheritMode;
@@ -4066,28 +4136,29 @@ function adjustLocals(doc, bones, adjust, context) {
     }
   }, context);
 }
-const clamp01$1 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const clamp01$2 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function posedSlots(doc, timelines, t, plant = {}, sliders = [], placeholders) {
-  const colour = plant.colour ?? readColour;
+  const stated = viewColours(doc);
+  const colour = plant.colour ?? stated;
   const byName = new Map(timelines.slots.map((s) => [s.name, s]));
   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 setupLight = slot.color === void 0 ? WHITE : colour(slot.color);
+    const light = [setupLight[0], setupLight[1], setupLight[2], setupLight[3]];
+    const setupDark = slot.dark === void 0 ? null : stated(slot.dark);
     const dark = setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]];
     for (const tl of live ? byName.get(slot.name)?.timelines ?? [] : []) {
       if (tl.kind === "attachment") {
-        const key = keyAt(tl.keys, t, plant);
+        const key = keyAt$1(tl.keys, t, plant);
         placeholder = key === null ? slot.setup : key.name ?? null;
         continue;
       }
       const v = valuesAt(tl.keys, t, plant);
-      const setupLight = slot.color === void 0 ? [1, 1, 1, 1] : colour(slot.color);
       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$1(v[i]);
-        else if (dark !== null && setupDark !== null) dark[at - 4] = v === null ? setupDark[at - 4] : clamp01$1(v[i]);
+        if (at < 4) light[at] = v === null ? setupLight[at] : clamp01$2(v[i]);
+        else if (dark !== null && setupDark !== null) dark[at - 4] = v === null ? setupDark[at - 4] : clamp01$2(v[i]);
       });
     }
     return { placeholder, light, dark };
@@ -4131,50 +4202,60 @@ function slotRowsFrom(doc, plant, sliders, placeholders, baseOf) {
   }
   return { rows, conflicts };
 }
-function posedBoneWorld(doc, timelines, t, plant = {}, constraints, sliders, step) {
-  const posed = posedBoneStep(doc, timelines, t, plant, constraints, sliders, step);
-  return { rows: stepRows(posed), world: posed.world };
-}
 function posedBoneWorldAlone(doc, timelines, t, plant, constraints, sliders, step) {
   return posedBoneStep(doc, timelines, t, plant, constraints, sliders, step).world;
 }
-function stepRows(posed) {
-  if (posed.rows !== void 0) return posed.rows;
-  const { world, active, round } = posed;
-  posed.rows = posed.bones.map((b) => {
-    const w = world.get(b.name);
-    return [b.name, round(w.worldX), round(w.worldY), round(w.a), round(w.b), round(w.c), round(w.d), active.has(b.name) ? 1 : 0, b.parent ?? null];
-  });
-  return posed.rows;
-}
 function posedBoneStep(doc, timelines, t, plant, constraints, sliders, step) {
+  const stage = plant.stage;
+  if (stage !== void 0) stage.begin("timeline");
   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);
+  if (stage !== void 0) stage.end("timeline");
+  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?.adjustment !== void 0) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
-  let world = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (step?.adjustment !== void 0) {
+    if (stage !== void 0) stage.begin("timeline");
+    adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
+    if (stage !== void 0) stage.end("timeline");
+  }
+  if (stage !== void 0) stage.begin("world");
+  const initialWorld = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (stage !== void 0) stage.end("world");
+  let world = initialWorld;
   if (constraints !== void 0) {
+    if (stage !== void 0) stage.begin("constraints");
     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;
-    world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(records) : records, previous, sliders, void 0, void 0, solverRules(plant.solver));
+    world = applyConstraints(bones, initialWorld, active, plant.constraints ? plant.constraints(records) : records, previous, sliders, void 0, void 0, solverRules(plant.solver));
+    if (stage !== void 0) stage.end("constraints");
   }
   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 stage = plant.stage;
   const active = activeBones(doc);
-  if (step.adjustment !== void 0) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
-  let world = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (step.adjustment !== void 0) {
+    if (stage !== void 0) stage.begin("timeline");
+    adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
+    if (stage !== void 0) stage.end("timeline");
+  }
+  if (stage !== void 0) stage.begin("world");
+  const initialWorld = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (stage !== void 0) {
+    stage.end("world");
+    stage.begin("constraints");
+  }
   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));
+  const world = applyConstraints(bones, initialWorld, active, plant.constraints ? plant.constraints(stepped) : stepped, null, sliders, step.ctx, void 0, solverRules(plant.solver));
+  if (stage !== void 0) stage.end("constraints");
   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 steppedLocalsWorld(doc, bones, plant, sliders, step) {
+  return steppedLocals(doc, bones, plant, () => constraintRecords(doc), [], 0, sliders, step).world;
 }
 function pathDeformed(doc, records, timelines, t, plant) {
   if (timelines.attachments.every((a) => a.deform === null)) return records;
@@ -4806,6 +4887,24 @@ function readColour(hex) {
   const channel2 = (i) => Number.parseInt(hex.slice(2 * i, 2 * i + 2), 16) / 255;
   return [channel2(0), channel2(1), channel2(2), hex.length === 8 ? channel2(3) : 1];
 }
+const coloursOfView = /* @__PURE__ */ new WeakMap();
+function viewColours(doc) {
+  let kept = coloursOfView.get(doc);
+  if (kept === void 0) {
+    kept = /* @__PURE__ */ new Map();
+    coloursOfView.set(doc, kept);
+  }
+  const colours = kept;
+  return (hex) => {
+    let c = colours.get(hex);
+    if (c === void 0) {
+      c = readColour(hex);
+      colours.set(hex, c);
+    }
+    return c;
+  };
+}
+const WHITE = [1, 1, 1, 1];
 function readBlend(slot) {
   if (slot.blend === void 0) return "Normal";
   const mode = foldBlend(slot.blend);
@@ -5017,7 +5116,7 @@ function rawBones(doc, world) {
 }
 function drawnGeometry(doc, shown, world, order, plant, mode) {
   const draw = drawWalkOf(doc, order, plant);
-  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, mode.loop && mode.live !== true && plant.through === void 0 ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
+  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices, deformedVertices: plant.deformedVertices }, mode.loop && mode.live !== true && plant.through === void 0 ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
   if (geometry.attachments === null) throw new CoreInputError(`the raw pose leaves the attachments out: ${geometry.attachmentsWhy}`);
   if (geometry.drawnClipped === null) throw new CoreInputError(`the raw pose leaves the clipped triangles out: ${geometry.drawnClippedWhy}`);
   return { rows: geometry.attachments, clips: geometry.clips, drawnClipped: geometry.drawnClipped };
@@ -5030,9 +5129,16 @@ function allNumbers(values2) {
   return true;
 }
 function rawDrawn(doc, shown, world, order, plant, mode = RAW_MODE) {
+  const stage = plant.stage;
+  if (stage !== void 0) stage.begin("geometry");
   const geometry = drawnGeometry(doc, shown, world, order, plant, mode);
+  if (stage !== void 0) {
+    stage.end("geometry");
+    stage.begin("readout");
+  }
   const rows = geometry.rows;
   const drawn = [];
+  const stated = viewColours(doc);
   let k = 0;
   for (const s of shown) {
     const g = s.geometry;
@@ -5040,7 +5146,8 @@ function rawDrawn(doc, shown, world, order, plant, mode = RAW_MODE) {
     const row = rows[k++];
     if (row === void 0 || row[0] !== s.slot) throw new CoreInputError(`slot "${s.slot}": the attachment rows are not in the shown records' order`);
     const record = doc.skins.find((x) => x.name === s.skin)?.attachments[s.slot]?.[s.placeholder];
-    const colour = record?.color === void 0 ? [1, 1, 1, 1] : readColour(record.color);
+    const read = record?.color === void 0 ? WHITE : stated(record.color);
+    const colour = [read[0], read[1], read[2], read[3]];
     let uvs;
     let triangles;
     let hull = null;
@@ -5058,6 +5165,7 @@ function rawDrawn(doc, shown, world, order, plant, mode = RAW_MODE) {
   }
   const clips = geometry.clips.map((c) => [c[0], c[1], c[2], numbersOf(c[3], `clip vertex of slot "${c[0]}"`, mode)]);
   const clipped = geometry.drawnClipped.map((c) => [c[0], c[1], c[2], numbersOf(c[3], `clipped vertex of slot "${c[0]}"`, mode), numbersOf(c[4], `clipped uv of slot "${c[0]}"`, mode), c[5]]);
+  if (stage !== void 0) stage.end("readout");
   return { drawn, clips, clipped };
 }
 function poseRawSetup(doc, plant = {}) {
@@ -5155,12 +5263,15 @@ function loopedTime(trackTime, duration) {
   return duration === 0 ? 0 : trackTime % duration;
 }
 const RAW_SHAPE = {
-  rows: true,
   setup: (doc, world, slots, drawOrder, shown, plant, mode) => ({ trackTime: 0, animationTime: 0, bones: rawBones(doc, world), slots, drawOrder, ...rawDrawn(doc, shown, world, drawOrder, plant, mode), events: [], shown: drawOrderOf(shown, drawOrder) }),
   step: (doc, p, plant, mode) => {
     const drawn = rawDrawn(doc, p.shown, p.world, p.drawOrder, plant, mode);
+    const stage = plant.stage;
+    if (stage !== void 0) stage.begin("readout");
     const events = p.events();
-    return { trackTime: p.trackTime, animationTime: p.animationTime, bones: rawBones(doc, p.world), slots: p.slots, drawOrder: p.drawOrder, ...drawn, events, shown: p.shown };
+    const pose = { trackTime: p.trackTime, animationTime: p.animationTime, bones: rawBones(doc, p.world), slots: p.slots, drawOrder: p.drawOrder, ...drawn, events, shown: p.shown };
+    if (stage !== void 0) stage.end("readout");
+    return pose;
   }
 };
 function animationOf(doc, animation) {
@@ -5197,7 +5308,7 @@ function stepWalk(track, dt, first = false) {
   const keys = anim.timelines.events;
   const adjustment = adjust === void 0 ? void 0 : { callback: adjust, context: { trackTime, animation: anim.name, globalTime: trackTime } };
   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, adjustment }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }),
+    world: (sliders) => posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }),
     slots: (sliders, placeholders) => posedSlots(doc, anim.timelines, t, raw, sliders, placeholders),
     drawOrder: anim.timelines.drawOrder,
     at: t,
@@ -5208,20 +5319,30 @@ function stepWalk(track, dt, first = false) {
   return pose;
 }
 function poseStepFrom(doc, plant, resolve, shape, mode, ctx, first, trackTime, animationTime, posers) {
+  const stage = plant.stage;
   const sliders = [];
   const world = posers.world(sliders);
   if (first) ctx.phase = "update";
+  if (stage !== void 0) stage.begin("readout");
   const placeholders = /* @__PURE__ */ new Map();
   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, posers.drawOrder, posers.at) ?? doc.slots.map((_s, k) => k);
+  const baseOrder = evalOrder(doc.slots.length, posers.drawOrder, posers.at) ?? doc.slots.map((_s, k) => k);
+  let order = baseOrder;
   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);
+  if (stage !== void 0) {
+    stage.end("readout");
+    stage.begin("timeline");
+  }
   const states = attachmentStates(doc, resolve, placeholders, posers.sample, sliders, plant, posers.mixed);
+  if (stage !== void 0) stage.end("timeline");
   if (states.why.length > 0) throw new CoreInputError(`the raw walk leaves the attachments out: ${states.why.join("; ")}`);
+  if (stage !== void 0) stage.begin("readout");
   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));
+  if (stage !== void 0) stage.end("readout");
   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);
 }
@@ -5474,7 +5595,8 @@ function trackComplete(e) {
   return e.trackTime;
 }
 const signum = (v) => v > 0 ? 1 : v < 0 ? -1 : 0;
-const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const clamp01$1 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+const NO_DARK = [0, 0, 0];
 const ATTACH_NONE = 0;
 const ATTACH_SETUP = 1;
 const ATTACH_RETAIN = 2;
@@ -5486,12 +5608,15 @@ class Pose {
     this.resolved = /* @__PURE__ */ new Map();
     this.bones = [...doc.bones];
     this.active = activeBones(doc);
-    const colour = plant.colour ?? readColour;
+    const stated = viewColours(doc);
+    this.stated = stated;
+    const colour = plant.colour ?? stated;
     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 };
+      const setupDark = slot.dark === void 0 ? null : stated(slot.dark);
+      const setupLight = slot.color === void 0 ? WHITE : colour(slot.color);
+      return { placeholder: slot.setup, light: [setupLight[0], setupLight[1], setupLight[2], setupLight[3]], 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. */
@@ -6068,11 +6193,10 @@ class Mixer {
     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 sl = slot.color === void 0 ? WHITE : (this.plant.colour ?? pose.stated)(slot.color);
+    const sd = slot.dark === void 0 ? NO_DARK : pose.stated(slot.dark);
     const clampLight = () => {
-      for (let k = 0; k < 4; k++) l[k] = clamp01(l[k]);
+      for (let k = 0; k < 4; k++) l[k] = clamp01$1(l[k]);
     };
     const v = this.values(tl.keys, time);
     const channels = SLOT_COLOUR_TIMELINES[tl.kind].channels.length;
@@ -6100,7 +6224,7 @@ class Mixer {
         }
         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]);
+        for (let k = 0; k < 3; k++) l[k] = clamp01$1(rgb[k]);
         return;
       }
       case "alpha": {
@@ -6111,7 +6235,7 @@ class Mixer {
         }
         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);
+        l[3] = clamp01$1(a);
         return;
       }
       case "rgba2":
@@ -6149,9 +6273,9 @@ class Mixer {
               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++) l[k] = clamp01$1(light[k]);
         }
-        for (let k = 0; k < 3; k++) d[k] = clamp01(dark[k]);
+        for (let k = 0; k < 3; k++) d[k] = clamp01$1(dark[k]);
         return;
       }
     }
@@ -6382,7 +6506,10 @@ class Tracks {
     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;
+      const stage = this.plant.stage;
+      if (stage !== void 0) stage.begin("timeline");
       this.mixer.update(dt);
+      if (stage !== void 0) stage.end("timeline");
       const pose = this.pose(dt, false);
       this.steps = n;
       return pose;
@@ -6403,6 +6530,8 @@ class Tracks {
     const ctx = path.ctx;
     const before = ctx.time;
     ctx.time += this.clock === void 0 ? dt : this.clock(dt);
+    const stage = this.plant.stage;
+    if (stage !== void 0) stage.begin("timeline");
     const pose = new Pose(doc, this.plant);
     const animationTime = this.mixer.apply(pose);
     const entry = this.mixer.tracks[0] ?? null;
@@ -6411,6 +6540,7 @@ class Tracks {
       context: { trackTime: entry?.trackTime ?? null, animation: entry?.anim.name ?? null, globalTime: this.time }
     };
     const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));
+    if (stage !== void 0) stage.end("timeline");
     return path.step(first, this.time, animationTime, {
       world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjustment }),
       slots: (sliders, placeholders) => slotRowsFrom(doc, path.raw, sliders, placeholders, (_slot, _live) => {
@@ -6737,6 +6867,15 @@ async function unpackRegions(pages, pageImages, options = {}) {
 function revokeRegions(images) {
   for (const image of images.values()) revokeOwned(image.url);
 }
+const triangleReadSources = /* @__PURE__ */ new WeakMap();
+function triangleReadSource(source) {
+  let kept = triangleReadSources.get(source);
+  if (kept === void 0) {
+    kept = Object.isFrozen(source) ? Array.from(source) : source;
+    triangleReadSources.set(source, kept);
+  }
+  return kept;
+}
 const BLEND_FACTORS = {
   Normal: [
     1,
@@ -6938,7 +7077,8 @@ class MeshGlBlitter {
     const data = this.vertexData;
     let f = 0;
     for (let i = 0; i < jobs.length; i++) {
-      const { vertices, uvs, triangles, ratio } = jobs[i];
+      const { vertices, uvs, ratio } = jobs[i];
+      const triangles = triangleReadSource(jobs[i].triangles);
       const ox = packX[i];
       const oy = packY[i];
       for (let t = 0; t < triangles.length; t++) {
@@ -7461,7 +7601,8 @@ class DomRenderer {
    * clipping attachment, an inactive bone, a kind the DOM tier does not draw —
    * are hidden, their elements kept for when they draw again.
    */
-  render(frame2) {
+  render(input) {
+    const frame2 = renderFrameOf(input);
     this.clipCount = 0;
     this.clipSkipCount = 0;
     this.clipWriteCount = 0;
@@ -7703,6 +7844,7 @@ class DomRenderer {
     ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
     const uw = page.width;
     const uh = page.height;
+    triangles = triangleReadSource(triangles);
     for (let t = 0; t < triangles.length; t += 3) {
       const i0 = triangles[t] * 2;
       const i1 = triangles[t + 1] * 2;
@@ -8215,7 +8357,8 @@ class CanvasRenderer {
     this.growTo(box.x, -(box.y + box.height), box.x + box.width, -box.y);
   }
   /** Draws one frame. */
-  render(frame2) {
+  render(input) {
+    const frame2 = renderFrameOf(input);
     this.drawCalls = 0;
     this.blendFlushes = 0;
     this.trianglesDrawn = 0;
@@ -8444,7 +8587,8 @@ class CanvasRenderer {
       if (!page) continue;
       const piece = this.piecesOf(slot, clips);
       if (!piece) continue;
-      const { vertices, uvs, triangles } = piece;
+      const { vertices, uvs } = piece;
+      const triangles = triangleReadSource(piece.triangles);
       const count = triangles.length;
       if (count === 0) continue;
       if (!this.glPages.has(page) && blitter) {
@@ -8519,7 +8663,8 @@ class CanvasRenderer {
       }
       ctx.globalAlpha = Math.max(0, Math.min(1, slot.tint[3]));
       this.drawCalls++;
-      const { vertices, uvs, triangles } = piece;
+      const { vertices, uvs } = piece;
+      const triangles = triangleReadSource(piece.triangles);
       if (slot.kind === "region" && vertices === slot.corners) {
         const c = vertices;
         const sx0 = uvs[2] * uw, sy0 = uvs[3] * uh;
@@ -8832,6 +8977,1383 @@ async function loadModel(options) {
     }
   };
 }
+const CURVE_LINEAR = 0;
+const CURVE_STEPPED = 1;
+const CURVE_BEZIER = 2;
+const POLYLINE = 2 * (BEZIER_PIECES + 1);
+function compileCurve(keys, channels) {
+  const n = keys.length;
+  const times2 = new Float64Array(n);
+  const values2 = new Float64Array(n * channels);
+  const kinds = new Uint8Array(n);
+  const polylines = new Float64Array(n * channels * POLYLINE);
+  for (let i = 0; i < n; i++) {
+    const a = keys[i];
+    times2[i] = a.time;
+    for (let c = 0; c < channels; c++) values2[i * channels + c] = a.values[c];
+    const curve = a.curve;
+    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];
+    for (let c = 0; c < channels; c++) {
+      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 o = (i * channels + c) * POLYLINE;
+      polylines[o] = a.time;
+      polylines[o + 1] = a.values[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];
+    }
+  }
+  return { keys: n, channels, times: times2, values: values2, kinds, polylines };
+}
+function keyAt(curve, cursors, slot, t) {
+  const times2 = curve.times;
+  let i = cursors[slot];
+  while (i >= 0 && times2[i] > t) i--;
+  while (i + 1 < curve.keys && times2[i + 1] <= t) i++;
+  cursors[slot] = i;
+  return i;
+}
+function channelValue(curve, i, c, t) {
+  const ch = curve.channels;
+  const values2 = curve.values;
+  const v0 = values2[i * ch + c];
+  if (i + 1 >= curve.keys) return v0;
+  const kind = curve.kinds[i];
+  if (kind === CURVE_STEPPED) return v0;
+  if (kind === CURVE_LINEAR) {
+    const t0 = curve.times[i];
+    return v0 + (t - t0) / (curve.times[i + 1] - t0) * (values2[(i + 1) * ch + c] - v0);
+  }
+  const p = curve.polylines;
+  const o = (i * ch + c) * POLYLINE;
+  let q = 2;
+  while (q < POLYLINE - 2 && p[o + q] < t) q += 2;
+  const x0 = p[o + q - 2];
+  const y0 = p[o + q - 1];
+  return y0 + (t - x0) / (p[o + q] - x0) * (p[o + q + 1] - y0);
+}
+const RUNTIME_STAGE = 1;
+function missingText(m) {
+  return `${m.feature}: ${m.detail}${m.animation === null ? "" : ` (animation "${m.animation}")`}`;
+}
+class RuntimeRefusal extends Error {
+  constructor(missing) {
+    super(`not posed by the runtime poser (stage ${RUNTIME_STAGE}), ${missing.length} construct(s) missing: ${missing.map(missingText).join("; ")}`);
+    this.missing = missing;
+  }
+}
+class RuntimeInputError extends Error {
+}
+const L_X = 0;
+const L_Y = 1;
+const L_ROTATION = 2;
+const L_SCALE_X = 3;
+const L_SCALE_Y = 4;
+const L_SHEAR_X = 5;
+const L_SHEAR_Y = 6;
+const LOCALS = 7;
+const W_A = 0;
+const W_B = 1;
+const W_C = 2;
+const W_D = 3;
+const W_X = 4;
+const W_Y = 5;
+const WORLDS = 6;
+const MODE_NORMAL = 0;
+const MODE_ONLY_TRANSLATION = 1;
+const MODE_NO_ROTATION_OR_REFLECTION = 2;
+const MODE_NO_SCALE = 3;
+const MODE_NO_SCALE_OR_REFLECTION = 4;
+const MODE_CODES = { normal: MODE_NORMAL, onlyTranslation: MODE_ONLY_TRANSLATION, noRotationOrReflection: MODE_NO_ROTATION_OR_REFLECTION, noScale: MODE_NO_SCALE, noScaleOrReflection: MODE_NO_SCALE_OR_REFLECTION };
+const DRAW_NONE = 0;
+const DRAW_REGION = 1;
+const DRAW_MESH = 2;
+const DRAW_WEIGHTED = 3;
+const SCALE_Y_NONE = 0;
+const SCALE_Y_UNIFORM = 1;
+const SCALE_Y_VOLUME = 2;
+const IK_BEND_POSITIVE = 1;
+const IK_COMPRESS = 2;
+const IK_STRETCH = 4;
+const RAD = RUNTIME_PI / 180;
+const BONE_KINDS = {
+  rotate: [[L_ROTATION, 0]],
+  translate: [[L_X, 0], [L_Y, 0]],
+  translatex: [[L_X, 0]],
+  translatey: [[L_Y, 0]],
+  scale: [[L_SCALE_X, 1], [L_SCALE_Y, 1]],
+  scalex: [[L_SCALE_X, 1]],
+  scaley: [[L_SCALE_Y, 1]],
+  shear: [[L_SHEAR_X, 0], [L_SHEAR_Y, 0]],
+  shearx: [[L_SHEAR_X, 0]],
+  sheary: [[L_SHEAR_Y, 0]]
+};
+const COLOUR_CHANNELS = { rgba: [0, 1, 2, 3], rgb: [0, 1, 2], alpha: [3] };
+class Refusals {
+  constructor(admitted) {
+    this.admitted = admitted;
+    this.model = [];
+    this.byAnimation = /* @__PURE__ */ new Map();
+  }
+  /** Records the construct unless a plant admits it. The caller poses the construct as absent either way. */
+  note(feature, detail, animation = null) {
+    if (this.admitted.has(feature)) return;
+    const m = { feature, detail, animation };
+    if (animation === null) this.model.push(m);
+    else {
+      const list = this.byAnimation.get(animation) ?? [];
+      list.push(m);
+      this.byAnimation.set(animation, list);
+    }
+  }
+}
+function compileRuntime(doc, options = {}, plant = {}) {
+  const refusals = new Refusals(new Set(plant.admit ?? []));
+  const ignoreEvents = (options.ignore ?? []).includes("events");
+  const absentWhy = constraintsAbsentWhy(doc);
+  if (absentWhy !== null) refusals.note("oracle-absent", `the oracle leaves the bones out: ${absentWhy}`);
+  const nb = doc.bones.length;
+  const boneIndex2 = new Map(doc.bones.map((b, i) => [b.name, i]));
+  const indexOf = (name) => {
+    const i = boneIndex2.get(name);
+    if (i === void 0) throw new RuntimeInputError(`bone "${name}" is not a bone of this document (readModel refuses it first)`);
+    return i;
+  };
+  const active = activeBones(doc);
+  const parents = new Int32Array(nb);
+  const modes = new Uint8Array(nb);
+  const activeFlags = new Uint8Array(nb);
+  const lengths = new Float64Array(nb);
+  const setup = new Float64Array(nb * LOCALS);
+  doc.bones.forEach((b, i) => {
+    parents[i] = b.parent === void 0 ? -1 : indexOf(b.parent);
+    if (parents[i] >= i) throw new RuntimeInputError(`bone "${b.name}" is listed before its parent (readModel refuses it first)`);
+    const mode = b.inheritMode === void 0 ? "normal" : foldInheritMode(b.inheritMode);
+    if (mode === null) throw new RuntimeInputError(`bone "${b.name}": inheritMode ${JSON.stringify(b.inheritMode)} is no mode (readModel refuses it first)`);
+    modes[i] = MODE_CODES[mode];
+    activeFlags[i] = active.has(b.name) ? 1 : 0;
+    lengths[i] = b.length ?? 0;
+    const o = i * LOCALS;
+    setup[o + L_X] = b.x ?? 0;
+    setup[o + L_Y] = b.y ?? 0;
+    setup[o + L_ROTATION] = b.rotation ?? 0;
+    setup[o + L_SCALE_X] = b.scaleX ?? 1;
+    setup[o + L_SCALE_Y] = b.scaleY ?? 1;
+    setup[o + L_SHEAR_X] = b.shearX ?? 0;
+    setup[o + L_SHEAR_Y] = b.shearY ?? 0;
+  });
+  if (plant.setupNudge !== void 0) setup[indexOf(plant.setupNudge.bone) * LOCALS + plant.setupNudge.field] += plant.setupNudge.delta;
+  const lists = doc.bones.map(() => []);
+  for (let k = 0; k < nb; k++) for (let at = k; at >= 0; at = parents[at]) lists[at].push(k);
+  const subtreeStart = new Int32Array(nb + 1);
+  const flat = [];
+  for (let k = 0; k < nb; k++) {
+    subtreeStart[k] = flat.length;
+    for (const x of lists[k]) flat.push(x);
+  }
+  subtreeStart[nb] = flat.length;
+  const constraints = [];
+  for (const c of doc.constraints) if (c.kind === "path" || c.kind === "physics" || c.kind === "slider") refusals.note(`${c.kind}-constraint`, `${c.kind} constraint "${c.name}"`);
+  for (const r of constraintRecords(doc)) {
+    if (r.kind !== "ik" && r.kind !== "transform") continue;
+    const applied = constraintInactiveWhy(r, active) === null;
+    const bones = Int32Array.from(r.bones.map(indexOf));
+    if (applied && r.bones.some((b) => !active.has(b))) refusals.note("inactive-constrained-bone", `${r.kind} constraint "${r.name}" names bone(s) ${r.bones.filter((b) => !active.has(b)).map((b) => `"${b}"`).join(", ")}, which the view leaves inactive — what the oracle writes there depends on the pass before`);
+    const index = constraints.length;
+    if (r.kind === "ik") constraints.push(compileIk(r, index, applied, bones, indexOf));
+    else {
+      if (r.localSource || r.localTarget) refusals.note("local-transform", `transform constraint "${r.name}" ${[r.localSource ? "reads local values (localSource)" : "", r.localTarget ? "writes local values (localTarget)" : ""].filter((x) => x !== "").join(" and ")}`);
+      if (r.additive) refusals.note("additive-transform", `transform constraint "${r.name}" is additive`);
+      const t = compileTransform(r, index, applied, bones, indexOf);
+      if (applied) {
+        for (let k = 0; k < bones.length; k++) {
+          const m = modes[bones[k]];
+          if (parents[bones[k]] >= 0 && (m === MODE_NO_SCALE || m === MODE_NO_SCALE_OR_REFLECTION)) refusals.note("noscale-world-target", `transform constraint "${r.name}" moves bone "${r.bones[k]}" in world space, and its local values are read back in a noScale mode`);
+        }
+      }
+      constraints.push(t);
+    }
+  }
+  const attachments = [];
+  let vertexCount = 0;
+  const sourceOf = sourceOfDoc(doc);
+  const attachmentView = plant.attachmentSkin === void 0 ? doc : underSkin(doc, plant.attachmentSkin);
+  const resolvedBySlot = doc.slots.map(() => /* @__PURE__ */ new Map());
+  const resolve = (si, placeholder, animation) => {
+    const cache = resolvedBySlot[si];
+    let kept = cache.get(placeholder);
+    if (kept === void 0) {
+      kept = resolveRecord(si, placeholder);
+      cache.set(placeholder, kept);
+    }
+    if (kept.missing !== null) refusals.note(kept.missing[0], kept.missing[1], animation);
+    return kept.index;
+  };
+  const resolveRecord = (si, placeholder) => {
+    const slot = doc.slots[si];
+    const shown = placeholder === null ? null : shownAttachment(attachmentView, slot, placeholder);
+    if (shown === null) return { index: -1, missing: null };
+    if ("conflict" in shown) return { index: -1, missing: ["skin-conflict", `slot "${slot.name}" placeholder "${placeholder}" is filled by skins that disagree`] };
+    const row = shownRow(shown);
+    const g = shown.record.geometry;
+    const at = { slot: si, name: row.name, skin: shown.skin, placeholder: shown.placeholder, path: CORE_REGION_KINDS.has(shown.record.kind) ? row.path : null, bone: indexOf(slot.bone), offset: vertexCount };
+    let made = null;
+    let missing = null;
+    if (g?.kind === "clipping") missing = ["clipping", `slot "${slot.name}" shows clipping attachment "${row.name}"`];
+    else if (g?.kind === "region") {
+      const r = g.region;
+      if (r.atlas === null) missing = ["null-atlas-region", `slot "${slot.name}" shows region "${row.name}", whose atlas rectangle the model states as null`];
+      else {
+        const W = r.width;
+        const H = r.height;
+        const sx = r.scaleX ?? 1;
+        const sy = r.scaleY ?? 1;
+        const rect = r.atlas;
+        const kx = W / rect.originalWidth * sx;
+        const ky = H / rect.originalHeight * sy;
+        const x1 = -W / 2 * sx + rect.offsetX * kx;
+        const y1 = -H / 2 * sy + rect.offsetY * ky;
+        const x2 = x1 + rect.width * kx;
+        const y2 = y1 + rect.height * ky;
+        const angle = (r.rotation ?? 0) * RAD;
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const x = r.x ?? 0;
+        const y = r.y ?? 0;
+        const local = new Float64Array(8);
+        const corners = [x1, y1, x1, y2, x2, y2, x2, y1];
+        for (let k = 0; k < 8; k += 2) {
+          const px = corners[k];
+          const py = corners[k + 1];
+          local[k] = px * cos + x - py * sin;
+          local[k + 1] = py * cos + y + px * sin;
+        }
+        made = vertexAttachment(at, DRAW_REGION, local, 8);
+      }
+    } else if (g?.kind === "mesh" || g?.kind === "linkedmesh") {
+      const source = g.kind === "mesh" ? g.vertices : sourceOf(g.skin, g.slot, g.source);
+      if (typeof source === "string") throw new RuntimeInputError(`slot "${slot.name}": ${source} (readModel refuses it first)`);
+      made = meshAttachment(at, source, indexOf, plant.bindingIndex, nb);
+    }
+    if (made === null) made = vertexAttachment(at, DRAW_NONE, new Float64Array(0), 0);
+    attachments.push(made);
+    vertexCount += made.count;
+    return { index: attachments.length - 1, missing };
+  };
+  const slots = doc.slots.map((slot, si) => {
+    const bone2 = indexOf(slot.bone);
+    const light = slot.color === void 0 ? [1, 1, 1, 1] : readColour(slot.color);
+    return {
+      name: slot.name,
+      bone: bone2,
+      // A slot on a bone the view leaves inactive is not animated (`slotTimelinesApply` in src/core/skins.ts).
+      live: active.has(slot.bone),
+      setupAttachment: resolve(si, slot.setup, null),
+      light: Float64Array.from(light),
+      dark: slot.dark === void 0 ? null : Float64Array.from(readColour(slot.dark).slice(0, 3)),
+      blend: readBlend(slot)
+    };
+  });
+  const slotIndex = new Map(doc.slots.map((s, i) => [s.name, i]));
+  const animations = /* @__PURE__ */ new Map();
+  const refused = [];
+  let cursorMax = 0;
+  for (const anim of doc.animations) {
+    const compiled = compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, (si, ph) => resolve(si, ph, anim.name));
+    const missing = refusals.byAnimation.get(anim.name);
+    if (missing !== void 0 && missing.length > 0) refused.push({ animation: anim.name, missing });
+    else {
+      animations.set(anim.name, compiled);
+      cursorMax = Math.max(cursorMax, compiled.cursors);
+    }
+  }
+  if (refusals.model.length > 0) throw new RuntimeRefusal(refusals.model);
+  const names = doc.animations.map((a) => a.name);
+  return {
+    eventWrapOffByOne: plant.eventWrapOffByOne === true,
+    restoreEventsFromStart: plant.restoreEventsFromStart === true,
+    doc,
+    boneNames: doc.bones.map((b) => b.name),
+    parents,
+    modes,
+    active: activeFlags,
+    lengths,
+    setup,
+    subtreeStart,
+    subtrees: Int32Array.from(flat),
+    slots,
+    attachments,
+    vertexCount,
+    constraints,
+    animations,
+    refused,
+    cursors: cursorMax,
+    scratch: plant.scratchByBones === true ? Math.max(1, nb) : Math.max(1, nb, ...constraints.map((c) => c.bones.length)),
+    animation(name) {
+      const found = animations.get(name);
+      if (found !== void 0) return found;
+      const no = refused.find((r) => r.animation === name);
+      if (no !== void 0) throw new RuntimeRefusal(no.missing);
+      throw new RuntimeInputError(`animation ${JSON.stringify(name)} is not one of this document's [${names.join(", ")}]`);
+    }
+  };
+}
+const NO_INTS = new Int32Array(0);
+const NO_NUMBERS = new Float64Array(0);
+function vertexAttachment(at, draw, local, count) {
+  return { ...at, draw, local, count, bindingCounts: NO_INTS, bindingBones: NO_INTS, bindingX: NO_NUMBERS, bindingY: NO_NUMBERS, bindingWeights: NO_NUMBERS };
+}
+function meshAttachment(at, vertices, indexOf, rewrite, bones) {
+  if (!vertices.weighted) {
+    const n = vertices.xy.length - vertices.xy.length % 2;
+    const local = new Float64Array(n);
+    for (let i = 0; i < n; i++) local[i] = Math.fround(vertices.xy[i]);
+    return vertexAttachment(at, DRAW_MESH, local, n);
+  }
+  const counts = [];
+  const ids = [];
+  const xs = [];
+  const ys = [];
+  const ws = [];
+  for (const influences of vertices.bindings) {
+    counts.push(influences.length);
+    for (const b of influences) {
+      const i = indexOf(b.bone);
+      ids.push(rewrite === void 0 ? i : rewrite(i, bones));
+      xs.push(Math.fround(b.x));
+      ys.push(Math.fround(b.y));
+      ws.push(Math.fround(b.weight));
+    }
+  }
+  return { ...at, draw: DRAW_WEIGHTED, local: NO_NUMBERS, count: counts.length * 2, bindingCounts: Int32Array.from(counts), bindingBones: Int32Array.from(ids), bindingX: Float64Array.from(xs), bindingY: Float64Array.from(ys), bindingWeights: Float64Array.from(ws) };
+}
+function compileIk(r, index, applied, bones, indexOf) {
+  return {
+    kind: "ik",
+    name: r.name,
+    index,
+    applied,
+    bones,
+    target: indexOf(r.target),
+    scaleY: r.scaleY === "uniform" ? SCALE_Y_UNIFORM : r.scaleY === "volume" ? SCALE_Y_VOLUME : SCALE_Y_NONE,
+    mix: r.mix,
+    softness: r.softness,
+    flags: ikFlags(r.bendPositive, r.compress, r.stretch)
+  };
+}
+function ikFlags(bendPositive, compress, stretch) {
+  return (bendPositive ? IK_BEND_POSITIVE : 0) | (compress ? IK_COMPRESS : 0) | (stretch ? IK_STRETCH : 0);
+}
+function compileTransform(r, index, applied, bones, indexOf) {
+  const fromProperty = [];
+  const fromOffset = [];
+  const toStart = [];
+  const toEnd = [];
+  const toProperty = [];
+  const toOffset = [];
+  const toScale = [];
+  const toMax = [];
+  for (const from of r.properties) {
+    fromProperty.push(TRANSFORM_PROPERTIES.indexOf(from.property));
+    fromOffset.push(from.offset);
+    toStart.push(toProperty.length);
+    for (const to of from.to) {
+      toProperty.push(TRANSFORM_PROPERTIES.indexOf(to.property));
+      toOffset.push(to.offset);
+      toScale.push(to.scale);
+      toMax.push(to.max);
+    }
+    toEnd.push(toProperty.length);
+  }
+  return {
+    kind: "transform",
+    name: r.name,
+    index,
+    applied,
+    bones,
+    source: indexOf(r.source),
+    fromProperty: Int32Array.from(fromProperty),
+    fromOffset: Float64Array.from(fromOffset),
+    toStart: Int32Array.from(toStart),
+    toEnd: Int32Array.from(toEnd),
+    toProperty: Int32Array.from(toProperty),
+    toOffset: Float64Array.from(toOffset),
+    toScale: Float64Array.from(toScale),
+    toMax: Float64Array.from(toMax),
+    offsets: Float64Array.from(TRANSFORM_PROPERTIES.map((p) => r.offsets[p])),
+    mixes: Float64Array.from(TRANSFORM_PROPERTIES.map((p) => r.mixes[p])),
+    clamp: r.clamp
+  };
+}
+function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, resolve) {
+  const tl = anim.timelines;
+  const name = anim.name;
+  let cursors = 0;
+  const deform = tl.attachments.filter((a) => a.deform !== null);
+  const sequence = tl.attachments.filter((a) => a.sequence !== null);
+  if (deform.length > 0) refusals.note("deform-timeline", `${deform.length} deform timeline(s): ${deform.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${deform.length > 3 ? ", …" : ""}`, name);
+  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);
+  const lastBy = (targets) => new Map(targets.map((t) => [t.name, t]));
+  const bones = [];
+  for (const target of lastBy(tl.bones).values()) {
+    const bone2 = boneIndex2.get(target.name);
+    if (bone2 === void 0) continue;
+    for (const t of target.timelines) {
+      if (t.kind === "inherit") {
+        refusals.note("inherit-timeline", `bone "${target.name}" keys its inherit mode`, name);
+        continue;
+      }
+      const spec = BONE_KINDS[t.kind];
+      bones.push({ bone: bone2, curve: compileCurve(t.keys, spec.length), cursor: cursors++, fields: Int32Array.from(spec.map((s) => s[0])), multiply: Uint8Array.from(spec.map((s) => s[1])) });
+    }
+  }
+  const slotTimelines = [];
+  const keyedSlots = [...lastBy(tl.slots).values()].flatMap((target) => {
+    const si = slotIndex.get(target.name);
+    return si === void 0 ? [] : [{ si, target }];
+  }).sort((a, b) => a.si - b.si);
+  for (const { si, target } of keyedSlots) {
+    if (!slots[si].live) continue;
+    for (const t of target.timelines) {
+      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) });
+      }
+    }
+  }
+  const constraintTimelines = constraints.map(() => null);
+  for (const c of constraints) {
+    if (c.kind === "ik") {
+      const keyed = anim.constraints.ik.find((x) => x.name === c.name);
+      if (keyed === void 0) continue;
+      constraintTimelines[c.index] = { constraint: c.index, curve: compileCurve(keyed.keys, 2), cursor: cursors++, flags: Uint8Array.from(keyed.keys.map((k) => ikFlags(k.flags.bendPositive, k.flags.compress, k.flags.stretch))) };
+    } else {
+      const keyed = anim.constraints.transform.find((x) => x.name === c.name);
+      if (keyed === void 0) continue;
+      constraintTimelines[c.index] = { constraint: c.index, curve: compileCurve(keyed.keys, TRANSFORM_PROPERTIES.length), cursor: cursors++, flags: null };
+    }
+  }
+  return { name, duration: tl.duration, bones, 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 }))) };
+}
+const DEG = RUNTIME_DEG;
+const TWO_PI = 2 * RUNTIME_PI;
+const P_ROTATE = 0;
+const P_X = 1;
+const P_Y = 2;
+const P_SCALE_X = 3;
+const P_SCALE_Y = 4;
+function wrap180(r) {
+  return r > 180 ? r - 360 : r <= -180 ? r + 360 : r;
+}
+function volumeScaleY(scaleY, s) {
+  return scaleY / (s < 0.7 ? 0.25 + s * 0.642857 : s);
+}
+const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+class RuntimePose {
+  constructor(model) {
+    this.trackTime = 0;
+    this.time = 0;
+    this.fired = [];
+    this.eventTime = -1;
+    this.current = null;
+    this.w = new Float64Array(WORLDS);
+    this.model = model;
+    const nb = model.boneNames.length;
+    const ns = model.slots.length;
+    const nc = model.constraints.length;
+    this.locals = new Float64Array(nb * LOCALS);
+    this.world = new Float64Array(nb * WORLDS);
+    this.light = new Float64Array(ns * 4);
+    this.shown = new Int32Array(ns);
+    this.vertices = new Float64Array(model.vertexCount);
+    this.cursors = new Int32Array(Math.max(1, model.cursors)).fill(-1);
+    this.ikMix = new Float64Array(nc);
+    this.ikSoftness = new Float64Array(nc);
+    this.ikFlags = new Uint8Array(nc);
+    this.mixes = new Float64Array(nc * 6);
+    this.changed = new Int32Array(model.scratch);
+    this.inWorld = new Int32Array(model.scratch);
+    this.changedMark = new Uint8Array(nb);
+    this.inWorldMark = new Uint8Array(nb);
+    this.below = new Uint8Array(nb);
+    this.visit = new Uint8Array(nb);
+  }
+  /** Borrowed immutable event records, in delivery order, until the next apply/step. */
+  get events() {
+    return this.fired;
+  }
+  /** The animation this pose plays (a covered one: `model.animation` throws a `RuntimeRefusal` for a refused one), from track time 0. */
+  setAnimation(name) {
+    this.current = this.model.animation(name);
+    this.cursors.fill(-1);
+    this.trackTime = 0;
+    this.time = 0;
+    this.eventTime = -1;
+    this.fired.length = 0;
+  }
+  /**
+   * Restore one animation's two clocks without delivering keys already passed.
+   * A skin/view replacement uses the old pose's trackTime and wrapped time.
+   * Unlike setAnimation + apply, restoration never replays the initial interval.
+   */
+  restore(name, trackTime, animationTime) {
+    if (!Number.isFinite(trackTime)) throw new RuntimeInputError(`restore: track time ${trackTime} is not finite`);
+    if (!Number.isFinite(animationTime)) throw new RuntimeInputError(`restore: animation time ${animationTime} is not finite`);
+    this.setAnimation(name);
+    this.trackTime = trackTime;
+    if (!this.model.restoreEventsFromStart) this.eventTime = animationTime;
+    this.apply(animationTime);
+  }
+  /** The setup pose: every constraint applied with its own values, every slot as it is set up. */
+  setupPose() {
+    this.current = null;
+    this.time = 0;
+    this.eventTime = -1;
+    this.fired.length = 0;
+    this.locals.set(this.model.setup);
+    this.hierarchy();
+    this.constraintValues(null, 0);
+    this.solveConstraints();
+    this.slotValues(null, 0);
+  }
+  /** The animation posed at its time `t`, from the setup pose (the header). */
+  apply(t) {
+    const anim = this.current;
+    if (anim === null) throw new RuntimeInputError("apply: no animation is set (setAnimation first)");
+    if (!Number.isFinite(t)) throw new RuntimeInputError(`apply: the time ${t} is not finite`);
+    this.collectEvents(anim, t);
+    this.time = t;
+    this.boneTimelines(anim, t);
+    this.hierarchy();
+    this.constraintValues(anim, t);
+    this.solveConstraints();
+    this.slotValues(anim, t);
+  }
+  /** One step of a looping track: the track time moved by `dt`, the animation posed at it wrapped by the duration (`loopedTime` in src/core/raw.ts). */
+  step(dt) {
+    const anim = this.current;
+    if (anim === null) throw new RuntimeInputError("step: no animation is set (setAnimation first)");
+    this.trackTime += dt;
+    this.apply(anim.duration === 0 ? 0 : this.trackTime % anim.duration);
+  }
+  /** The oracle interval (last,t], tail then head on a wrap; never copies a payload. */
+  collectEvents(anim, t) {
+    const last = this.eventTime;
+    const wrapped = t < last;
+    const keys = anim.eventKeys;
+    let count = 0;
+    if (wrapped) {
+      for (let i = 0; i < keys.length; i++) if (keys[i].time > last) this.fired[count++] = keys[i];
+    }
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key.time <= t && (wrapped ? !this.model.eventWrapOffByOne || key.time > 0 : key.time > last)) this.fired[count++] = key;
+    }
+    this.fired.length = count;
+    this.eventTime = t;
+  }
+  // ---------------------------------------------------------------------------
+  // the bones
+  // ---------------------------------------------------------------------------
+  /** The setup locals with the bone timelines' values at `t` (`posedBones`): added, or multiplied for a scale; a channel before its timeline's first key at setup plus 0, or times 1. */
+  boneTimelines(anim, t) {
+    const L = this.locals;
+    const S = this.model.setup;
+    L.set(S);
+    const timelines = anim.bones;
+    for (let k = 0; k < timelines.length; k++) {
+      const tl = timelines[k];
+      const i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+      const o = tl.bone * LOCALS;
+      const fields = tl.fields;
+      for (let c = 0; c < fields.length; c++) {
+        const at = o + fields[c];
+        if (tl.multiply[c] === 1) L[at] = S[at] * (i < 0 ? 1 : channelValue(tl.curve, i, c, t));
+        else L[at] = S[at] + (i < 0 ? 0 : channelValue(tl.curve, i, c, t));
+      }
+    }
+  }
+  /** Every bone's world transform from its locals, parents first (`worldTransforms`): an inactive bone as zeros. */
+  hierarchy() {
+    const nb = this.model.boneNames.length;
+    for (let i = 0; i < nb; i++) this.poseBone(i, true);
+  }
+  /**
+   * One bone's world transform from its locals under its parent's current
+   * world (`worldTransforms` and the update order's `poseBone`). An inactive
+   * bone is zeroed by the hierarchy (`fresh`) and left as it is by a repose.
+   */
+  poseBone(i, fresh) {
+    const m = this.model;
+    const W = this.world;
+    const o = i * WORLDS;
+    if (m.active[i] === 0) {
+      if (fresh) {
+        W[o + W_A] = 0;
+        W[o + W_B] = 0;
+        W[o + W_C] = 0;
+        W[o + W_D] = 0;
+        W[o + W_X] = 0;
+        W[o + W_Y] = 0;
+      }
+      return;
+    }
+    const L = this.locals;
+    const l = i * LOCALS;
+    const x = L[l + L_X];
+    const y = L[l + L_Y];
+    const rotation = L[l + L_ROTATION];
+    const scaleX = L[l + L_SCALE_X];
+    const scaleY = L[l + L_SCALE_Y];
+    const shearX = L[l + L_SHEAR_X];
+    const shearY = L[l + L_SHEAR_Y];
+    const parent = m.parents[i];
+    if (parent < 0) {
+      const xAngle = (rotation + shearX) * RAD;
+      const yAngle = (rotation + 90 + shearY) * RAD;
+      W[o + W_A] = Math.cos(xAngle) * scaleX;
+      W[o + W_B] = Math.cos(yAngle) * scaleY;
+      W[o + W_C] = Math.sin(xAngle) * scaleX;
+      W[o + W_D] = Math.sin(yAngle) * scaleY;
+      W[o + W_X] = x;
+      W[o + W_Y] = y;
+      return;
+    }
+    const q = parent * WORLDS;
+    const pa = W[q + W_A];
+    const pb = W[q + W_B];
+    const pc = W[q + W_C];
+    const pd = W[q + W_D];
+    const px = W[q + W_X];
+    const py = W[q + W_Y];
+    switch (m.modes[i]) {
+      case MODE_NORMAL: {
+        const xAngle = (rotation + shearX) * RAD;
+        const yAngle = (rotation + 90 + shearY) * RAD;
+        const la = Math.cos(xAngle) * scaleX;
+        const lb = Math.cos(yAngle) * scaleY;
+        const lc = Math.sin(xAngle) * scaleX;
+        const ld = Math.sin(yAngle) * scaleY;
+        W[o + W_A] = pa * la + pb * lc;
+        W[o + W_B] = pa * lb + pb * ld;
+        W[o + W_C] = pc * la + pd * lc;
+        W[o + W_D] = pc * lb + pd * ld;
+        break;
+      }
+      case MODE_ONLY_TRANSLATION: {
+        const xAngle = (rotation + shearX) * RAD;
+        const yAngle = (rotation + 90 + shearY) * RAD;
+        W[o + W_A] = Math.cos(xAngle) * scaleX;
+        W[o + W_B] = Math.cos(yAngle) * scaleY;
+        W[o + W_C] = Math.sin(xAngle) * scaleX;
+        W[o + W_D] = Math.sin(yAngle) * scaleY;
+        break;
+      }
+      case MODE_NO_ROTATION_OR_REFLECTION: {
+        const xLengthSq = pa * pa + pc * pc;
+        let c0;
+        let c1;
+        let c2;
+        let c3;
+        let r;
+        if (xLengthSq > COLLAPSED_X_AXIS_SQ) {
+          const k = Math.abs(pa * pd - pb * pc) / xLengthSq;
+          c0 = pa;
+          c1 = -pc * k;
+          c2 = pc;
+          c3 = pa * k;
+          r = rotation - Math.atan2(pc, pa) * DEG;
+        } else {
+          c0 = 0;
+          c1 = -pb;
+          c2 = 0;
+          c3 = pd;
+          r = rotation - 90 + Math.atan2(pd, pb) * DEG;
+        }
+        const xAngle = (r + shearX) * RAD;
+        const yAngle = (r + shearY + 90) * RAD;
+        const la = Math.cos(xAngle) * scaleX;
+        const lb = Math.cos(yAngle) * scaleY;
+        const lc = Math.sin(xAngle) * scaleX;
+        const ld = Math.sin(yAngle) * scaleY;
+        W[o + W_A] = c0 * la + c1 * lc;
+        W[o + W_B] = c0 * lb + c1 * ld;
+        W[o + W_C] = c2 * la + c3 * lc;
+        W[o + W_D] = c2 * lb + c3 * ld;
+        break;
+      }
+      default: {
+        const rr = rotation * RAD;
+        const cos = Math.cos(rr);
+        const sin = Math.sin(rr);
+        const ux0 = pa * cos + pb * sin;
+        const uy0 = pc * cos + pd * sin;
+        const inverse = 1 / Math.sqrt(ux0 * ux0 + uy0 * uy0);
+        const ux = ux0 * inverse;
+        const uy = uy0 * inverse;
+        const flip = m.modes[i] === MODE_NO_SCALE && pa * pd - pb * pc < 0 ? -1 : 1;
+        const t0 = ux;
+        const t1 = -uy * flip;
+        const t2 = uy;
+        const t3 = ux * flip;
+        const xAngle = (0 + shearX) * RAD;
+        const yAngle = (0 + 90 + shearY) * RAD;
+        const la = Math.cos(xAngle) * scaleX;
+        const lb = Math.cos(yAngle) * scaleY;
+        const lc = Math.sin(xAngle) * scaleX;
+        const ld = Math.sin(yAngle) * scaleY;
+        W[o + W_A] = t0 * la + t1 * lc;
+        W[o + W_B] = t0 * lb + t1 * ld;
+        W[o + W_C] = t2 * la + t3 * lc;
+        W[o + W_D] = t2 * lb + t3 * ld;
+      }
+    }
+    W[o + W_X] = pa * x + pb * y + px;
+    W[o + W_Y] = pc * x + pd * y + py;
+  }
+  // ---------------------------------------------------------------------------
+  // the constraints
+  // ---------------------------------------------------------------------------
+  /** Each constraint's values at `t` (`posedRecords`): its own before its timeline's first key, else the keyed values through the setup blend and the key's flags. */
+  constraintValues(anim, t) {
+    const cs = this.model.constraints;
+    for (let k = 0; k < cs.length; k++) {
+      const c = cs[k];
+      const tl = anim === null ? null : anim.constraints[k];
+      const i = tl === null ? -1 : keyAt(tl.curve, this.cursors, tl.cursor, t);
+      if (c.kind === "ik") {
+        if (tl === null || i < 0) {
+          this.ikMix[k] = c.mix;
+          this.ikSoftness[k] = c.softness;
+          this.ikFlags[k] = c.flags;
+        } else {
+          this.ikMix[k] = c.mix + (channelValue(tl.curve, i, 0, t) - c.mix) * 1;
+          this.ikSoftness[k] = c.softness + (channelValue(tl.curve, i, 1, t) - c.softness) * 1;
+          this.ikFlags[k] = tl.flags[i];
+        }
+      } else {
+        const o = k * 6;
+        for (let p = 0; p < 6; p++) this.mixes[o + p] = tl === null || i < 0 ? c.mixes[p] : c.mixes[p] + (channelValue(tl.curve, i, p, t) - c.mixes[p]) * 1;
+      }
+    }
+  }
+  /** Every applied constraint in the document's order, each followed by the update order's repose (`applyConstraints`). */
+  solveConstraints() {
+    const cs = this.model.constraints;
+    for (let k = 0; k < cs.length; k++) {
+      const c = cs[k];
+      if (!c.applied) continue;
+      if (c.kind === "ik") this.solveIk(c, k);
+      else this.solveTransform(c, k);
+    }
+  }
+  solveIk(c, k) {
+    const mix = this.ikMix[k];
+    if (mix === 0) return;
+    const flags = this.ikFlags[k];
+    if (c.bones.length === 1) {
+      this.solveOne(c.bones[0], c.target, mix, (flags & IK_COMPRESS) !== 0, (flags & IK_STRETCH) !== 0, c.scaleY);
+      this.changed[0] = c.bones[0];
+      this.repose(1, 0);
+    } else if (this.solveTwo(c, mix, this.ikSoftness[k], flags)) {
+      this.changed[0] = c.bones[0];
+      this.repose(1, 0);
+    }
+  }
+  /** A one-bone ik (`solveOne`). */
+  solveOne(bi, ti, mix, compress, stretch, scaleYMode) {
+    const m = this.model;
+    const L = this.locals;
+    const W = this.world;
+    const parent = m.parents[bi];
+    const q = parent * WORLDS;
+    let pa = 1;
+    let pb = 0;
+    let pc = 0;
+    let pd = 1;
+    let pwx = 0;
+    let pwy = 0;
+    if (parent >= 0) {
+      pa = W[q + W_A];
+      pb = W[q + W_B];
+      pc = W[q + W_C];
+      pd = W[q + W_D];
+      pwx = W[q + W_X];
+      pwy = W[q + W_Y];
+    }
+    const bw = bi * WORLDS;
+    const tw = ti * WORLDS;
+    const l = bi * LOCALS;
+    const mode = m.modes[bi];
+    let turn = 0;
+    let lx;
+    let ly;
+    if (mode === MODE_NO_ROTATION_OR_REFLECTION) {
+      const k = Math.abs(pa * pd - pb * pc) / Math.max(1e-5, pa * pa + pc * pc);
+      pb = -pc * k;
+      pd = pa * k;
+      turn = Math.atan2(pc, pa) * DEG;
+      const det = pa * pd - pb * pc;
+      const x = W[tw + W_X] - pwx;
+      const y = W[tw + W_Y] - pwy;
+      if (Math.abs(det) <= 1e-5) {
+        lx = 0;
+        ly = 0;
+      } else {
+        lx = (x * pd - y * pb) / det - L[l + L_X];
+        ly = (y * pa - x * pc) / det - L[l + L_Y];
+      }
+    } else if (mode === MODE_ONLY_TRANSLATION) {
+      lx = W[tw + W_X] - W[bw + W_X];
+      ly = W[tw + W_Y] - W[bw + W_Y];
+    } else {
+      const det = pa * pd - pb * pc;
+      const x = W[tw + W_X] - pwx;
+      const y = W[tw + W_Y] - pwy;
+      if (Math.abs(det) <= 1e-5) {
+        lx = 0;
+        ly = 0;
+      } else {
+        lx = (x * pd - y * pb) / det - L[l + L_X];
+        ly = (y * pa - x * pc) / det - L[l + L_Y];
+      }
+    }
+    const rotation = L[l + L_ROTATION];
+    const scaleX = L[l + L_SCALE_X];
+    let r = -L[l + L_SHEAR_X] - rotation + turn + Math.atan2(ly, lx) * DEG;
+    if (scaleX < 0) r += 180;
+    L[l + L_ROTATION] = rotation + wrap180(r) * mix;
+    const len = m.lengths[bi] * scaleX;
+    if ((compress || stretch) && len > 1e-5) {
+      const wx = W[tw + W_X] - W[bw + W_X];
+      const wy = W[tw + W_Y] - W[bw + W_Y];
+      const d = mode === MODE_NO_SCALE || mode === MODE_NO_SCALE_OR_REFLECTION ? Math.sqrt(wx * wx + wy * wy) : Math.sqrt(lx * lx + ly * ly);
+      if (compress && d < len || stretch && d > len) {
+        const s = (d / len - 1) * mix + 1;
+        L[l + L_SCALE_X] = scaleX * s;
+        if (scaleYMode === SCALE_Y_UNIFORM) L[l + L_SCALE_Y] = L[l + L_SCALE_Y] * s;
+        else if (scaleYMode === SCALE_Y_VOLUME) L[l + L_SCALE_Y] = volumeScaleY(L[l + L_SCALE_Y], s);
+      }
+    }
+  }
+  /** A two-bone ik (`solveTwo`): whether it changed the parent. */
+  solveTwo(c, mix, softness, flags) {
+    const m = this.model;
+    const L = this.locals;
+    const W = this.world;
+    const pi = c.bones[0];
+    const ci = c.bones[1];
+    if (m.modes[pi] !== MODE_NORMAL || m.modes[ci] !== MODE_NORMAL) return false;
+    const stretch = (flags & IK_STRETCH) !== 0;
+    const g = m.parents[pi] * WORLDS;
+    const pw = pi * WORLDS;
+    const tw = c.target * WORLDS;
+    const pl = pi * LOCALS;
+    const cl = ci * LOCALS;
+    const ga = W[g + W_A];
+    const gb = W[g + W_B];
+    const gc = W[g + W_C];
+    const gd = W[g + W_D];
+    const gx = W[g + W_X];
+    const gy = W[g + W_Y];
+    const gdet = ga * gd - gb * gc;
+    const gid = Math.abs(gdet) <= 1e-5 ? 0 : 1 / gdet;
+    const px = L[pl + L_X];
+    const py = L[pl + L_Y];
+    const psx = L[pl + L_SCALE_X];
+    const psy = L[pl + L_SCALE_Y];
+    const csx = L[cl + L_SCALE_X];
+    let sx = psx;
+    let sy = psy;
+    const cx = L[cl + L_X];
+    let cy = L[cl + L_Y];
+    const uniform = Math.abs(Math.abs(psx) - Math.abs(psy)) <= 1e-5;
+    if (!uniform || stretch) cy = 0;
+    let x = W[pw + W_A] * cx + W[pw + W_B] * cy + W[pw + W_X] - gx;
+    let y = W[pw + W_C] * cx + W[pw + W_D] * cy + W[pw + W_Y] - gy;
+    const ox = (x * gd - y * gb) * gid;
+    const oy = (y * ga - x * gc) * gid;
+    const dx = ox - px;
+    const dy = oy - py;
+    const l1 = Math.sqrt(dx * dx + dy * dy);
+    let l2 = m.lengths[ci] * Math.abs(csx);
+    if (l1 < 1e-5) {
+      this.solveOne(pi, c.target, mix, false, stretch, 0);
+      L[cl + L_ROTATION] = 0;
+      L[cl + L_Y] = cy;
+      return true;
+    }
+    x = W[tw + W_X] - gx;
+    y = W[tw + W_Y] - gy;
+    let tx = (x * gd - y * gb) * gid;
+    let ty = (y * ga - x * gc) * gid;
+    tx -= px;
+    ty -= py;
+    let d2 = tx * tx + ty * ty;
+    const bend = (flags & IK_BEND_POSITIVE) !== 0 ? 1 : -1;
+    if (softness !== 0) {
+      const soft = softness * (Math.abs(psx) * (Math.abs(csx) + 1) * 0.5);
+      const d = Math.sqrt(d2);
+      const sd = d - l1 - l2 * Math.abs(psx) + soft;
+      if (sd > 0) {
+        const q = Math.min(1, sd / (soft * 2)) - 1;
+        const pull = (sd - soft * (1 - q * q)) / d;
+        tx -= pull * tx;
+        ty -= pull * ty;
+        d2 = tx * tx + ty * ty;
+      }
+    }
+    let a1;
+    let a2;
+    if (uniform) {
+      l2 *= Math.abs(psx);
+      let cos = (d2 - l1 * l1 - l2 * l2) / (2 * l1 * l2);
+      if (cos < -1) {
+        cos = -1;
+        a2 = Math.PI * bend;
+      } else if (cos > 1) {
+        cos = 1;
+        a2 = 0;
+        if (stretch) {
+          const f = (Math.sqrt(d2) / (l1 + l2) - 1) * mix + 1;
+          sx *= f;
+          if (c.scaleY === SCALE_Y_UNIFORM) sy *= f;
+          else if (c.scaleY === SCALE_Y_VOLUME) sy = volumeScaleY(sy, f);
+        }
+      } else a2 = Math.acos(cos) * bend;
+      const along = l1 + l2 * cos;
+      const across = l2 * Math.sin(a2);
+      a1 = Math.atan2(ty * along - tx * across, tx * along + ty * across);
+    } else {
+      const ea = Math.abs(psx) * l2;
+      const eb = Math.abs(psy) * l2;
+      const aa = ea * ea;
+      const bb = eb * eb;
+      const qa = bb - aa;
+      const qb = -2 * bb * l1;
+      const qc = bb * l1 * l1 + aa * d2 - aa * bb;
+      const disc = qb * qb - 4 * qa * qc;
+      let solved = false;
+      a1 = 0;
+      a2 = 0;
+      if (disc >= 0) {
+        let q = Math.sqrt(disc);
+        if (qb < 0) q = -q;
+        q = -(qb + q) * 0.5;
+        const r0 = q / qa;
+        const r1 = qc / q;
+        const X = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
+        const y2 = d2 - X * X;
+        if (y2 >= 0) {
+          const Y = Math.sqrt(y2) * bend;
+          a1 = Math.atan2(ty, tx) - Math.atan2(Y, X);
+          a2 = Math.atan2(Y / Math.abs(psy), (X - l1) / Math.abs(psx));
+          solved = true;
+        }
+      }
+      if (!solved) {
+        let nearAngle = RUNTIME_PI;
+        let nearX = l1 - ea;
+        let nearY = 0;
+        let nearDist = (l1 - ea) * (l1 - ea);
+        let farAngle = 0;
+        let farX = l1 + ea;
+        let farY = 0;
+        let farDist = (l1 + ea) * (l1 + ea);
+        const vertex = -ea * l1 / (aa - bb);
+        if (vertex >= -1 && vertex <= 1) {
+          const angle = Math.acos(vertex);
+          const vx = ea * Math.cos(angle) + l1;
+          const vy = eb * Math.sin(angle);
+          const dist = vx * vx + vy * vy;
+          if (dist < nearDist) {
+            nearAngle = angle;
+            nearX = vx;
+            nearY = vy;
+            nearDist = dist;
+          }
+          if (dist > farDist) {
+            farAngle = angle;
+            farX = vx;
+            farY = vy;
+            farDist = dist;
+          }
+        }
+        if (d2 <= (nearDist + farDist) * 0.5) {
+          a1 = Math.atan2(ty, tx) - Math.atan2(nearY * bend, nearX);
+          a2 = nearAngle * bend;
+        } else {
+          a1 = Math.atan2(ty, tx) - Math.atan2(farY * bend, farX);
+          a2 = farAngle * bend;
+        }
+      }
+    }
+    const signs = (psx < 0 ? -1 : 1) * (psy < 0 ? -1 : 1);
+    const offset = Math.atan2(cy, cx);
+    const parentRotation = L[pl + L_ROTATION];
+    const parentChange = (a1 - signs * offset) * DEG + (psx < 0 ? 180 : 0) - parentRotation;
+    L[pl + L_ROTATION] = parentRotation + wrap180(parentChange) * mix;
+    L[pl + L_SCALE_X] = sx;
+    L[pl + L_SCALE_Y] = sy;
+    const childTarget = ((a2 + signs * offset) * DEG - L[cl + L_SHEAR_X]) * signs + (csx < 0 ? 180 : 0);
+    const childRotation = L[cl + L_ROTATION];
+    L[cl + L_Y] = cy;
+    L[cl + L_ROTATION] = childRotation + wrap180(childTarget - childRotation) * mix;
+    return true;
+  }
+  /** A world-space, absolute transform (`solveTransform`): each bone's world edited in turn and written back, then the repose. */
+  solveTransform(c, k) {
+    const W = this.world;
+    const w = this.w;
+    const mixes = this.mixes;
+    const o6 = k * 6;
+    let n = 0;
+    for (let bk = 0; bk < c.bones.length; bk++) {
+      const bi = c.bones[bk];
+      const o = bi * WORLDS;
+      w[W_A] = W[o + W_A];
+      w[W_B] = W[o + W_B];
+      w[W_C] = W[o + W_C];
+      w[W_D] = W[o + W_D];
+      w[W_X] = W[o + W_X];
+      w[W_Y] = W[o + W_Y];
+      let applied = false;
+      for (let f = 0; f < c.fromProperty.length; f++) {
+        const value = this.sourceValue(c, c.fromProperty[f]) - c.fromOffset[f];
+        for (let q = c.toStart[f]; q < c.toEnd[f]; q++) {
+          const property = c.toProperty[q];
+          const mix = mixes[o6 + property];
+          if (mix === 0) continue;
+          let v = value * c.toScale[q] + c.toOffset[q];
+          if (c.clamp) {
+            const lo = Math.min(c.toOffset[q], c.toMax[q]);
+            const hi = Math.max(c.toOffset[q], c.toMax[q]);
+            v = v < lo ? lo : v > hi ? hi : v;
+          }
+          applied = true;
+          applyWorld(w, property, v, mix);
+        }
+      }
+      if (!applied) continue;
+      W[o + W_A] = w[W_A];
+      W[o + W_B] = w[W_B];
+      W[o + W_C] = w[W_C];
+      W[o + W_D] = w[W_D];
+      W[o + W_X] = w[W_X];
+      W[o + W_Y] = w[W_Y];
+      this.changed[n] = bi;
+      this.inWorld[n] = bi;
+      n++;
+    }
+    if (n > 0) this.repose(n, n);
+  }
+  /** The source's world value of a property (`sourceValue`, world source). */
+  sourceValue(c, property) {
+    const W = this.world;
+    const s = c.source * WORLDS;
+    const o = c.offsets;
+    const a = W[s + W_A];
+    const b = W[s + W_B];
+    const cc = W[s + W_C];
+    const d = W[s + W_D];
+    switch (property) {
+      case P_ROTATE: {
+        const det = a * d - b * cc;
+        let r = Math.atan2(cc, a) * DEG + (det > 0 ? o[P_ROTATE] : -o[P_ROTATE]);
+        if (r < 0) r += 360;
+        return r;
+      }
+      case P_X:
+        return a * o[P_X] + b * o[P_Y] + W[s + W_X];
+      case P_Y:
+        return cc * o[P_X] + d * o[P_Y] + W[s + W_Y];
+      case P_SCALE_X:
+        return Math.sqrt(a * a + cc * cc) + o[P_SCALE_X];
+      case P_SCALE_Y:
+        return Math.sqrt(b * b + d * d) + o[P_SCALE_Y];
+      default:
+        return (Math.atan2(d, b) - Math.atan2(cc, a)) * DEG - 90 + o[5];
+    }
+  }
+  /**
+   * After a constraint (`repose`): the `nInWorld` bones it moved in world space
+   * (the first of `inWorld`) read back into local values, then every bone below
+   * one of the `nChanged` it changed (`changed`) posed again, in bone order —
+   * but not through an inactive bone it did not move itself, and not a bone it
+   * moved in world space.
+   */
+  repose(nChanged, nInWorld) {
+    const m = this.model;
+    const changed = this.changed;
+    const changedMark = this.changedMark;
+    const inWorldMark = this.inWorldMark;
+    const below = this.below;
+    for (let k = 0; k < nInWorld; k++) {
+      this.localFromWorld(this.inWorld[k]);
+      inWorldMark[this.inWorld[k]] = 1;
+    }
+    for (let k = 0; k < nChanged; k++) {
+      changedMark[changed[k]] = 1;
+      below[changed[k]] = 1;
+    }
+    const starts = m.subtreeStart;
+    const list = m.subtrees;
+    const parents = m.parents;
+    const active = m.active;
+    if (nChanged === 1) {
+      const e = starts[changed[0] + 1];
+      for (let q = starts[changed[0]]; q < e; q++) this.reposeOne(list[q], parents, active);
+      for (let q = starts[changed[0]]; q < e; q++) below[list[q]] = 0;
+    } else {
+      const visit = this.visit;
+      let first = parents.length;
+      for (let k = 0; k < nChanged; k++) {
+        const b = changed[k];
+        if (b < first) first = b;
+        const e = starts[b + 1];
+        for (let q = starts[b]; q < e; q++) visit[list[q]] = 1;
+      }
+      for (let b = first; b < parents.length; b++) if (visit[b] === 1) this.reposeOne(b, parents, active);
+      for (let b = first; b < parents.length; b++) {
+        visit[b] = 0;
+        below[b] = 0;
+      }
+    }
+    for (let k = 0; k < nChanged; k++) changedMark[changed[k]] = 0;
+    for (let k = 0; k < nInWorld; k++) inWorldMark[this.inWorld[k]] = 0;
+  }
+  reposeOne(b, parents, active) {
+    const below = this.below;
+    const p = parents[b];
+    if (p >= 0 && below[p] === 1 && (active[p] === 1 || this.changedMark[p] === 1)) below[b] = 1;
+    if (below[b] === 1 && this.inWorldMark[b] === 0) this.poseBone(b, false);
+  }
+  /** A bone's local values read back from its world transform (`localFromWorld`) — `normal`, `onlyTranslation` and `noRotationOrReflection`; a world target in a `noScale` mode is refused at load. */
+  localFromWorld(bi) {
+    const m = this.model;
+    const W = this.world;
+    const L = this.locals;
+    const w = bi * WORLDS;
+    const l = bi * LOCALS;
+    const parent = m.parents[bi];
+    const mode = parent < 0 ? MODE_NORMAL : m.modes[bi];
+    let pa = 1;
+    let pb = 0;
+    let pc = 0;
+    let pd = 1;
+    let px = 0;
+    let py = 0;
+    if (parent >= 0) {
+      const q = parent * WORLDS;
+      pa = W[q + W_A];
+      pb = W[q + W_B];
+      pc = W[q + W_C];
+      pd = W[q + W_D];
+      px = W[q + W_X];
+      py = W[q + W_Y];
+    }
+    const pid = 1 / (pa * pd - pb * pc);
+    const dx = W[w + W_X] - px;
+    const dy = W[w + W_Y] - py;
+    L[l + L_X] = dx * (pd * pid) - dy * (pb * pid);
+    L[l + L_Y] = dy * (pa * pid) - dx * (pc * pid);
+    L[l + L_SHEAR_X] = 0;
+    const wa = W[w + W_A];
+    const wb = W[w + W_B];
+    const wc = W[w + W_C];
+    const wd = W[w + W_D];
+    if (mode === MODE_ONLY_TRANSLATION) {
+      this.decompose(l, wa, wc, wb, wd);
+      return;
+    }
+    if (mode === MODE_NO_ROTATION_OR_REFLECTION) {
+      const xLengthInverse = 1 / (pa * pa + pc * pc);
+      const detInverse = 1 / Math.abs(pa * pd - pb * pc);
+      this.decompose(l, (pa * wa + pc * wc) * xLengthInverse, (pa * wc - pc * wa) * detInverse, (pa * wb + pc * wd) * xLengthInverse, (pa * wd - pc * wb) * detInverse);
+      L[l + L_ROTATION] = L[l + L_ROTATION] + Math.atan2(pc, pa) * DEG;
+      return;
+    }
+    const ia = pd * pid;
+    const ib = pb * pid;
+    const ic = pc * pid;
+    const id = pa * pid;
+    this.decompose(l, ia * wa - ib * wc, id * wc - ic * wa, ia * wb - ib * wd, id * wd - ic * wb);
+  }
+  /** A local matrix with columns `(la, lc)` and `(lb, ld)` as rotation, scales and shear (`decompose`). */
+  decompose(l, la, lc, lb, ld) {
+    const L = this.locals;
+    const sx = Math.sqrt(la * la + lc * lc);
+    const yLength = Math.sqrt(lb * lb + ld * ld);
+    if (!(sx > 1e-4)) {
+      L[l + L_SCALE_X] = 0;
+      L[l + L_SCALE_Y] = yLength;
+      L[l + L_SHEAR_Y] = 0;
+      L[l + L_ROTATION] = yLength > 1e-5 ? Math.atan2(ld, lb) * DEG - 90 : 0;
+      return;
+    }
+    const xAngle = Math.atan2(lc, la) * DEG;
+    const det = la * ld - lb * lc;
+    const yAngle = Math.atan2(ld, lb) * DEG;
+    L[l + L_ROTATION] = xAngle;
+    L[l + L_SCALE_X] = sx;
+    L[l + L_SCALE_Y] = det < 0 ? -yLength : yLength;
+    const right = det < 0 ? -90 : 90;
+    let shear = yAngle - (xAngle + right);
+    shear = shear > 180 ? shear - 360 : shear < -180 ? shear + 360 : shear;
+    L[l + L_SHEAR_Y] = yLength > 1e-5 ? shear : 0;
+  }
+  // ---------------------------------------------------------------------------
+  // the slots and the vertices
+  // ---------------------------------------------------------------------------
+  /** Every slot's colour and what it shows (`posedSlots`): the setup's, then each of its timelines at `t` in order. */
+  slotValues(anim, t) {
+    const slots = this.model.slots;
+    const light = this.light;
+    for (let s = 0; s < slots.length; s++) {
+      const slot = slots[s];
+      this.shown[s] = slot.setupAttachment;
+      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];
+    }
+    if (anim === null) return;
+    const timelines = anim.slots;
+    for (let k = 0; k < timelines.length; k++) {
+      const tl = timelines[k];
+      const i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+      const attachments = tl.attachments;
+      if (attachments !== null) {
+        this.shown[tl.slot] = i < 0 ? slots[tl.slot].setupAttachment : attachments[i];
+        continue;
+      }
+      const channels = tl.channels;
+      const setup = slots[tl.slot].light;
+      const o = tl.slot * 4;
+      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));
+      }
+    }
+  }
+  /** Every shown attachment's world vertices into `vertices` at its offset (`regionCorners`, `worldVertices`). */
+  computeVertices() {
+    const m = this.model;
+    const W = this.world;
+    const out = this.vertices;
+    const shown = this.shown;
+    const attachments = m.attachments;
+    for (let s = 0; s < shown.length; s++) {
+      const index = shown[s];
+      if (index < 0) continue;
+      const at = attachments[index];
+      if (at.draw === DRAW_NONE) continue;
+      let o = at.offset;
+      if (at.draw === DRAW_REGION || at.draw === DRAW_MESH) {
+        const b = at.bone * WORLDS;
+        const a = W[b + W_A];
+        const bb = W[b + W_B];
+        const c = W[b + W_C];
+        const d = W[b + W_D];
+        const wx = W[b + W_X];
+        const wy = W[b + W_Y];
+        const local = at.local;
+        if (at.draw === DRAW_REGION) {
+          for (let q = 0; q < 8; q += 2) {
+            const lx = local[q];
+            const ly = local[q + 1];
+            out[o++] = a * lx + bb * ly + wx;
+            out[o++] = c * lx + d * ly + wy;
+          }
+        } else {
+          for (let q = 0; q < at.count; q += 2) {
+            const x = local[q];
+            const y = local[q + 1];
+            out[o++] = x * a + y * bb + wx;
+            out[o++] = x * c + y * d + wy;
+          }
+        }
+        continue;
+      }
+      const counts = at.bindingCounts;
+      const bones = at.bindingBones;
+      const xs = at.bindingX;
+      const ys = at.bindingY;
+      const weights = at.bindingWeights;
+      let n = 0;
+      for (let v = 0; v < counts.length; v++) {
+        let wx = 0;
+        let wy = 0;
+        const end = n + counts[v];
+        for (; n < end; n++) {
+          const b = bones[n] * WORLDS;
+          const x = xs[n];
+          const y = ys[n];
+          const weight = weights[n];
+          wx += (x * W[b + W_A] + y * W[b + W_B] + W[b + W_X]) * weight;
+          wy += (x * W[b + W_C] + y * W[b + W_D] + W[b + W_Y]) * weight;
+        }
+        out[o++] = wx;
+        out[o++] = wy;
+      }
+    }
+  }
+}
+function applyWorld(w, property, v, mix) {
+  switch (property) {
+    case P_ROTATE: {
+      let r = v * RAD - Math.atan2(w[W_C], w[W_A]);
+      if (r > RUNTIME_PI) r -= TWO_PI;
+      else if (r < -RUNTIME_PI) r += TWO_PI;
+      r *= mix;
+      const cos = Math.cos(r);
+      const sin = Math.sin(r);
+      const a = w[W_A];
+      const b = w[W_B];
+      w[W_A] = cos * a - sin * w[W_C];
+      w[W_B] = cos * b - sin * w[W_D];
+      w[W_C] = sin * a + cos * w[W_C];
+      w[W_D] = sin * b + cos * w[W_D];
+      return;
+    }
+    case P_X:
+      w[W_X] = w[W_X] + (v - w[W_X]) * mix;
+      return;
+    case P_Y:
+      w[W_Y] = w[W_Y] + (v - w[W_Y]) * mix;
+      return;
+    case P_SCALE_X:
+    case P_SCALE_Y: {
+      const p = property === P_SCALE_X ? W_A : W_B;
+      const q = property === P_SCALE_X ? W_C : W_D;
+      const s = Math.sqrt(w[p] * w[p] + w[q] * w[q]);
+      if (s === 0) return;
+      const k = 1 + (v - s) * mix / s;
+      w[p] *= k;
+      w[q] *= k;
+      return;
+    }
+    default: {
+      const yAngle = Math.atan2(w[W_D], w[W_B]);
+      const xAngle = Math.atan2(w[W_C], w[W_A]);
+      let r = (v + 90) * RAD - (yAngle - xAngle);
+      r = r > RUNTIME_PI ? r - TWO_PI : r < -RUNTIME_PI ? r + TWO_PI : r;
+      const angle = yAngle + r * mix;
+      const s = Math.sqrt(w[W_B] * w[W_B] + w[W_D] * w[W_D]);
+      w[W_B] = Math.cos(angle) * s;
+      w[W_D] = Math.sin(angle) * s;
+    }
+  }
+}
 function frameSource(doc, parsed) {
   if (doc.pages === null) {
     throw new CoreInputError(
@@ -8839,12 +10361,20 @@ function frameSource(doc, parsed) {
     );
   }
   const pages = new Map(doc.pages.map((page) => [page.name, page]));
+  const boneOf = /* @__PURE__ */ new Map();
+  const slotIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < doc.slots.length; i++) {
+    const slot = doc.slots[i];
+    boneOf.set(slot.name, slot.bone);
+    slotIndex.set(slot.name, i);
+  }
   return {
     doc,
     uv: { lookup: documentPageLookup(doc.pages), sequences: readUvSequences(parsed) },
     pages,
     active: activeBones(doc),
-    boneOf: new Map(doc.slots.map((slot) => [slot.name, slot.bone])),
+    boneOf,
+    slotIndex,
     uvs: /* @__PURE__ */ new WeakMap(),
     regionUvs: /* @__PURE__ */ new WeakMap(),
     triangles: /* @__PURE__ */ new Map()
@@ -8877,24 +10407,57 @@ function regionUvs(source, found) {
   return kept;
 }
 function trianglesOf(source, drawn) {
-  const key = `${drawn.slot}\0${drawn.attachment}`;
-  let lists = source.triangles.get(key);
-  if (lists === void 0) {
-    lists = [];
-    source.triangles.set(key, lists);
+  let byAttachment = source.triangles.get(drawn.slot);
+  if (byAttachment === void 0) {
+    byAttachment = /* @__PURE__ */ new Map();
+    source.triangles.set(drawn.slot, byAttachment);
+  }
+  let cache = byAttachment.get(drawn.attachment);
+  if (cache === void 0) {
+    cache = { byRef: /* @__PURE__ */ new WeakMap(), lists: [] };
+    byAttachment.set(drawn.attachment, cache);
   }
   const wanted = drawn.triangles;
-  let kept = lists.find((list) => list.length === wanted.length && list.every((v, i) => v === wanted[i]));
+  const fast = cache.byRef.get(wanted);
+  if (fast !== void 0) return fast;
+  const frozen = Object.isFrozen(wanted);
+  let kept = cache.lists.find((list) => list.length === wanted.length && list.every((v, i) => v === wanted[i]));
   if (kept === void 0) {
-    kept = [...wanted];
-    lists.push(kept);
+    kept = frozen ? wanted : Object.freeze([...wanted]);
+    cache.lists.push(kept);
+    cache.byRef.set(kept, kept);
   }
+  if (frozen) cache.byRef.set(wanted, kept);
   return kept;
 }
+function regionMap(regions) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < regions.length; i++) map.set(regions[i].slot, regions[i]);
+  return map;
+}
+function slotRowMap(slots) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < slots.length; i++) map.set(slots[i][0], slots[i]);
+  return map;
+}
+function drawOrderMap(drawOrder) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < drawOrder.length; i++) map.set(drawOrder[i], i);
+  return map;
+}
 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();
+  if (pose.clips.length === 0) return cover;
+  const polygons = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pose.clips.length; i++) {
+    const c = pose.clips[i];
+    polygons.set(c[0], { end: c[2], polygon: c[3] });
+  }
+  const shownOf = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pose.shown.length; i++) {
+    const s = pose.shown[i];
+    shownOf.set(s.slot, s);
+  }
   let current = null;
   for (const slot of pose.drawOrder) {
     const shown = shownOf.get(slot);
@@ -8915,20 +10478,25 @@ function clipCover(pose, active, draws = () => true) {
 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, draws);
+  let regionOf = null;
+  let rows = null;
+  let z = null;
+  const cover = pose.clips.length === 0 ? null : clipCover(pose, source.active, draws);
   const [sr, sg, sb, sa] = color;
   const order = [];
-  for (const d of pose.drawn) {
+  for (let i = 0; i < pose.drawn.length; i++) {
+    const d = pose.drawn[i];
     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);
+    const directRegion = regions[i];
+    const found = directRegion !== void 0 && directRegion.slot === d.slot ? directRegion : (regionOf ??= regionMap(regions)).get(d.slot);
     if (found === void 0) throw new CoreInputError(`slot "${d.slot}" drew "${d.attachment}", and no atlas region was resolved for it`);
-    const row = rows.get(d.slot);
+    const slotIdx = source.slotIndex.get(d.slot);
+    const directRow = slotIdx !== void 0 ? pose.slots[slotIdx] : void 0;
+    const row = directRow !== void 0 && directRow[0] === d.slot ? directRow : (rows ??= slotRowMap(pose.slots)).get(d.slot);
     if (row === void 0) throw new CoreInputError(`slot "${d.slot}" drew and has no slot row`);
+    const slotZ = slotIdx !== void 0 && pose.drawOrder[slotIdx] === d.slot ? slotIdx : (z ??= drawOrderMap(pose.drawOrder)).get(d.slot);
     const tint = [
       channel(row[2], d.slot) * d.colour[0] * sr,
       channel(row[3], d.slot) * d.colour[1] * sg,
@@ -8936,13 +10504,14 @@ function frameOf(source, pose, color = [1, 1, 1, 1], draws = () => true) {
       channel(row[5], d.slot) * d.colour[3] * sa
     ];
     const darkRow = row[6];
+    const clip = cover === null ? void 0 : cover.get(d.slot);
     const common = {
       slot: d.slot,
-      z: z.get(d.slot),
+      z: slotZ,
       blend: row[8] ?? "Normal",
       tint,
       ...darkRow === null ? {} : { dark: [channel(darkRow[0], d.slot), channel(darkRow[1], d.slot), channel(darkRow[2], d.slot)] },
-      ...cover.has(d.slot) ? { clip: cover.get(d.slot) } : {}
+      ...clip === void 0 ? {} : { clip }
     };
     const page = source.pages.get(found.found.page.name);
     if (d.kind === "region") {
@@ -8970,6 +10539,238 @@ function frameOf(source, pose, color = [1, 1, 1, 1], draws = () => true) {
   }
   return { order };
 }
+function numbers(buffer, offset, count) {
+  const result = new Array(count);
+  for (let i = 0; i < count; i++) Object.defineProperty(result, i, {
+    enumerable: true,
+    get: () => buffer[offset + i]
+  });
+  return Object.freeze(result);
+}
+function checkedLiveFrame(frame2, current) {
+  const generation = current();
+  const frameGeneration = frame2.generation;
+  const proxies = /* @__PURE__ */ new WeakMap();
+  const check = () => {
+    if (current() !== generation) throw new Error(`LIVE_FRAME_STALE: borrowed generation ${frameGeneration} was invalidated; call liveFrame() again`);
+  };
+  const wrap = (value) => {
+    const found = proxies.get(value);
+    if (found) return found;
+    const proxy = new Proxy(Array.isArray(value) ? [] : {}, {
+      get(_target, property) {
+        check();
+        if (property === "buffer" || property === "set" || property === "fill" || property === "copyWithin" || property === "reverse" || property === "sort") {
+          throw new Error(`LIVE_FRAME_READONLY: ${String(property)} does not expose the live backing store`);
+        }
+        const item = Reflect.get(value, property, value);
+        if (typeof item === "function") {
+          if (ArrayBuffer.isView(value) && property !== Symbol.iterator) throw new Error(`LIVE_FRAME_READONLY: ${String(property)} is not part of the indexed live buffer interface`);
+          return (...args) => {
+            check();
+            const returned = Reflect.apply(item, Array.isArray(value) ? proxy : value, args);
+            return returned !== null && typeof returned === "object" ? wrap(returned) : returned;
+          };
+        }
+        return item !== null && typeof item === "object" ? wrap(item) : item;
+      },
+      set() {
+        check();
+        throw new Error("LIVE_FRAME_READONLY: live frame values cannot be assigned");
+      },
+      defineProperty() {
+        check();
+        throw new Error("LIVE_FRAME_READONLY: live frame values cannot be redefined");
+      },
+      deleteProperty() {
+        check();
+        throw new Error("LIVE_FRAME_READONLY: live frame values cannot be deleted");
+      },
+      preventExtensions() {
+        check();
+        throw new Error("LIVE_FRAME_READONLY: live frame objects cannot be reconfigured");
+      },
+      setPrototypeOf() {
+        check();
+        throw new Error("LIVE_FRAME_READONLY: live frame prototypes cannot be changed");
+      },
+      has(_target, property) {
+        check();
+        return Reflect.has(value, property);
+      },
+      ownKeys() {
+        check();
+        return Reflect.ownKeys(value);
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        check();
+        if (property === "length" && Array.isArray(value)) return { value: value.length, writable: true, configurable: false, enumerable: false };
+        const descriptor = Reflect.getOwnPropertyDescriptor(value, property);
+        return descriptor ? { configurable: true, enumerable: descriptor.enumerable, get: () => Reflect.get(proxy, property) } : void 0;
+      }
+    });
+    proxies.set(value, proxy);
+    return proxy;
+  };
+  const lease = wrap(frame2);
+  const drawing = liveDrawings.get(frame2);
+  if (drawing) liveDrawings.set(lease, drawing);
+  return lease;
+}
+class RuntimeFrames {
+  model;
+  pose;
+  renderFrame = { order: [] };
+  live;
+  order;
+  tint;
+  templates;
+  colours;
+  /** Incremented when a draw refresh changes colour without a pose step. */
+  revision = 0;
+  previousColor = new Float64Array(4).fill(Number.NaN);
+  drawn = 0;
+  epoch = 0;
+  constructor(source, model) {
+    this.model = model ?? compileRuntime(source.doc);
+    this.pose = new RuntimePose(this.model);
+    this.order = new Int32Array(this.model.slots.length);
+    this.tint = new Float64Array(this.model.slots.length * 4);
+    const colours = [];
+    const metadata = [];
+    this.templates = this.model.attachments.map((attachment, index) => {
+      const identity = attachment;
+      if (identity.skin === void 0 || identity.placeholder === void 0) {
+        throw new Error(`RUNTIME_DRAW_IDENTITY: attachment ${index} on slot "${this.model.slots[attachment.slot].name}" needs resolved skin and placeholder from rig-c/runtime`);
+      }
+      const slot = this.model.slots[attachment.slot];
+      const doc = { ...source.doc, slots: source.doc.slots.map((value, si) => ({ ...value, setup: si === attachment.slot ? identity.placeholder : null })) };
+      const setup = poseRawSetup(doc);
+      const raw = setup.drawn.find((value) => value.slot === slot.name);
+      const template = frameOf(source, setup).order.find((value) => value.slot === slot.name) ?? null;
+      const colour = raw?.colour ?? [1, 1, 1, 1];
+      colours.push(colour);
+      if (template) {
+        const vertices = numbers(this.pose.vertices, attachment.offset, attachment.count);
+        if (template.kind === "region") template.corners = vertices;
+        else template.vertices = vertices;
+        template.tint = numbers(this.tint, attachment.slot * 4, 4);
+      }
+      metadata.push(Object.freeze({
+        slot: slot.name,
+        slotIndex: attachment.slot,
+        attachment: attachment.name,
+        skin: identity.skin,
+        placeholder: identity.placeholder,
+        kind: template?.kind ?? "none",
+        region: template?.kind === "region" ? template.region : null,
+        page: template?.page ?? null,
+        pma: template?.pma ?? false,
+        blend: slot.blend,
+        offset: attachment.offset,
+        count: attachment.count,
+        uvs: Object.freeze(template?.uvs ?? []),
+        triangles: Object.freeze(template?.kind === "mesh" ? template.triangles : []),
+        dark: template?.dark ? Object.freeze(template.dark) : null,
+        clip: null
+      }));
+      return template;
+    });
+    this.colours = colours;
+    const owner = this;
+    this.live = Object.freeze({
+      get generation() {
+        return owner.epoch;
+      },
+      get count() {
+        return owner.drawn;
+      },
+      drawOrder: this.order,
+      vertices: this.pose.vertices,
+      tint: this.tint,
+      attachments: Object.freeze(metadata)
+    });
+    liveDrawings.set(this.live, this.renderFrame);
+  }
+  update(generation, color, draws, poseChanged = true) {
+    if (poseChanged) this.pose.computeVertices();
+    let colorChanged = false;
+    for (let c = 0; c < 4; c++) {
+      if (!Object.is(this.previousColor[c], color[c])) colorChanged = true;
+      this.previousColor[c] = color[c];
+    }
+    if (colorChanged) this.revision++;
+    let count = 0;
+    for (let si = 0; si < this.pose.shown.length; si++) {
+      const ai = this.pose.shown[si];
+      const template = ai < 0 ? null : this.templates[ai];
+      if (!template || !this.model.active[this.model.slots[si].bone]) continue;
+      const offset = si * 4;
+      const colour = this.colours[ai];
+      for (let c = 0; c < 4; c++) this.tint[offset + c] = this.pose.light[offset + c] * colour[c] * color[c];
+      if (!draws(template.slot)) continue;
+      this.order[count] = ai;
+      this.renderFrame.order[count++] = template;
+    }
+    this.renderFrame.order.length = count;
+    this.drawn = count;
+    this.epoch = generation;
+  }
+  snapshot(draws) {
+    const selected = [];
+    for (let si = 0; si < this.pose.shown.length; si++) {
+      const ai = this.pose.shown[si];
+      const slot = ai < 0 ? null : this.templates[ai];
+      if (slot && this.model.active[this.model.slots[si].bone] && (draws === void 0 || draws(slot.slot))) selected.push(slot);
+    }
+    const order = selected.map((slot) => {
+      const common = { ...slot, tint: slot.tint.slice() };
+      return slot.kind === "region" ? { ...common, kind: "region", region: slot.region, corners: slot.corners.slice(), page: slot.page, pma: slot.pma, uvs: slot.uvs } : { ...common, kind: "mesh", vertices: slot.vertices.slice(), page: slot.page, pma: slot.pma, uvs: slot.uvs, triangles: slot.triangles, sequence: slot.sequence };
+    });
+    return { order };
+  }
+}
+function oracleLiveFrame(frame2, identities, indices) {
+  let size = 0;
+  for (const slot of frame2.order) size += (slot.kind === "region" ? slot.corners : slot.vertices).length;
+  const vertices = new Float64Array(size);
+  const tint = new Float64Array(indices.size * 4);
+  const drawOrder = new Int32Array(frame2.order.length);
+  let offset = 0;
+  const attachments = frame2.order.map((slot, index) => {
+    const points = slot.kind === "region" ? slot.corners : slot.vertices;
+    const slotIndex = indices.get(slot.slot);
+    if (slotIndex === void 0) throw new Error(`LIVE_FRAME_SLOT: drawn slot "${slot.slot}" has no setup index`);
+    vertices.set(points, offset);
+    tint.set(slot.tint, slotIndex * 4);
+    drawOrder[index] = index;
+    const identity = identities.get(slot.slot);
+    if (!identity) throw new Error(`LIVE_FRAME_IDENTITY: drawn slot "${slot.slot}" has no coherent identity`);
+    const metadata = {
+      slot: slot.slot,
+      slotIndex,
+      attachment: identity.attachment,
+      skin: identity.skin,
+      placeholder: null,
+      kind: slot.kind,
+      region: slot.kind === "region" ? slot.region : null,
+      page: slot.page,
+      pma: slot.pma,
+      blend: slot.blend,
+      offset,
+      count: points.length,
+      uvs: slot.uvs,
+      triangles: slot.kind === "mesh" ? slot.triangles : [],
+      dark: slot.dark ?? null,
+      clip: slot.clip ?? null
+    };
+    offset += points.length;
+    return metadata;
+  });
+  const live = { generation: frame2.generation ?? 0, count: attachments.length, drawOrder, vertices, tint, attachments };
+  liveDrawings.set(live, frame2);
+  return live;
+}
 const DEFAULT_ENVIRONMENT = Object.freeze({ wind: Object.freeze([1, 0]), gravity: Object.freeze([0, 1]) });
 function setEaseOption(call, options) {
   const ease = options?.ease;
@@ -9296,6 +11097,14 @@ class RigPlayer {
   setup = null;
   seekCache = null;
   poseGeneration = 0;
+  runtimeModel = null;
+  runtimeFrames = null;
+  runtimeReadback = null;
+  runtimeCompletionClock = { trackTime: 0 };
+  poserLabel = "oracle: not selected";
+  oracleOnly;
+  liveChecks;
+  liveDisposed = false;
   cachedIdentity = null;
   cachedIdentityGen = -1;
   setList;
@@ -9335,6 +11144,9 @@ class RigPlayer {
   constructor(root, assets, options = {}) {
     const read = assets.document;
     this.read = read;
+    if (options.poser !== void 0 && options.poser !== "auto" && options.poser !== "oracle") throw new Error(`poser must be auto or oracle, got ${String(options.poser)}`);
+    this.oracleOnly = options.poser === "oracle";
+    this.liveChecks = options.liveFrameChecks ?? false;
     this.skinName = options.skin;
     this.view = options.skin === void 0 ? underNoSkin(read.doc) : underSkin(read.doc, options.skin);
     this.source = frameSource(this.view, read.parsed);
@@ -9351,6 +11163,7 @@ class RigPlayer {
     this.poseGeneration = 0;
     this.cachedIdentity = null;
     this.active = this.create(options.mode ?? "dom");
+    this.selectRuntime();
   }
   /**
    * How the player draws. Setting it swaps the renderer without reloading
@@ -9395,7 +11208,7 @@ class RigPlayer {
   }
   /** The player's time — the running sum of the steps since `play` (or the last `seek`). */
   get time() {
-    return this.tracks?.trackTime ?? this.track?.trackTime ?? 0;
+    return this.runtimeFrames?.pose.trackTime ?? this.tracks?.trackTime ?? this.track?.trackTime ?? 0;
   }
   /**
    * Plays `name` on a track — track 0 by default, which is what `play(name)`
@@ -9420,6 +11233,8 @@ class RigPlayer {
     const plain = track === 0 && mix === 0 && alpha === 1 && !additive;
     if (!plain) this.beyondBase = true;
     if (this.tracks === null && plain && !this.trackMode) {
+      if (this.tryRuntimePlay(name, loop)) return;
+      this.oracle("animation not supported by the runtime");
       this.animation = name;
       this.loop = loop;
       this.track = openTrack(this.view, name, { loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
@@ -9494,6 +11309,11 @@ class RigPlayer {
   }
   /** `track`'s current entry, or null where it plays nothing (and before `play`). */
   entry(track = 0) {
+    if (this.runtimeFrames !== null) {
+      if (track !== 0 || this.animation === null) return null;
+      const pose = this.runtimeFrames.pose;
+      return { animation: this.animation, loop: this.loop, trackTime: pose.trackTime, animationTime: pose.time, duration: this.runtimeFrames.model.animation(this.animation).duration, alpha: 1, additive: false };
+    }
     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, alpha: view.alpha, additive: view.additive };
@@ -9517,6 +11337,7 @@ class RigPlayer {
    * `seekStep` of time played — which `tracks: true` avoids entirely.
    */
   compose() {
+    this.oracle("track composition");
     if (this.tracks !== null) return this.tracks;
     this.clearSeekCache();
     const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
@@ -9629,6 +11450,7 @@ class RigPlayer {
    * there is nothing to move.
    */
   moved(motion) {
+    if (this.runtimeFrames !== null && Number.isFinite(motion.x ?? 0) && Number.isFinite(motion.y ?? 0) && Number.isFinite(motion.rotation ?? 0)) return;
     const live = this.stepper();
     if (!live) return;
     const x = motion.x ?? 0;
@@ -9657,6 +11479,16 @@ class RigPlayer {
     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)}`);
     if (this.beyondBase) 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");
+    if (this.runtimeFrames !== null) {
+      const steps2 = Math.floor(time / this.seekStep);
+      let replayTime = 0;
+      for (let i = 0; i < steps2; i++) replayTime += this.seekStep;
+      const rest2 = time - replayTime;
+      if (rest2 > 0) replayTime += rest2;
+      this.runtimeFrames.pose.trackTime = replayTime;
+      this.applyRuntimeTime();
+      return;
+    }
     this.easing = null;
     const cache = this.ensureSeekCache();
     const stepper = this.tracks ?? this.track;
@@ -9771,6 +11603,7 @@ class RigPlayer {
   }
   /** What is open: the tracks, the single track, or nothing before `play`. */
   stepper() {
+    this.oracle("oracle track operation");
     return this.tracks ?? this.track;
   }
   /** A newly opened track or tracks answer the environment the player stands in; one never set leaves it untouched. */
@@ -9810,6 +11643,33 @@ class RigPlayer {
    * the events and `time` stay on the steps themselves (#103).
    */
   advance(dt) {
+    if (this.runtimeFrames !== null) {
+      const step2 = dt * this.timeScale;
+      if (this.paused || !(step2 > 0)) return;
+      if (!Number.isFinite(step2)) throw new Error(`advance step must be finite, got ${String(step2)}`);
+      const before2 = this.runtimeFrames.pose.trackTime;
+      const duration = this.runtimeFrames.model.animations.get(this.animation).duration;
+      this.runtimeFrames.pose.trackTime += step2;
+      this.lastStep = step2;
+      this.applyRuntimeTime();
+      const completionClock = this.runtimeCompletionClock;
+      if (this.listeners.event.size > 0) {
+        const events = this.runtimeFrames.pose.events.slice();
+        for (const key of events) {
+          const payload2 = { name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, track: 0 };
+          for (const listener of this.listeners.event) listener(payload2);
+        }
+      }
+      if (this.listeners.complete.size > 0) {
+        const after = completionClock.trackTime;
+        const complete = this.loop ? duration === 0 || Math.floor(after / duration) > Math.floor(before2 / duration) : before2 < duration && after >= duration;
+        if (complete) {
+          const payload2 = { animation: this.animation, track: 0 };
+          for (const listener of this.listeners.complete) listener(payload2);
+        }
+      }
+      return;
+    }
     if (this.pose === null) return;
     const step = dt * this.timeScale;
     if (this.paused || !(step > 0)) return;
@@ -9833,6 +11693,11 @@ class RigPlayer {
   }
   /** Draws the pose the player holds. */
   draw() {
+    if (this.runtimeFrames !== null) {
+      this.runtimeFrames.update(this.poseGeneration, this.color, this.draws, false);
+      this.renderer.render(this.runtimeFrames.live);
+      return;
+    }
     if (this.pose === null) return;
     this.renderer.render(this.posedFrame());
   }
@@ -9853,14 +11718,27 @@ class RigPlayer {
     if (name === this.skinName) return;
     if (this.beyondBase) 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.oracle("skin change");
     this.view = view;
     this.source = frameSource(view, this.read.parsed);
+    this.selectRuntime();
     this.skinName = name;
     this.setup = null;
     this.easing = null;
     this.clearSeekCache();
     if (this.animation !== null && (this.track !== null || this.tracks !== null)) {
       const time = this.time;
+      const animation = this.animation;
+      const animationTime = this.entry(0).animationTime;
+      if (this.tryRuntimePlay(animation, this.loop)) {
+        const frames = this.runtimeFrames;
+        frames.pose.restore(animation, time, animationTime);
+        this.poseGeneration++;
+        this.cachedIdentity = null;
+        this.runtimeReadback = null;
+        frames.update(this.poseGeneration, this.color, this.draws);
+        return;
+      }
       this.reopen();
       this.stepTo(time);
     } else if (this.rawPose !== null) {
@@ -10246,6 +12124,7 @@ class RigPlayer {
    * before changing anything, then applies their composition to the held pose.
    */
   activate(sets, physics, ease = 0) {
+    this.oracle("attachment sets");
     for (let i = 0; i < sets.length; i++) {
       for (let j = 0; j < i; j++) {
         const other = this.touched(sets[j]);
@@ -10347,6 +12226,7 @@ class RigPlayer {
   }
   set adjust(fn) {
     if (fn !== null && typeof fn !== "function") throw new Error(`adjust must be a function or null, got ${typeof fn}`);
+    this.oracle("local adjustment");
     this.adjustFn = fn;
     this.clearSeekCache();
     this.repose();
@@ -10359,6 +12239,10 @@ class RigPlayer {
    * changed, then `draw`. Nothing before `play`.
    */
   repose() {
+    if (this.runtimeFrames !== null) {
+      this.applyRuntimeTime();
+      return;
+    }
     this.clearSeekCache();
     const stepper = this.tracks ?? this.track;
     if (stepper === null || this.pose === null) return;
@@ -10401,7 +12285,7 @@ class RigPlayer {
    * mode; nothing is computed until called.
    */
   bounds() {
-    const frame2 = this.pose === null ? frameOf(this.source, this.posed(), this.color, this.draws) : this.posedFrame();
+    const frame2 = this.runtimeFrames !== null ? this.posedFrame() : 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;
@@ -10433,10 +12317,110 @@ class RigPlayer {
   }
   /** The pose the reads above see: the track's, or the setup pose before `play` (posed once). */
   posed() {
+    if (this.runtimeFrames !== null && this.animation !== null) {
+      if (this.runtimeReadback === null) {
+        const track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", clock: physicsClockStep });
+        this.runtimeReadback = this.time > 0 ? track.step(this.time) : track.first;
+      }
+      return this.runtimeReadback;
+    }
     if (this.pose !== null) return this.pose;
     if (this.setup === null) this.setup = poseRawSetup(this.view);
     return this.activeSet === null ? this.setup : applySetToPose(this.view, this.setup, this.activeSet);
   }
+  /** Selected poser, including the named reason when the oracle is required. */
+  get poser() {
+    return this.runtimeFrames !== null ? "runtime" : this.poserLabel === "runtime" ? "oracle: no runtime animation is active" : this.poserLabel;
+  }
+  selectRuntime() {
+    this.runtimeModel = null;
+    if (this.oracleOnly) {
+      this.poserLabel = "oracle: explicitly selected";
+      return;
+    }
+    try {
+      this.runtimeModel = compileRuntime(this.view);
+      this.poserLabel = this.trackMode ? "oracle: track composition" : this.adjustFn !== null ? "oracle: local adjustment" : "runtime";
+    } catch (error) {
+      if (!(error instanceof RuntimeRefusal)) throw error;
+      this.poserLabel = `oracle: ${error.message}`;
+    }
+  }
+  tryRuntimePlay(name, loop) {
+    if (this.runtimeModel === null) return false;
+    const blocked = this.trackMode ? "track composition" : this.adjustFn !== null ? "local adjustment" : this.activeSet !== null ? "attachment sets" : this.easing !== null ? "set easing" : this.env !== null ? "environment configuration" : null;
+    if (blocked !== null) {
+      this.poserLabel = `oracle: ${blocked}`;
+      return false;
+    }
+    if (!this.runtimeModel.animations.has(name)) {
+      const refused = this.runtimeModel.refused.find((value) => value.animation === name);
+      if (refused) this.poserLabel = `oracle: ${new RuntimeRefusal(refused.missing).message}`;
+      return false;
+    }
+    const frames = this.runtimeFrames ?? new RuntimeFrames(this.source, this.runtimeModel);
+    frames.pose.setAnimation(name);
+    frames.pose.apply(0);
+    this.runtimeFrames = frames;
+    this.runtimeCompletionClock = { trackTime: 0 };
+    this.animation = name;
+    this.loop = loop;
+    this.track = null;
+    this.tracks = null;
+    this.pose = null;
+    this.rawPose = null;
+    this.poserLabel = "runtime";
+    this.poseGeneration++;
+    this.cachedIdentity = null;
+    this.runtimeReadback = null;
+    frames.update(this.poseGeneration, this.color, this.draws);
+    return true;
+  }
+  applyRuntimeTime() {
+    const frames = this.runtimeFrames;
+    const duration = frames.model.animations.get(this.animation).duration;
+    const time = frames.pose.trackTime;
+    this.runtimeCompletionClock.trackTime = time;
+    frames.pose.apply(duration === 0 ? 0 : this.loop ? time % duration : Math.min(time, duration));
+    this.poseGeneration++;
+    this.cachedIdentity = null;
+    this.runtimeReadback = null;
+    frames.update(this.poseGeneration, this.color, this.draws);
+  }
+  /** Materialize the old track only at an operation stage 0 cannot execute. */
+  oracle(reason) {
+    if (this.runtimeFrames === null || this.animation === null) return;
+    const time = this.runtimeFrames.pose.trackTime;
+    const generation = this.poseGeneration;
+    this.runtimeFrames = null;
+    this.runtimeReadback = null;
+    if (this.poserLabel === "runtime") this.poserLabel = `oracle: ${reason}`;
+    this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
+    this.setRawPose(this.track.first);
+    if (time > 0) this.setRawPose(this.track.step(time));
+    this.poseGeneration = generation;
+    this.applyEnvironment(this.track);
+  }
+  /** Borrow buffers until the next pose mutation. Request posedFrame() to retain a snapshot. */
+  liveFrame() {
+    if (this.liveDisposed) throw new Error("LIVE_FRAME_DISPOSED: cannot borrow a frame after dispose");
+    let frame2;
+    if (this.runtimeFrames !== null) {
+      this.runtimeFrames.update(this.poseGeneration, this.color, this.draws, false);
+      frame2 = this.runtimeFrames.live;
+    } else {
+      const identities = new Map(this.slotIdentity().slots.map((slot) => [slot.slot, slot]));
+      frame2 = oracleLiveFrame(this.posedFrame(), identities, this.source.slotIndex);
+    }
+    return this.liveChecks ? this.checkedFrame(frame2) : frame2;
+  }
+  /** Keep lease closures out of the production borrow's call environment. */
+  checkedFrame(frame2) {
+    const generation = this.poseGeneration;
+    const state = this.runtimeFrames;
+    const revision = state?.revision;
+    return checkedLiveFrame(frame2, () => this.poseGeneration === generation && (state === null || state.revision === revision) ? generation : -1);
+  }
   /** Monotonic pose generation counter matching `posedFrame().generation` and `slotIdentity().generation`. */
   get generation() {
     return this.poseGeneration;
@@ -10450,7 +12434,8 @@ class RigPlayer {
    */
   posedFrame(slots) {
     const draws = slots === void 0 ? this.draws : slots === null ? () => true : typeof slots === "function" ? slots : predicateOf(slots);
-    const frame2 = this.pose === null ? { order: [] } : frameOf(this.source, this.pose, this.color, draws);
+    if (this.runtimeFrames !== null) this.runtimeFrames.update(this.poseGeneration, this.color, this.draws, false);
+    const frame2 = this.runtimeFrames !== null ? this.runtimeFrames.snapshot(draws) : this.pose === null ? { order: [] } : frameOf(this.source, this.pose, this.color, draws);
     Object.defineProperty(frame2, "generation", {
       value: this.poseGeneration,
       enumerable: false,
@@ -10474,7 +12459,7 @@ class RigPlayer {
     }
     const setupPose = this.setup ?? (this.setup = poseRawSetup(this.view));
     const pose = this.posed();
-    const raw = this.rawPose ?? setupPose;
+    const raw = this.runtimeFrames !== null ? pose : this.rawPose ?? setupPose;
     const shownBySlot = new Map(pose.shown.map((s) => [s.slot, s]));
     const setupShownSlots = new Set(setupPose.shown.map((s) => s.slot));
     const rawRowBySlot = new Map(raw.slots.map((r) => [r[0], r]));
@@ -10572,13 +12557,17 @@ class RigPlayer {
       }
       return result;
     }
-    if (this.track !== null && this.animation !== null) {
+    if ((this.track !== null || this.runtimeFrames !== null) && this.animation !== null) {
       return checkAnimation(this.animation, animationTime) === true;
     }
     return false;
   }
   /** Removes the renderer's elements and hands its GPU pages back. The assets stay the caller's. */
   dispose() {
+    this.runtimeFrames = null;
+    this.runtimeReadback = null;
+    this.liveDisposed = true;
+    this.poseGeneration++;
     this.renderer.dispose();
     this.clearSeekCache();
     this.cachedIdentity = null;