@rig-c/play 1.20.0 → 1.21.1

package/dist/index.js

@@ -1556,19 +1556,19 @@ function readPathTimelines(value, label, declared, problems) {
 function pathWorld(state, c, g) {
   return worldVertices(g.vertices, state.world.get(c.slotBone), state.world, g.exact === true ? EXACT_COORDS : Math.fround);
 }
-function onLineBefore(p, x1, y1, x2, y2, out, o) {
+function onLineBefore$1(p, x1, y1, x2, y2, out, o) {
   const r = Math.atan2(y2 - y1, x2 - x1);
   out[o] = x1 + p * Math.cos(r);
   out[o + 1] = y1 + p * Math.sin(r);
   out[o + 2] = r;
 }
-function onLinePast(p, x0, y0, x1, y1, out, o) {
+function onLinePast$1(p, x0, y0, x1, y1, out, o) {
   const r = Math.atan2(y1 - y0, x1 - x0);
   out[o] = x1 + p * Math.cos(r);
   out[o + 1] = y1 + p * Math.sin(r);
   out[o + 2] = r;
 }
-function onCurve(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent) {
+function onCurve$1(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent) {
   if (Number.isNaN(p)) {
     out[o] = x1;
     out[o + 1] = y1;
@@ -1619,12 +1619,12 @@ function positionsOf(state, c, g, spaces, wantsTangent) {
       } else if (p < 0) {
         const [x13, y13] = P(1);
         const [x23, y23] = P(2);
-        onLineBefore(p, x13, y13, x23, y23, out, o);
+        onLineBefore$1(p, x13, y13, x23, y23, out, o);
         continue;
       } else if (p > total2) {
         const [x0, y0] = P(n - 3);
         const [x13, y13] = P(n - 2);
-        onLinePast(p - total2, x0, y0, x13, y13, out, o);
+        onLinePast$1(p - total2, x0, y0, x13, y13, out, o);
         continue;
       }
       for (; ; curve++) {
@@ -1643,7 +1643,7 @@ function positionsOf(state, c, g, spaces, wantsTangent) {
       const [cx12, cy12] = q(1);
       const [cx22, cy22] = q(2);
       const [x22, y22] = q(3);
-      onCurve(p, x12, y12, cx12, cy12, cx22, cy22, x22, y22, out, o, wantsTangent || i > 0 && space === 0);
+      onCurve$1(p, x12, y12, cx12, cy12, cx22, cy22, x22, y22, out, o, wantsTangent || i > 0 && space === 0);
     }
     return out;
   }
@@ -1671,11 +1671,11 @@ function positionsOf(state, c, g, spaces, wantsTangent) {
       curve = 0;
       segment = 0;
     } else if (p < 0) {
-      onLineBefore(p, chain[0], chain[1], chain[2], chain[3], out, o);
+      onLineBefore$1(p, chain[0], chain[1], chain[2], chain[3], out, o);
       continue;
     } else if (p > total) {
       const e = chain.length;
-      onLinePast(p - total, chain[e - 4], chain[e - 3], chain[e - 2], chain[e - 1], out, o);
+      onLinePast$1(p - total, chain[e - 4], chain[e - 3], chain[e - 2], chain[e - 1], out, o);
       continue;
     }
     for (; ; curve++) {
@@ -1738,7 +1738,7 @@ function positionsOf(state, c, g, spaces, wantsTangent) {
       }
       break;
     }
-    onCurve(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent || i > 0 && space === 0);
+    onCurve$1(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent || i > 0 && space === 0);
   }
   return out;
 }
@@ -2114,10 +2114,10 @@ function posedPhysics(records, timelines, t, last, active, plant = {}, wrapped =
 function resetCrossed(keys, last, t, wrapped = false) {
   return wrapped ? keys.some((k) => k.time > last || k.time <= t) : keys.some((k) => last < k.time && k.time <= t);
 }
-function freshPhysicsState() {
+function freshPhysicsState$1() {
   return { pending: true, lastTime: 0, remaining: 0, ux: 0, uy: 0, cx: 0, cy: 0, tx: 0, ty: 0, xOffset: 0, xLag: 0, xVelocity: 0, yOffset: 0, yLag: 0, yVelocity: 0, rotateOffset: 0, rotateLag: 0, rotateVelocity: 0, scaleOffset: 0, scaleLag: 0, scaleVelocity: 0 };
 }
-function resetPhysicsState(s, time) {
+function resetPhysicsState$1(s, time) {
   s.remaining = 0;
   s.lastTime = time;
   s.pending = true;
@@ -2127,19 +2127,21 @@ function resetPhysicsState(s, time) {
   s.scaleOffset = s.scaleLag = s.scaleVelocity = 0;
 }
 const DEFAULT_PHYSICS_ENVIRONMENT = Object.freeze({ wind: Object.freeze([1, 0]), gravity: Object.freeze([0, 1]) });
-function translatePhysics(ctx, x, y) {
-  for (const s of ctx.states.values()) {
+function translatePhysics(ctx, x, y, scope) {
+  for (const [name, s] of ctx.states) {
+    if (scope !== void 0 && !scope.has(name)) continue;
     s.ux -= x;
     s.uy -= y;
     s.cx -= x;
     s.cy -= y;
   }
 }
-function rotatePhysics(ctx, x, y, degrees) {
+function rotatePhysics(ctx, x, y, degrees, scope) {
   const r = degrees * RUNTIME_RAD;
   const cos = Math.cos(r);
   const sin = Math.sin(r);
-  for (const s of ctx.states.values()) {
+  for (const [name, s] of ctx.states) {
+    if (scope !== void 0 && !scope.has(name)) continue;
     const dx = s.cx - x;
     const dy = s.cy - y;
     const tx = dx * cos - dy * sin - dx;
@@ -2153,13 +2155,13 @@ function rotatePhysics(ctx, x, y, degrees) {
 function physicsState(ctx, name) {
   let s = ctx.states.get(name);
   if (s === void 0) {
-    s = freshPhysicsState();
+    s = freshPhysicsState$1();
     ctx.states.set(name, s);
   }
   return s;
 }
-const PI2 = RUNTIME_PI * 2;
-const INV_PI2 = 1 / PI2;
+const PI2$1 = RUNTIME_PI * 2;
+const INV_PI2$1 = 1 / PI2$1;
 function physicsDrives(r) {
   return { x: r.x > 0, y: r.y > 0, rotateOrShearX: r.rotate > 0 || r.shearX > 0, scaleX: r.scaleX > 0 };
 }
@@ -2169,7 +2171,7 @@ function stepPhysics(r, w, length, ctx) {
   const s = physicsState(ctx, r.name);
   const { x, y, rotateOrShearX, scaleX } = physicsDrives(r);
   const l = length;
-  if (ctx.phase === "reset") resetPhysicsState(s, ctx.time);
+  if (ctx.phase === "reset") resetPhysicsState$1(s, ctx.time);
   const delta = Math.max(ctx.time - s.lastTime, 0);
   const shown = Math.max(0, 1 - s.remaining / r.step);
   s.remaining += delta;
@@ -2246,7 +2248,7 @@ function stepPhysics(r, w, length, ctx) {
         mr = (r.rotate + r.shearX) * mix;
         const lagged = s.rotateLag * shown;
         let rr = Math.atan2(dy + s.ty, dx + s.tx) - ca - (s.rotateOffset - lagged) * mr;
-        s.rotateOffset += (rr - Math.ceil(rr * INV_PI2 - 0.5) * PI2) * i;
+        s.rotateOffset += (rr - Math.ceil(rr * INV_PI2$1 - 0.5) * PI2$1) * i;
         rr = (s.rotateOffset - lagged) * mr + ca;
         c = Math.cos(rr);
         sn = Math.sin(rr);
@@ -2353,7 +2355,7 @@ function stepPhysicsRecords(records, keyed, t, active, ctx, before) {
   ctx.last = t;
   ctx.setupRecords = new Map(physics.map((r) => [r.name, r]));
   ctx.keyedNow = new Set(keyed.flatMap((tl) => tl.kind === "reset" ? [] : (tl.name === EVERY_GLOBAL_PHYSICS ? unnamedPhysicsTargets(physics, tl.kind, (r) => physicsActive(r, active)).map((r) => r.name) : [tl.name]).map((n) => `${n}/${tl.kind === "mass" ? "massInverse" : tl.kind}`)));
-  for (const name of posed.reset) resetPhysicsState(physicsState(ctx, name), before);
+  for (const name of posed.reset) resetPhysicsState$1(physicsState(ctx, name), before);
   return records.map((r) => r.kind === "physics" ? posed.records.get(r.name) : r);
 }
 function freshStepContext(step) {
@@ -2638,7 +2640,7 @@ function applySliderPhysics(r, at, alpha, target) {
     const named = target.records.get(tl.name);
     const targets = tl.name === EVERY_GLOBAL_PHYSICS ? unnamedPhysicsTargets([...target.records.values()], tl.kind, target.active) : named !== void 0 && target.active(named) ? [named] : [];
     if (tl.kind === "reset") {
-      if (!rules.sliderPhysicsResetIsDead && tl.keys.some((k) => k.time <= at)) for (const p of targets) resetPhysicsState(physicsState(target.ctx, p.name), target.ctx.time);
+      if (!rules.sliderPhysicsResetIsDead && tl.keys.some((k) => k.time <= at)) for (const p of targets) resetPhysicsState$1(physicsState(target.ctx, p.name), target.ctx.time);
       continue;
     }
     const i = keyIndexAt(tl.keys, at);
@@ -5248,17 +5250,30 @@ function setEnvironmentOn(ctx, env, who) {
 function environmentOf(ctx) {
   return ctx.env ?? DEFAULT_PHYSICS_ENVIRONMENT;
 }
-function translateOn(ctx, x, y, who) {
+function checkedPhysicsScope(doc, scope, who) {
+  if (scope === void 0) return void 0;
+  if (!Array.isArray(scope)) throw new CoreInputError(`${who} physics movement scope is ${String(scope)}, not an array of physics constraint names`);
+  const selected = /* @__PURE__ */ new Set();
+  for (const name of scope) {
+    if (typeof name !== "string") throw new CoreInputError(`${who} physics movement scope name ${String(name)} is not a string`);
+    const constraint = doc.constraints.find((c) => c.kind === "physics" && c.name === name) ?? doc.constraints.find((c) => c.name === name);
+    if (constraint === void 0) throw new CoreInputError(`${who} physics movement scope: no constraint "${name}"; this document declares [${doc.constraints.map((c) => c.name).join(", ")}]`);
+    if (constraint.kind !== "physics") throw new CoreInputError(`${who} physics movement scope: constraint "${name}" is ${constraint.kind}, not physics`);
+    selected.add(name);
+  }
+  return selected;
+}
+function translateOn(ctx, x, y, who, scope) {
   for (const [k, v] of [["x", x], ["y", y]]) {
     if (typeof v !== "number" || !Number.isFinite(v)) throw new CoreInputError(`${who} physicsTranslate's ${k} is ${String(v)}, not a finite distance in the skeleton's world`);
   }
-  translatePhysics(ctx, x, y);
+  translatePhysics(ctx, x, y, scope);
 }
-function rotateOn(ctx, x, y, degrees, who) {
+function rotateOn(ctx, x, y, degrees, who, scope) {
   for (const [k, v] of [["x", x], ["y", y], ["degrees", degrees]]) {
     if (typeof v !== "number" || !Number.isFinite(v)) throw new CoreInputError(`${who} physicsRotate's ${k} is ${String(v)}, not a finite number`);
   }
-  rotatePhysics(ctx, x, y, degrees);
+  rotatePhysics(ctx, x, y, degrees, scope);
 }
 function loopedTime(trackTime, duration) {
   return duration === 0 ? 0 : trackTime % duration;
@@ -5468,13 +5483,13 @@ class Track {
     this.live("clearPhysicsParameters");
     this.parameters.clear(name);
   }
-  physicsTranslate(x, y) {
+  physicsTranslate(x, y, scope) {
     this.live("physicsTranslate");
-    translateOn(this.track.ctx, x, y, "the live track's");
+    translateOn(this.track.ctx, x, y, "the live track's", checkedPhysicsScope(this.track.doc, scope, "the live track's"));
   }
-  physicsRotate(x, y, degrees) {
+  physicsRotate(x, y, degrees, scope) {
     this.live("physicsRotate");
-    rotateOn(this.track.ctx, x, y, degrees, "the live track's");
+    rotateOn(this.track.ctx, x, y, degrees, "the live track's", checkedPhysicsScope(this.track.doc, scope, "the live track's"));
   }
   /** A refused track refuses every call that would move it, naming the step it was refused at. */
   live(call) {
@@ -6426,13 +6441,13 @@ class Tracks {
     this.live("clearPhysicsParameters");
     this.parameters.clear(name);
   }
-  physicsTranslate(x, y) {
+  physicsTranslate(x, y, scope) {
     this.live("physicsTranslate");
-    translateOn(this.path.ctx, x, y, "the live tracks'");
+    translateOn(this.path.ctx, x, y, "the live tracks'", checkedPhysicsScope(this.doc, scope, "the live tracks'"));
   }
-  physicsRotate(x, y, degrees) {
+  physicsRotate(x, y, degrees, scope) {
     this.live("physicsRotate");
-    rotateOn(this.path.ctx, x, y, degrees, "the live tracks'");
+    rotateOn(this.path.ctx, x, y, degrees, "the live tracks'", checkedPhysicsScope(this.doc, scope, "the live tracks'"));
   }
   live(call) {
     if (this.refused !== null) throw new CoreInputError(`the live tracks were refused at ${this.refused}, after their entries and physics had moved; open them again (${call} not made)`);
@@ -9030,26 +9045,30 @@ function compileCurve(keys, channels) {
   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;
+    const av = a.values;
+    if (av !== void 0) for (let c = 0; c < channels; c++) values2[i * channels + c] = av[c];
+    const curve = a.curve ?? "stepped";
     kinds[i] = curve === "linear" ? CURVE_LINEAR : curve === "stepped" ? CURVE_STEPPED : CURVE_BEZIER;
     if (typeof curve === "string" || i + 1 >= n) continue;
     const b = keys[i + 1];
+    const aStated = a.stated;
+    const bStated = b.stated;
+    const bValues = b.values;
     for (let c = 0; c < channels; c++) {
-      const inner = bezierPolyline(a.stated.time, a.stated.values[c], curve[c * 4], curve[c * 4 + 1], curve[c * 4 + 2], curve[c * 4 + 3], b.stated.time, b.stated.values[c]);
+      const inner = bezierPolyline(aStated.time, aStated.values[c], curve[c * 4], curve[c * 4 + 1], curve[c * 4 + 2], curve[c * 4 + 3], bStated.time, bStated.values[c]);
       const o = (i * channels + c) * POLYLINE;
       polylines[o] = a.time;
-      polylines[o + 1] = a.values[c];
+      polylines[o + 1] = av[c];
       for (let q = 0; q < inner.length; q++) polylines[o + 2 + q] = inner[q];
       polylines[o + POLYLINE - 2] = b.time;
-      polylines[o + POLYLINE - 1] = b.values[c];
+      polylines[o + POLYLINE - 1] = bValues[c];
     }
   }
   return { keys: n, channels, times: times2, values: values2, kinds, polylines };
 }
 function keyAt(curve, cursors, slot, t) {
   const times2 = curve.times;
-  let i = cursors[slot];
+  let i = Math.min(cursors[slot], curve.keys - 1);
   while (i >= 0 && times2[i] > t) i--;
   while (i + 1 < curve.keys && times2[i + 1] <= t) i++;
   cursors[slot] = i;
@@ -9104,7 +9123,7 @@ function deformFraction(curve, i, t) {
   if (q === POLYLINE - 2) return y0 + (1 - y0) * (t - x0) / (x1 - x0);
   return y0 + (t - x0) / (x1 - x0) * (y1 - y0);
 }
-const RUNTIME_STAGE = 2;
+const RUNTIME_STAGE = 9;
 function missingText(m) {
   return `${m.feature}: ${m.detail}${m.animation === null ? "" : ` (animation "${m.animation}")`}`;
 }
@@ -9147,6 +9166,15 @@ const SCALE_Y_VOLUME = 2;
 const IK_BEND_POSITIVE = 1;
 const IK_COMPRESS = 2;
 const IK_STRETCH = 4;
+const PATH_POSITION_FIXED = 0;
+const PATH_POSITION_PERCENT = 1;
+const PATH_SPACING_LENGTH = 0;
+const PATH_SPACING_FIXED = 1;
+const PATH_SPACING_PERCENT = 2;
+const PATH_SPACING_PROPORTIONAL = 3;
+const PATH_ROTATE_TANGENT = 0;
+const PATH_ROTATE_CHAIN = 1;
+const PATH_ROTATE_CHAIN_SCALE = 2;
 const RAD = RUNTIME_PI / 180;
 const BONE_KINDS = {
   rotate: [[L_ROTATION, 0]],
@@ -9160,7 +9188,7 @@ const BONE_KINDS = {
   shearx: [[L_SHEAR_X, 0]],
   sheary: [[L_SHEAR_Y, 0]]
 };
-const COLOUR_CHANNELS = { rgba: [0, 1, 2, 3], rgb: [0, 1, 2], alpha: [3] };
+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] };
 class Refusals {
   constructor(admitted) {
     this.admitted = admitted;
@@ -9182,7 +9210,7 @@ class Refusals {
 function compileRuntime(doc, options = {}, plant = {}) {
   const refusals = new Refusals(new Set(plant.admit ?? []));
   const ignoreEvents = (options.ignore ?? []).includes("events");
-  const absentWhy = constraintsAbsentWhy(doc);
+  const absentWhy = constraintsAbsentWhy(doc) ?? pathAnimationsWhy(doc) ?? steppedPreviousPassWhy(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]));
@@ -9191,6 +9219,12 @@ function compileRuntime(doc, options = {}, plant = {}) {
     if (i === void 0) throw new RuntimeInputError(`bone "${name}" is not a bone of this document (readModel refuses it first)`);
     return i;
   };
+  const slotIndex = new Map(doc.slots.map((s, i) => [s.name, i]));
+  const slotIndexOf = (name) => {
+    const i = slotIndex.get(name);
+    if (i === void 0) throw new RuntimeInputError(`slot "${name}" is not a slot of this document (readModel refuses it first)`);
+    return i;
+  };
   const active = activeBones(doc);
   const parents = new Int32Array(nb);
   const modes = new Uint8Array(nb);
@@ -9225,27 +9259,35 @@ function compileRuntime(doc, options = {}, plant = {}) {
   }
   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 records = constraintRecords(doc);
+  const skipped = /* @__PURE__ */ new Set();
+  records.forEach((r, i) => {
+    if (constraintInactiveWhy(r, active) !== null) skipped.add(i);
+  });
+  const pathPlan = records.some((r) => r.kind === "path") ? slotBonePlan(doc.bones, active, records, skipped) : /* @__PURE__ */ new Map();
+  for (const r of records) {
     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 bones = Int32Array.from((r.kind === "physics" ? [r.bone] : r.kind === "slider" ? r.timelines.bones.filter((t) => t.timelines.length > 0).map((t) => t.name) : r.bones).map(indexOf));
     const index = constraints.length;
+    if (r.kind === "physics") {
+      constraints.push({ kind: "physics", name: r.name, index, applied, bones, setup: r });
+      continue;
+    }
+    if (r.kind === "slider") {
+      constraints.push({ kind: "slider", name: r.name, index, applied, bones, setup: r, bone: r.bone === null ? -1 : indexOf(r.bone), property: TRANSFORM_PROPERTIES.indexOf(r.property), animation: null });
+      continue;
+    }
+    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`);
     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`);
-        }
-      }
+    else if (r.kind === "path") {
+      constraints.push(compilePath(r, index, applied, bones, indexOf, slotIndexOf, pathPlan.get(index) ?? null));
+    } else {
+      const noScaleWorld = !r.localTarget && bones.some((b) => parents[b] >= 0 && (modes[b] === MODE_NO_SCALE || modes[b] === MODE_NO_SCALE_OR_REFLECTION));
+      const t = compileTransform(r, index, applied && !(plant.omitLocalTransform && (r.localSource || r.localTarget)) && !(plant.omitNoScaleWorldTransform && noScaleWorld) && !(plant.omitAdditiveTransform && r.additive), bones, indexOf);
       constraints.push(t);
     }
   }
+  const hasClipping = doc.skins.some((s) => Object.values(s.attachments).some((table) => Object.values(table).some((at) => at.geometry?.kind === "clipping")));
   const attachments = [];
   let vertexCount = 0;
   let deformCount = 0;
@@ -9272,8 +9314,9 @@ function compileRuntime(doc, options = {}, plant = {}) {
     const at = { timeline: timelineIdentity(slot.name, shown), deformOffset: deformCount, 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") {
+    if (g?.kind === "clipping") {
+      made = { ...meshAttachment(at, g.vertices, indexOf, plant.bindingIndex, nb), clip: { end: g.end, inverse: g.inverse, convex: g.convex } };
+    } 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 {
@@ -9307,8 +9350,18 @@ function compileRuntime(doc, options = {}, plant = {}) {
       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);
+    } else if (g?.kind === "path") {
+      made = pathAttachment(at, g.vertices, indexOf, plant.bindingIndex, nb);
     }
     if (made === null) made = vertexAttachment(at, DRAW_NONE, new Float64Array(0), 0);
+    if (hasClipping) {
+      if (g?.kind === "region") made = { ...made, clipTopology: { triangles: new Int32Array([0, 1, 2, 2, 3, 0]), uvs: new Float64Array([0, 1, 0, 0, 1, 0, 1, 1]) } };
+      else if (g?.kind === "mesh" || g?.kind === "linkedmesh") {
+        const mesh = g.kind === "mesh" ? g : doc.skins.find((s) => s.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
+        if (mesh?.kind !== "mesh") throw new RuntimeInputError("clipping topology: linked source is not a mesh (readModel refuses it first)");
+        made = { ...made, clipTopology: { triangles: Int32Array.from(mesh.triangles), uvs: Float64Array.from(mesh.uvs) } };
+      }
+    }
     attachments.push(made);
     vertexCount += made.count;
     deformCount += made.deformCount;
@@ -9328,7 +9381,21 @@ function compileRuntime(doc, options = {}, plant = {}) {
       blend: readBlend(slot)
     };
   });
-  const slotIndex = new Map(doc.slots.map((s, i) => [s.name, i]));
+  let hasPath = false;
+  let maxPathSpaces = 0;
+  let maxPathVertices = 0;
+  for (const c of constraints) {
+    if (c.kind !== "path") continue;
+    hasPath = true;
+    c.attachment = c.setup.path === null ? -1 : slots[c.slot].setupAttachment;
+    const spaceCount = c.rotateMode === PATH_ROTATE_TANGENT ? c.bones.length : c.bones.length + 1;
+    if (spaceCount > maxPathSpaces) maxPathSpaces = spaceCount;
+    if (c.attachment >= 0) {
+      const at = attachments[c.attachment];
+      c.pathVertices = at.bindingCounts.length > 0 ? at.bindingCounts.length * 2 : at.local.length;
+      if (c.pathVertices > maxPathVertices) maxPathVertices = c.pathVertices;
+    }
+  }
   const animations = /* @__PURE__ */ new Map();
   const refused = [];
   let cursorMax = 0;
@@ -9341,11 +9408,25 @@ function compileRuntime(doc, options = {}, plant = {}) {
       cursorMax = Math.max(cursorMax, compiled.cursors);
     }
   }
+  for (const c of constraints) if (c.kind === "slider") {
+    const a = animations.get(c.setup.animation);
+    if (a !== void 0) c.animation = a;
+    else for (const m of refusals.byAnimation.get(c.setup.animation) ?? []) refusals.note(m.feature, `slider "${c.name}" applies refused animation "${c.setup.animation}": ${m.detail}`);
+  }
   if (refusals.model.length > 0) throw new RuntimeRefusal(refusals.model);
   const names = doc.animations.map((a) => a.name);
   return {
+    omitPhysics: plant.omitPhysics === true,
+    sliderAsTrack: plant.sliderAsTrack === true,
     omitDeform: plant.omitDeform === true,
     deformAfterWeights: plant.deformAfterWeights === true,
+    omitPath: plant.omitPath === true,
+    ignorePhysicsScope: plant.ignorePhysicsScope === true,
+    omitDrawOrder: plant.omitDrawOrder === true,
+    omitDarkColour: plant.omitDarkColour === true,
+    hasPath,
+    maxPathSpaces,
+    maxPathVertices,
     deformCount,
     eventWrapOffByOne: plant.eventWrapOffByOne === true,
     restoreEventsFromStart: plant.restoreEventsFromStart === true,
@@ -9404,6 +9485,10 @@ function meshAttachment(at, vertices, indexOf, rewrite, bones) {
   }
   return { ...at, deformCount: ids.length * 2, 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 pathAttachment(at, vertices, indexOf, rewrite, bones) {
+  const m = meshAttachment(at, vertices, indexOf, rewrite, bones);
+  return { ...m, draw: DRAW_NONE, count: 0 };
+}
 function compileIk(r, index, applied, bones, indexOf) {
   return {
     kind: "ik",
@@ -9421,6 +9506,34 @@ function compileIk(r, index, applied, bones, indexOf) {
 function ikFlags(bendPositive, compress, stretch) {
   return (bendPositive ? IK_BEND_POSITIVE : 0) | (compress ? IK_COMPRESS : 0) | (stretch ? IK_STRETCH : 0);
 }
+function compilePath(r, index, applied, bones, indexOf, slotIndexOf, ev) {
+  return {
+    kind: "path",
+    name: r.name,
+    index,
+    applied,
+    bones,
+    slot: slotIndexOf(r.slot),
+    slotBone: indexOf(r.slotBone),
+    attachment: -1,
+    pathVertices: 0,
+    closed: r.path?.closed ?? false,
+    constantSpeed: r.path?.constantSpeed ?? true,
+    lengths: Float64Array.from(r.path?.lengths ?? []),
+    positionMode: r.positionMode === "fixed" ? PATH_POSITION_FIXED : PATH_POSITION_PERCENT,
+    spacingMode: r.spacingMode === "fixed" ? PATH_SPACING_FIXED : r.spacingMode === "percent" ? PATH_SPACING_PERCENT : r.spacingMode === "proportional" ? PATH_SPACING_PROPORTIONAL : PATH_SPACING_LENGTH,
+    rotateMode: r.rotateMode === "chain" ? PATH_ROTATE_CHAIN : r.rotateMode === "chainScale" ? PATH_ROTATE_CHAIN_SCALE : PATH_ROTATE_TANGENT,
+    offsetRotation: r.offsetRotation,
+    position: r.position,
+    spacing: r.spacing,
+    mixRotate: r.mixRotate,
+    mixX: r.mixX,
+    mixY: r.mixY,
+    slotEventAt: ev === null ? -1 : ev.at,
+    slotEventAfter: ev?.when === "after",
+    setup: r
+  };
+}
 function compileTransform(r, index, applied, bones, indexOf) {
   const fromProperty = [];
   const fromOffset = [];
@@ -9459,7 +9572,10 @@ function compileTransform(r, index, applied, bones, indexOf) {
     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
+    clamp: r.clamp,
+    localSource: r.localSource,
+    localTarget: r.localTarget,
+    additive: r.additive
   };
 }
 function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, doc, resolve) {
@@ -9469,21 +9585,52 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
   const deform = tl.attachments.filter((a) => a.deform !== null);
   const sequence = tl.attachments.filter((a) => a.sequence !== null);
   if (sequence.length > 0) refusals.note("sequence-timeline", `${sequence.length} sequence timeline(s): ${sequence.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${sequence.length > 3 ? ", …" : ""}`, name);
-  if (tl.drawOrder.length > 0) refusals.note("draw-order-timeline", `${tl.drawOrder.length} draw-order key(s)`, name);
+  let drawOrder = null;
+  if (tl.drawOrder.length > 0) {
+    const ns = slots.length;
+    const orders = new Int32Array(tl.drawOrder.length * ns).fill(-1);
+    const moved = new Uint8Array(ns);
+    for (let i = 0; i < tl.drawOrder.length; i++) {
+      const base = i * ns;
+      moved.fill(0);
+      for (const m of tl.drawOrder[i].moves) {
+        orders[base + m.slot + m.offset] = m.slot;
+        moved[m.slot] = 1;
+      }
+      for (let s = 0, d = 0; s < ns; s++) {
+        if (moved[s] !== 0) continue;
+        while (orders[base + d] !== -1) d++;
+        orders[base + d] = s;
+        d++;
+      }
+    }
+    drawOrder = { curve: compileCurve(tl.drawOrder, 0), cursor: cursors++, orders };
+  }
   const lastBy = (targets) => new Map(targets.map((t) => [t.name, t]));
   const bones = [];
-  for (const target of lastBy(tl.bones).values()) {
+  const byTarget = /* @__PURE__ */ new Map();
+  const compileBones = (target, forSlider) => {
+    const cached = byTarget.get(target);
+    if (cached !== void 0) return cached;
+    const keyed = [];
+    byTarget.set(target, keyed);
     const bone2 = boneIndex2.get(target.name);
-    if (bone2 === void 0) continue;
+    if (bone2 === void 0) return keyed;
     for (const t of target.timelines) {
       if (t.kind === "inherit") {
-        refusals.note("inherit-timeline", `bone "${target.name}" keys its inherit mode`, name);
+        if (!forSlider) refusals.note("inherit-timeline", `bone "${target.name}" keys its inherit mode`, name);
+        else for (const c of constraints) if (c.kind === "slider" && c.setup.animation === name) {
+          refusals.note("inherit-timeline", `slider "${c.name}" applies animation "${name}" whose bone "${target.name}" keys its inherit mode`);
+        }
         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])) });
+      keyed.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])) });
     }
-  }
+    return keyed;
+  };
+  for (const target of lastBy(tl.bones).values()) bones.push(...compileBones(target, false));
+  const sliderBones = constraints.some((c) => c.kind === "slider" && c.setup.animation === name) ? tl.bones.flatMap((target) => compileBones(target, true)) : [];
   const slotTimelines = [];
   const keyedSlots = [...lastBy(tl.slots).values()].flatMap((target) => {
     const si = slotIndex.get(target.name);
@@ -9495,8 +9642,6 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
       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) });
@@ -9509,12 +9654,37 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
       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 {
+    } else if (c.kind === "transform") {
       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 };
     }
   }
+  const sliders = constraints.map((c) => {
+    if (c.kind !== "slider") return null;
+    const keyed = anim.constraints.slider.find((t) => t.name === c.name);
+    if (keyed === void 0) return null;
+    return { time: keyed.time === null ? null : compileCurve(keyed.time, 1), mix: keyed.mix === null ? null : compileCurve(keyed.mix, 1), timeCursor: cursors++, mixCursor: cursors++ };
+  });
+  const paths = constraints.map((c) => {
+    if (c.kind !== "path") return null;
+    const keyed = anim.constraints.path.find((t) => t.name === c.name);
+    if (keyed === void 0) return null;
+    return {
+      position: keyed.position === void 0 ? null : compileCurve(keyed.position, 1),
+      spacing: keyed.spacing === void 0 ? null : compileCurve(keyed.spacing, 1),
+      mix: keyed.mix === void 0 ? null : compileCurve(keyed.mix, 3),
+      positionCursor: cursors++,
+      spacingCursor: cursors++,
+      mixCursor: cursors++
+    };
+  });
+  const physics = (anim.constraints.physicsKeyed ?? []).map((t) => ({
+    kind: t.kind,
+    cursor: cursors++,
+    curve: compileCurve(t.keys, t.kind === "reset" ? 0 : 1),
+    targets: Int32Array.from(constraints.filter((c) => c.kind === "physics" && c.applied && (t.name === "*" ? t.kind === "reset" || c.setup.global[t.kind] : c.name === t.name)).map((c) => c.index))
+  }));
   const deforms = deform.map((a) => {
     const g = doc.skins.find((s) => s.name === a.skin)?.attachments[a.slot]?.[a.attachment]?.geometry;
     if (g === void 0 || g.kind === "region" || g.kind === "linkedmesh") throw new RuntimeInputError(`deform "${a.skin}/${a.slot}/${a.attachment}" has no vertex geometry (readModel refuses it first)`);
@@ -9522,15 +9692,613 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
     const arrays = keys.map((k) => heldArray(g.vertices, k));
     return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
   });
-  return { name, duration: tl.duration, deforms, 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 }))) };
+  return { name, duration: tl.duration, physics, sliders, paths, deforms, bones, sliderBones, slots: slotTimelines, drawOrder, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map((key) => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
+}
+class RuntimeClipBuffer {
+  constructor(triangles, polygonVertices) {
+    this.vertexCount = 0;
+    this.triangleCount = 0;
+    this.clipped = false;
+    const points = triangles * Math.max(3, polygonVertices * (polygonVertices + 3));
+    if (!Number.isSafeInteger(points) || points < 0) throw new Error("runtime clip: output capacity is not a safe non-negative integer");
+    this.vertices = new Float32Array(points * 2);
+    this.uvs = new Float32Array(points * 2);
+    this.triangles = new Int32Array(points * 3);
+    this.sources = new Int32Array(points);
+  }
+}
+class RuntimeClipper {
+  constructor(maxPolygonVertices) {
+    this.maxPolygonVertices = maxPolygonVertices;
+    this.nativeRows = false;
+    this.tri = new Float64Array(6);
+    this.uv = new Float64Array(6);
+    this.regionsCount = 0;
+    this.inverse = false;
+    this.cut = false;
+    this.n = 0;
+    const n = Math.max(3, maxPolygonVertices);
+    this.points = new Float64Array(n * 2);
+    this.ring = new Int32Array(n);
+    this.work = new Int32Array(n);
+    this.sorted = new Int32Array(n);
+    this.hull = new Int32Array(n * 2);
+    this.pieces = new Int32Array(n * n);
+    this.sizes = new Int32Array(n);
+    this.merged = new Int32Array(n * 2);
+    this.regions = new Float64Array(n * n * 2);
+    this.regionSizes = new Int32Array(n);
+    this.a = new Float64Array((n * 2 + 16) * 2);
+    this.b = new Float64Array(this.a.length);
+    this.outside = new Float64Array(this.a.length);
+  }
+  cross(a, b, c) {
+    const p = this.points;
+    return (p[b * 2] - p[a * 2]) * (p[c * 2 + 1] - p[a * 2 + 1]) - (p[b * 2 + 1] - p[a * 2 + 1]) * (p[c * 2] - p[a * 2]);
+  }
+  area(indices, n) {
+    const p = this.points;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+      const a = indices[i] * 2, b = indices[(i + 1) % n] * 2;
+      area += p[a] * p[b + 1] - p[b] * p[a + 1];
+    }
+    return area;
+  }
+  convex(indices, n, start = 0) {
+    let sign = 0;
+    for (let i = 0; i < n; i++) {
+      const p = this.points, a = indices[start + i] * 2, b = indices[start + (i + 1) % n] * 2, c = indices[start + (i + 2) % n] * 2;
+      const cross = (p[b] - p[a]) * (p[c + 1] - p[b + 1]) - (p[b + 1] - p[a + 1]) * (p[c] - p[b]);
+      if (cross === 0) return false;
+      const next = Math.sign(cross);
+      if (sign === 0) sign = next;
+      else if (sign !== next) return false;
+    }
+    return true;
+  }
+  on(a, b, r) {
+    const p = this.points;
+    return Math.min(p[a * 2], p[b * 2]) <= p[r * 2] && p[r * 2] <= Math.max(p[a * 2], p[b * 2]) && Math.min(p[a * 2 + 1], p[b * 2 + 1]) <= p[r * 2 + 1] && p[r * 2 + 1] <= Math.max(p[a * 2 + 1], p[b * 2 + 1]);
+  }
+  meet(a, b, c, d) {
+    const d1 = this.cross(c, d, a), d2 = this.cross(c, d, b), d3 = this.cross(a, b, c), d4 = this.cross(a, b, d);
+    if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) return true;
+    return d1 === 0 && this.on(c, d, a) || d2 === 0 && this.on(c, d, b) || d3 === 0 && this.on(a, b, c) || d4 === 0 && this.on(a, b, d);
+  }
+  region(indices, n, r, start = 0) {
+    const p = this.points;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+      const a = indices[start + i] * 2, b = indices[start + (i + 1) % n] * 2;
+      area += p[a] * p[b + 1] - p[b] * p[a + 1];
+    }
+    const base = r * this.maxPolygonVertices * 2;
+    for (let i = 0; i < n; i++) {
+      const j = indices[start + (area > 0 ? n - 1 - i : i)] * 2;
+      this.regions[base + i * 2] = p[j];
+      this.regions[base + i * 2 + 1] = p[j + 1];
+    }
+    this.regionSizes[r] = n;
+  }
+  makeHull(count) {
+    const idx = this.sorted, p = this.points, h = this.hull;
+    for (let i = 0; i < count; i++) {
+      const v = this.ring[i];
+      let j = i;
+      while (j > 0) {
+        const u = idx[j - 1];
+        if (p[u * 2] < p[v * 2] || p[u * 2] === p[v * 2] && p[u * 2 + 1] <= p[v * 2 + 1]) break;
+        idx[j] = u;
+        j--;
+      }
+      idx[j] = v;
+    }
+    let used = 0;
+    for (let i = 0; i < count; i++) {
+      const v = idx[i];
+      while (used >= 2 && this.cross(h[used - 2], h[used - 1], v) <= 0) used--;
+      h[used++] = v;
+    }
+    used--;
+    const lower = used;
+    for (let i = count - 1; i >= 0; i--) {
+      const v = idx[i];
+      while (used >= lower + 2 && this.cross(h[used - 2], h[used - 1], v) <= 0) used--;
+      h[used++] = v;
+    }
+    return used - 1;
+  }
+  plan(inverse, convex) {
+    this.nativeRows = false;
+    const n = this.n, p = this.points, ring = this.ring;
+    let repeats = 0, distinct = 0;
+    for (let i = 0; i < n; i++) {
+      ring[i] = i;
+      for (let j2 = i + 1; j2 < n; j2++) if (p[i * 2] === p[j2 * 2] && p[i * 2 + 1] === p[j2 * 2 + 1]) repeats++;
+      const j = (i + 1) % n;
+      if (p[i * 2] !== p[j * 2] || p[i * 2 + 1] !== p[j * 2 + 1]) this.work[distinct++] = i;
+    }
+    if (repeats > 0) {
+      if (!inverse && distinct === n - repeats && distinct >= 3 && this.convex(this.work, distinct)) {
+        this.regionsCount = 1;
+        this.inverse = false;
+        this.region(ring, n, 0);
+        return false;
+      }
+      throw new Error("runtime clip: polygon has repeated vertices unsupported by clipShapeOf");
+    }
+    for (let i = 0; i < n; i++) {
+      const j = (i + 1) % n, k = (i + 2) % n;
+      if (this.cross(i, j, k) === 0 && (p[k * 2] - p[j * 2]) * (p[i * 2] - p[j * 2]) + (p[k * 2 + 1] - p[j * 2 + 1]) * (p[i * 2 + 1] - p[j * 2 + 1]) > 0) throw new Error("runtime clip: neighbouring polygon edges fold back");
+      for (let q = i + 2; q < n; q++) if (!(i === 0 && q === n - 1) && this.meet(i, j, q, (q + 1) % n)) throw new Error("runtime clip: polygon edges cross or touch");
+    }
+    const originalConvex = this.convex(ring, n);
+    this.nativeRows = !inverse && originalConvex;
+    let count = n;
+    for (let changed = true; changed && count > 3; ) {
+      changed = false;
+      for (let i = 0; i < count; i++) if (this.cross(ring[(i + count - 1) % count], ring[i], ring[(i + 1) % count]) === 0) {
+        ring.copyWithin(i, i + 1, count);
+        count--;
+        changed = true;
+        break;
+      }
+    }
+    if (count === 3 && this.cross(ring[0], ring[1], ring[2]) === 0) throw new Error("runtime clip: every polygon vertex lies on one line");
+    this.inverse = inverse;
+    if (inverse || !originalConvex && convex) {
+      this.regionsCount = 1;
+      this.region(this.hull, this.makeHull(count), 0);
+      return false;
+    }
+    if (originalConvex) {
+      for (let i = 0; i < n; i++) ring[i] = i;
+      this.regionsCount = 1;
+      this.region(ring, n, 0);
+      return false;
+    }
+    if (this.area(ring, count) < 0) for (let i = 0; i < count / 2; i++) {
+      const j = count - 1 - i, v = ring[i];
+      ring[i] = ring[j];
+      ring[j] = v;
+    }
+    this.work.set(ring);
+    let left = count, pieces = 0;
+    while (left > 3) {
+      let found = false;
+      for (let k = 0; k < left; k++) {
+        const a = this.work[(k + left - 1) % left], b = this.work[k], c = this.work[(k + 1) % left];
+        if (this.cross(a, b, c) <= 0) continue;
+        let inside = false;
+        for (let j = 0; j < left; j++) {
+          const v = this.work[j];
+          if (v !== a && v !== b && v !== c && this.cross(a, b, v) >= 0 && this.cross(b, c, v) >= 0 && this.cross(c, a, v) >= 0) {
+            inside = true;
+            break;
+          }
+        }
+        if (inside) continue;
+        const base = pieces * this.maxPolygonVertices;
+        this.pieces[base] = a;
+        this.pieces[base + 1] = b;
+        this.pieces[base + 2] = c;
+        this.sizes[pieces++] = 3;
+        this.work.copyWithin(k, k + 1, left);
+        left--;
+        found = true;
+        break;
+      }
+      if (!found) throw new Error("runtime clip: no ear left in a polygon held simple");
+    }
+    for (let i = 0; i < 3; i++) this.pieces[pieces * this.maxPolygonVertices + i] = this.work[i];
+    this.sizes[pieces++] = 3;
+    for (let changed = true; changed; ) {
+      changed = false;
+      search: for (let a = 0; a < pieces; a++) for (let b = a + 1; b < pieces; b++) {
+        const an = this.sizes[a], bn = this.sizes[b], ab = a * this.maxPolygonVertices, bb = b * this.maxPolygonVertices;
+        for (let i = 0; i < an; i++) {
+          const u = this.pieces[ab + i], v = this.pieces[ab + (i + 1) % an];
+          let j = -1;
+          for (let k = 0; k < bn; k++) if (this.pieces[bb + k] === v) {
+            j = k;
+            break;
+          }
+          if (j < 0 || this.pieces[bb + (j + 1) % bn] !== u) continue;
+          let size = 0;
+          for (let k = 0; k <= i; k++) this.merged[size++] = this.pieces[ab + k];
+          for (let k = (j + 2) % bn; k !== j; k = (k + 1) % bn) this.merged[size++] = this.pieces[bb + k];
+          for (let k = i + 1; k < an; k++) this.merged[size++] = this.pieces[ab + k];
+          let strict = true;
+          for (let k = 0; k < size; k++) if (this.cross(this.merged[(k + size - 1) % size], this.merged[k], this.merged[(k + 1) % size]) <= 0) {
+            strict = false;
+            break;
+          }
+          if (!strict) continue;
+          for (let k = 0; k < size; k++) this.pieces[ab + k] = this.merged[k];
+          this.sizes[a] = size;
+          this.pieces.copyWithin(bb, bb + this.maxPolygonVertices, pieces * this.maxPolygonVertices);
+          this.sizes.copyWithin(b, b + 1, pieces);
+          pieces--;
+          changed = true;
+          break search;
+        }
+      }
+    }
+    this.regionsCount = pieces;
+    for (let i = 0; i < pieces; i++) this.region(this.pieces, this.sizes[i], i, i * this.maxPolygonVertices);
+    return pieces > 1;
+  }
+  /** Plan again after float32 conversion exactly when clipThrough first finds pieces. */
+  prepare(polygon, offset, count, inverse, convex) {
+    this.n = count / 2;
+    if (!Number.isInteger(this.n) || this.n < 3 || this.n > this.maxPolygonVertices) throw new Error("runtime clip: polygon vertex count exceeds its load-time capacity");
+    for (let i = 0; i < count; i++) {
+      const value = polygon[offset + i];
+      if (!Number.isFinite(value)) throw new Error("runtime clip: polygon contains a non-finite coordinate");
+      this.points[i] = value;
+    }
+    const replan = this.plan(inverse, convex), nativeRows = this.nativeRows;
+    if (replan) {
+      for (let i = 0; i < count; i++) this.points[i] = Math.fround(polygon[offset + i]);
+      this.plan(inverse, convex);
+    }
+    this.nativeRows = nativeRows;
+  }
+  half(input, n, px, py, qx, qy, out) {
+    let size = 0;
+    this.cut = false;
+    const ex = qx - px, ey = qy - py;
+    for (let i = 0; i < n; i++) {
+      const j = (i + 1) % n, sx = input[i * 2], sy = input[i * 2 + 1], tx = input[j * 2], ty = input[j * 2 + 1];
+      const si = ex * (sy - py) - ey * (sx - px) < 0, ei = ex * (ty - py) - ey * (tx - px) < 0;
+      if (!si || !ei) this.cut = true;
+      if (si !== ei) {
+        const dx = tx - sx, dy = ty - sy, t = (ex * (sy - py) - ey * (sx - px)) / (ey * dx - ex * dy);
+        if (size * 2 + 2 > out.length) throw new Error("runtime clip: scratch polygon exceeds its load-time capacity");
+        out[size * 2] = sx + t * dx;
+        out[size * 2 + 1] = sy + t * dy;
+        size++;
+      }
+      if (ei) {
+        if (size * 2 + 2 > out.length) throw new Error("runtime clip: scratch polygon exceeds its load-time capacity");
+        out[size * 2] = tx;
+        out[size * 2 + 1] = ty;
+        size++;
+      }
+    }
+    return size;
+  }
+  emit(points, count, cut, source, out) {
+    if (count < 3) return;
+    if ((out.vertexCount + count) * 2 > out.vertices.length || out.triangleCount + count - 2 > out.sources.length) throw new Error("runtime clip: output exceeds its load-time capacity");
+    const tri = this.tri, uv = this.uv, base = out.vertexCount;
+    const d0 = tri[3] - tri[5], d1 = tri[4] - tri[2], d2 = tri[0] - tri[4], d4 = tri[5] - tri[1], d = 1 / (d0 * d2 + d1 * (tri[1] - tri[5]));
+    for (let i = 0; i < count; i++) {
+      const x = cut ? points[i * 2] : tri[i * 2], y = cut ? points[i * 2 + 1] : tri[i * 2 + 1], at = out.vertexCount++ * 2;
+      out.vertices[at] = x;
+      out.vertices[at + 1] = y;
+      if (!cut) {
+        out.uvs[at] = uv[i * 2];
+        out.uvs[at + 1] = uv[i * 2 + 1];
+      } else {
+        const a = (d0 * (x - tri[4]) + d1 * (y - tri[5])) * d, b = (d4 * (x - tri[4]) + d2 * (y - tri[5])) * d, c = 1 - a - b;
+        out.uvs[at] = uv[0] * a + uv[2] * b + uv[4] * c;
+        out.uvs[at + 1] = uv[1] * a + uv[3] * b + uv[5] * c;
+      }
+    }
+    for (let i = base * 2; i < out.vertexCount * 2; i++) if (!Number.isFinite(out.vertices[i]) || !Number.isFinite(out.uvs[i])) throw new Error(`runtime clip: triangle ${source} produced a non-finite clipped coordinate or UV`);
+    for (let i = 1; i + 1 < count; i++) {
+      const at = out.triangleCount * 3;
+      out.triangles[at] = base;
+      out.triangles[at + 1] = base + i;
+      out.triangles[at + 2] = base + i + 1;
+      out.sources[out.triangleCount++] = source;
+    }
+  }
+  clip(vertices, offset, triangles, uvs, out) {
+    out.vertexCount = 0;
+    out.triangleCount = 0;
+    out.clipped = this.inverse;
+    for (let k = 0; k < triangles.length; k += 3) {
+      for (let j = 0; j < 3; j++) {
+        const n = triangles[k + j] * 2;
+        this.tri[j * 2] = vertices[offset + n];
+        this.tri[j * 2 + 1] = vertices[offset + n + 1];
+        this.uv[j * 2] = Math.fround(uvs[n]);
+        this.uv[j * 2 + 1] = Math.fround(uvs[n + 1]);
+      }
+      if (!this.inverse) for (let r = 0; r < this.regionsCount; r++) {
+        let input = this.a, output = this.b, count = 3, cut = false;
+        for (let i = 0; i < 6; i++) input[i] = this.tri[i];
+        const n = this.regionSizes[r], base = r * this.maxPolygonVertices * 2;
+        for (let e = 0; e < n && count > 0; e++) {
+          const p = base + e * 2, q = base + (e + 1) % n * 2;
+          count = this.half(input, count, this.regions[p], this.regions[p + 1], this.regions[q], this.regions[q + 1], output);
+          cut ||= this.cut;
+          const swap = input;
+          input = output;
+          output = swap;
+        }
+        out.clipped ||= cut;
+        this.emit(input, count, cut, k / 3, out);
+      }
+      else {
+        let input = this.a, output = this.b, count = 3, cutSoFar = false;
+        for (let i = 0; i < 6; i++) input[i] = this.tri[i];
+        const n = this.regionSizes[0];
+        for (let e = 0; e < n && count > 0; e++) {
+          const p = e * 2, q = (e + 1) % n * 2, px = this.regions[p], py = this.regions[p + 1], qx = this.regions[q], qy = this.regions[q + 1];
+          const outside = this.half(input, count, qx, qy, px, py, this.outside), cut = this.cut || cutSoFar;
+          this.emit(this.outside, outside, cut, k / 3, out);
+          count = this.half(input, count, px, py, qx, qy, output);
+          cutSoFar ||= this.cut;
+          const swap = input;
+          input = output;
+          output = swap;
+        }
+      }
+    }
+  }
+}
+class RuntimeDrawClipper {
+  constructor(model) {
+    this.model = model;
+    this.nativeRows = true;
+    this.clipCount = 0;
+    this.drawCount = 0;
+    const triangles = [], uvs = [], maxTriangles = new Int32Array(model.slots.length);
+    let maxPolygon = 3;
+    for (const at of model.attachments) {
+      const t = at.clipTopology?.triangles ?? null, uv = at.clipTopology?.uvs ?? null;
+      if (at.clip !== void 0) maxPolygon = Math.max(maxPolygon, at.count / 2);
+      triangles.push(t);
+      uvs.push(uv);
+      if (t !== null) maxTriangles[at.slot] = Math.max(maxTriangles[at.slot], t.length / 3);
+    }
+    this.triangles = triangles;
+    this.uvs = uvs;
+    this.clipper = new RuntimeClipper(maxPolygon);
+    this.clipSlots = new Int32Array(model.slots.length);
+    this.drawSlots = new Int32Array(model.slots.length);
+    this.outputs = Array.from(maxTriangles, (n) => new RuntimeClipBuffer(n, maxPolygon));
+  }
+  /** pose.computeVertices() must precede this walk. Omission is a diagnostic plant only. */
+  frame(pose, omit = false) {
+    if (pose.model !== this.model) throw new Error("runtime clip draw: pose differs from the prepared model");
+    this.clipCount = 0;
+    this.drawCount = 0;
+    this.nativeRows = true;
+    let active = false, end = null;
+    for (let i = 0; i < pose.drawOrder.length; i++) {
+      const s = pose.drawOrder[i], slot = this.model.slots[s], shown = pose.shown[s], at = shown < 0 ? null : this.model.attachments[shown];
+      if (at?.clip !== void 0) {
+        this.clipSlots[this.clipCount++] = s;
+        if (active && end === slot.name) active = false;
+        if (!omit && !active && this.model.active[at.bone] === 1) {
+          this.clipper.prepare(pose.vertices, at.offset, at.count, at.clip.inverse, at.clip.convex);
+          this.nativeRows &&= this.clipper.nativeRows;
+          active = true;
+          end = at.clip.end;
+        }
+        continue;
+      }
+      if (active && at !== null) {
+        const triangles = this.triangles[shown], uvs = this.uvs[shown];
+        if (triangles !== null && uvs !== null) {
+          this.clipper.clip(pose.vertices, at.offset, triangles, uvs, this.outputs[s]);
+          this.drawSlots[this.drawCount++] = s;
+        }
+      }
+      if (active && end === slot.name) active = false;
+    }
+  }
+}
+const PI2 = RUNTIME_PI * 2;
+const INV_PI2 = 1 / PI2;
+function freshPhysicsState() {
+  return { pending: true, lastTime: 0, remaining: 0, ux: 0, uy: 0, cx: 0, cy: 0, tx: 0, ty: 0, xOffset: 0, xLag: 0, xVelocity: 0, yOffset: 0, yLag: 0, yVelocity: 0, rotateOffset: 0, rotateLag: 0, rotateVelocity: 0, scaleOffset: 0, scaleLag: 0, scaleVelocity: 0 };
+}
+function resetPhysicsState(s, time) {
+  s.remaining = 0;
+  s.lastTime = time;
+  s.pending = true;
+  s.xOffset = s.xLag = s.xVelocity = 0;
+  s.yOffset = s.yLag = s.yVelocity = 0;
+  s.rotateOffset = s.rotateLag = s.rotateVelocity = 0;
+  s.scaleOffset = s.scaleLag = s.scaleVelocity = 0;
+}
+function stepRuntimePhysics(r, s, w, boneOffset, length, time, reset, env) {
+  const mix = r.mix;
+  if (mix === 0) return false;
+  const x = r.x > 0, y = r.y > 0, rotateOrShearX = r.rotate > 0 || r.shearX > 0, scaleX = r.scaleX > 0;
+  const l = length;
+  if (reset) resetPhysicsState(s, time);
+  const delta = Math.max(time - s.lastTime, 0);
+  const shown = Math.max(0, 1 - s.remaining / r.step);
+  s.remaining += delta;
+  s.lastTime = time;
+  const bx = w[boneOffset + 4];
+  const by = w[boneOffset + 5];
+  let z = 0;
+  if (s.pending) {
+    s.pending = false;
+    s.ux = bx;
+    s.uy = by;
+  } else {
+    let a = s.remaining;
+    const i = r.inertia;
+    const t = r.step;
+    const f = r.referenceScale;
+    let d = -1;
+    const qx = r.limit * delta;
+    const qy = qx;
+    if (x || y) {
+      if (x) {
+        const u = (s.ux - bx) * i;
+        s.xOffset += u > qx ? qx : u < -qx ? -qx : u;
+        s.ux = bx;
+      }
+      if (y) {
+        const u = (s.uy - by) * i;
+        s.yOffset += u > qy ? qy : u < -qy ? -qy : u;
+        s.uy = by;
+      }
+      if (a >= t) {
+        d = Math.pow(r.damping, 60 * t);
+        const m = r.massInverse * t;
+        const e = r.strength;
+        const wind = r.wind * f;
+        const g = r.gravity * f;
+        const ax = wind * env[0] + g * env[2];
+        const ay = wind * env[1] + g * env[3];
+        const xs = s.xOffset;
+        const ys = s.yOffset;
+        do {
+          if (x) {
+            s.xVelocity += (ax - s.xOffset * e) * m;
+            s.xOffset += s.xVelocity * t;
+            s.xVelocity *= d;
+          }
+          if (y) {
+            s.yVelocity -= (ay + s.yOffset * e) * m;
+            s.yOffset += s.yVelocity * t;
+            s.yVelocity *= d;
+          }
+          a -= t;
+        } while (a >= t);
+        s.xLag = s.xOffset - xs;
+        s.yLag = s.yOffset - ys;
+      }
+      z = Math.max(0, 1 - a / t);
+      if (x) w[boneOffset + 4] += (s.xOffset - s.xLag * z) * mix * r.x;
+      if (y) w[boneOffset + 5] += (s.yOffset - s.yLag * z) * mix * r.y;
+    }
+    if (rotateOrShearX || scaleX) {
+      const ca = Math.atan2(w[boneOffset + 2], w[boneOffset + 0]);
+      let c = 0;
+      let sn = 0;
+      let mr = 0;
+      let dx = s.cx - w[boneOffset + 4];
+      let dy = s.cy - w[boneOffset + 5];
+      if (dx > qx) dx = qx;
+      else if (dx < -qx) dx = -qx;
+      if (dy > qy) dy = qy;
+      else if (dy < -qy) dy = -qy;
+      if (rotateOrShearX) {
+        mr = (r.rotate + r.shearX) * mix;
+        const lagged = s.rotateLag * shown;
+        let rr = Math.atan2(dy + s.ty, dx + s.tx) - ca - (s.rotateOffset - lagged) * mr;
+        s.rotateOffset += (rr - Math.ceil(rr * INV_PI2 - 0.5) * PI2) * i;
+        rr = (s.rotateOffset - lagged) * mr + ca;
+        c = Math.cos(rr);
+        sn = Math.sin(rr);
+        if (scaleX) {
+          rr = l * Math.sqrt(w[boneOffset + 0] * w[boneOffset + 0] + w[boneOffset + 2] * w[boneOffset + 2]);
+          if (rr > 0) s.scaleOffset += (dx * c + dy * sn) * i / rr;
+        }
+      } else {
+        c = Math.cos(ca);
+        sn = Math.sin(ca);
+        const rr = l * Math.sqrt(w[boneOffset + 0] * w[boneOffset + 0] + w[boneOffset + 2] * w[boneOffset + 2]) - s.scaleLag * shown;
+        if (rr > 0) s.scaleOffset += (dx * c + dy * sn) * i / rr;
+      }
+      a = s.remaining;
+      if (a >= t) {
+        if (d === -1) d = Math.pow(r.damping, 60 * t);
+        const m = r.massInverse * t;
+        const e = r.strength;
+        const ax = r.wind * env[0] + r.gravity * env[2];
+        const ay = r.wind * env[1] + r.gravity * env[3];
+        const h = l / f;
+        const rs = s.rotateOffset;
+        const ss = s.scaleOffset;
+        for (; ; ) {
+          a -= t;
+          if (scaleX) {
+            s.scaleVelocity += (ax * c - ay * sn - s.scaleOffset * e) * m;
+            s.scaleOffset += s.scaleVelocity * t;
+            s.scaleVelocity *= d;
+          }
+          if (rotateOrShearX) {
+            s.rotateVelocity -= ((ax * sn + ay * c) * h + s.rotateOffset * e) * m;
+            s.rotateOffset += s.rotateVelocity * t;
+            s.rotateVelocity *= d;
+            if (a < t) break;
+            const rr = s.rotateOffset * mr + ca;
+            c = Math.cos(rr);
+            sn = Math.sin(rr);
+          } else if (a < t) break;
+        }
+        s.rotateLag = s.rotateOffset - rs;
+        s.scaleLag = s.scaleOffset - ss;
+      }
+      z = Math.max(0, 1 - a / t);
+    }
+    s.remaining = a;
+  }
+  s.cx = w[boneOffset + 4];
+  s.cy = w[boneOffset + 5];
+  if (rotateOrShearX) {
+    let angle = (s.rotateOffset - s.rotateLag * z) * mix;
+    let sn = 0;
+    let c = 0;
+    let a = 0;
+    if (r.shearX > 0) {
+      let rr = 0;
+      if (r.rotate > 0) {
+        rr = angle * r.rotate;
+        sn = Math.sin(rr);
+        c = Math.cos(rr);
+        a = w[boneOffset + 1];
+        w[boneOffset + 1] = c * a - sn * w[boneOffset + 3];
+        w[boneOffset + 3] = sn * a + c * w[boneOffset + 3];
+      }
+      rr += angle * r.shearX;
+      sn = Math.sin(rr);
+      c = Math.cos(rr);
+      a = w[boneOffset + 0];
+      w[boneOffset + 0] = c * a - sn * w[boneOffset + 2];
+      w[boneOffset + 2] = sn * a + c * w[boneOffset + 2];
+    } else {
+      angle *= r.rotate;
+      sn = Math.sin(angle);
+      c = Math.cos(angle);
+      a = w[boneOffset + 0];
+      w[boneOffset + 0] = c * a - sn * w[boneOffset + 2];
+      w[boneOffset + 2] = sn * a + c * w[boneOffset + 2];
+      a = w[boneOffset + 1];
+      w[boneOffset + 1] = c * a - sn * w[boneOffset + 3];
+      w[boneOffset + 3] = sn * a + c * w[boneOffset + 3];
+    }
+  }
+  if (scaleX) {
+    const k = 1 + (s.scaleOffset - s.scaleLag * z) * mix * r.scaleX;
+    w[boneOffset + 0] *= k;
+    w[boneOffset + 2] *= k;
+    if (r.scaleYMode === "Uniform") {
+      w[boneOffset + 1] *= k;
+      w[boneOffset + 3] *= k;
+    } else if (r.scaleYMode === "Volume") {
+      const magnitude = Math.abs(k);
+      const transverse = magnitude >= 0.7 ? 1 / magnitude : 4 - 3.67347 * magnitude;
+      w[boneOffset + 1] *= transverse;
+      w[boneOffset + 3] *= transverse;
+    }
+  }
+  s.tx = l * w[boneOffset + 0];
+  s.ty = l * w[boneOffset + 2];
+  return true;
 }
 const DEG = RUNTIME_DEG;
 const TWO_PI = 2 * RUNTIME_PI;
+const PATH_EPSILON = 1e-5;
 const P_ROTATE = 0;
 const P_X = 1;
 const P_Y = 2;
 const P_SCALE_X = 3;
 const P_SCALE_Y = 4;
+const PROPERTY_LOCAL = new Int32Array([L_ROTATION, L_X, L_Y, L_SCALE_X, L_SCALE_Y, L_SHEAR_Y]);
 function wrap180(r) {
   return r > 180 ? r - 360 : r <= -180 ? r + 360 : r;
 }
@@ -9539,21 +10307,39 @@ function volumeScaleY(scaleY, s) {
 }
 const clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 class RuntimePose {
-  constructor(model) {
+  constructor(model, options = {}) {
     this.trackTime = 0;
     this.time = 0;
     this.fired = [];
     this.eventTime = -1;
     this.current = null;
+    this.pathSegmentEnds = new Float64Array(10);
     this.w = new Float64Array(WORLDS);
+    this.physicsTime = 0;
+    this.physicsLast = -1;
+    this.physicsPhase = "none";
+    this.physicsReady = false;
+    this.environment = new Float64Array([1, 0, 0, 1]);
     this.model = model;
+    this.clipping = model.attachments.some((at) => at.clip !== void 0) ? new RuntimeDrawClipper(model) : null;
+    this.clock = options.clock;
+    this.hasPhysics = model.constraints.some((c) => c.kind === "physics");
+    this.physicsStates = model.constraints.map(() => freshPhysicsState());
+    this.physicsRecords = model.constraints.map((c) => c.kind === "physics" ? { ...c.setup } : null);
+    this.sliderTime = new Float64Array(model.constraints.length);
+    this.sliderMix = new Float64Array(model.constraints.length);
+    this.sliderAt = new Float64Array(model.constraints.length);
     const nb = model.boneNames.length;
     const ns = model.slots.length;
     const nc = model.constraints.length;
+    this.physicsScope = new Uint8Array(nc);
     this.locals = new Float64Array(nb * LOCALS);
     this.world = new Float64Array(nb * WORLDS);
     this.light = new Float64Array(ns * 4);
+    this.dark = new Float64Array(ns * 3);
     this.shown = new Int32Array(ns);
+    this.drawOrder = new Int32Array(ns);
+    for (let s = 0; s < ns; s++) this.drawOrder[s] = s;
     this.vertices = new Float64Array(model.vertexCount);
     this.deform = new Float64Array(model.deformCount);
     this.deformed = new Uint8Array(model.attachments.length);
@@ -9562,6 +10348,16 @@ class RuntimePose {
     this.ikSoftness = new Float64Array(nc);
     this.ikFlags = new Uint8Array(nc);
     this.mixes = new Float64Array(nc * 6);
+    this.pathValues = new Float64Array(nc * 5);
+    this.pathSlotSign = new Int8Array(nc);
+    const ms = model.maxPathSpaces;
+    const mv = model.maxPathVertices;
+    this.pathSpaces = new Float64Array(ms);
+    this.pathLengths = new Float64Array(ms);
+    this.pathPositions = new Float64Array(ms > 0 ? ms * 3 + 2 : 0);
+    this.pathWorldPts = new Float64Array(mv);
+    this.pathChain = new Float64Array(mv > 0 ? mv + 4 : 0);
+    this.pathCurveEnds = new Float64Array(mv > 0 ? Math.ceil(mv / 6) + 1 : 0);
     this.changed = new Int32Array(model.scratch);
     this.inWorld = new Int32Array(model.scratch);
     this.changedMark = new Uint8Array(nb);
@@ -9576,6 +10372,10 @@ class RuntimePose {
   /** 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.physicsTime = 0;
+    this.physicsLast = -1;
+    this.physicsReady = false;
+    for (let k = 0; k < this.physicsStates.length; k++) resetPhysicsState(this.physicsStates[k], 0);
     this.cursors.fill(-1);
     this.trackTime = 0;
     this.time = 0;
@@ -9596,38 +10396,57 @@ class RuntimePose {
     this.apply(animationTime);
   }
   /** The setup pose: every constraint applied with its own values, every slot as it is set up. */
-  setupPose() {
+  setupPose(physics = "none") {
+    this.physicsPhase = physics;
     this.current = null;
     this.time = 0;
     this.eventTime = -1;
     this.fired.length = 0;
+    this.physicsValues(null, 0, false);
     this.locals.set(this.model.setup);
     this.hierarchy();
-    this.constraintValues(null, 0);
-    this.solveConstraints();
     this.slotValues(null, 0);
     this.deformValues(null, 0);
+    this.constraintValues(null, 0);
+    this.solveConstraints();
+    this.sliderAttachments();
   }
   /** The animation posed at its time `t`, from the setup pose (the header). */
-  apply(t) {
+  apply(t, physics = "none", delta = 0) {
     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`);
+    if (!Number.isFinite(delta) || delta < 0) throw new RuntimeInputError(`apply: physics delta ${delta} is not finite and at or above 0`);
+    this.physicsPhase = physics;
+    this.physicsValues(anim, t, physics !== "none");
+    if (physics !== "none") {
+      this.physicsTime += delta;
+      this.physicsReady = true;
+    }
     this.collectEvents(anim, t);
     this.time = t;
     this.boneTimelines(anim, t);
     this.hierarchy();
-    this.constraintValues(anim, t);
-    this.solveConstraints();
     this.slotValues(anim, t);
     this.deformValues(anim, t);
+    this.constraintValues(anim, t);
+    this.solveConstraints();
+    this.sliderAttachments();
   }
   /** 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)");
+    if (!Number.isFinite(dt) || dt < 0) throw new RuntimeInputError(`step: delta ${dt} is not finite and at or above 0`);
+    if (!this.physicsReady && this.hasPhysics) {
+      const lastEventTime = this.eventTime;
+      this.apply(this.time, "reset", 0);
+      this.eventTime = lastEventTime;
+    }
+    const moved = this.clock === void 0 ? dt : this.clock(dt);
+    if (!Number.isFinite(moved) || moved < 0) throw new RuntimeInputError(`step: physics clock moved by ${moved}, not finite and at or above 0`);
     this.trackTime += dt;
-    this.apply(anim.duration === 0 ? 0 : this.trackTime % anim.duration);
+    this.apply(anim.duration === 0 ? 0 : this.trackTime % anim.duration, "update", moved);
   }
   /** The oracle interval (last,t], tail then head on a wrap; never copies a payload. */
   collectEvents(anim, t) {
@@ -9824,20 +10643,738 @@ class RuntimePose {
           this.ikSoftness[k] = c.softness + (channelValue(tl.curve, i, 1, t) - c.softness) * 1;
           this.ikFlags[k] = tl.flags[i];
         }
-      } else {
+      } else if (c.kind === "transform") {
         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;
+      } else if (c.kind === "slider") {
+        const keyed = anim === null ? null : anim.sliders[k];
+        let time = c.setup.time, mix = c.setup.mix;
+        if (keyed !== null) {
+          if (keyed.time !== null) {
+            const q = keyAt(keyed.time, this.cursors, keyed.timeCursor, t);
+            if (q >= 0) time += (channelValue(keyed.time, q, 0, t) - time) * 1;
+          }
+          if (keyed.mix !== null) {
+            const q = keyAt(keyed.mix, this.cursors, keyed.mixCursor, t);
+            if (q >= 0) mix += (channelValue(keyed.mix, q, 0, t) - mix) * 1;
+          }
+        }
+        this.sliderTime[k] = time;
+        this.sliderMix[k] = mix;
+      } else if (c.kind === "path") {
+        const keyed = anim === null ? null : anim.paths[k];
+        let position = c.position;
+        let spacing = c.spacing;
+        let mixRotate = c.mixRotate;
+        let mixX = c.mixX;
+        let mixY = c.mixY;
+        if (keyed !== null) {
+          if (keyed.position !== null) {
+            const q = keyAt(keyed.position, this.cursors, keyed.positionCursor, t);
+            if (q >= 0) position = c.position + (channelValue(keyed.position, q, 0, t) - c.position) * 1;
+          }
+          if (keyed.spacing !== null) {
+            const q = keyAt(keyed.spacing, this.cursors, keyed.spacingCursor, t);
+            if (q >= 0) spacing = c.spacing + (channelValue(keyed.spacing, q, 0, t) - c.spacing) * 1;
+          }
+          if (keyed.mix !== null) {
+            const q = keyAt(keyed.mix, this.cursors, keyed.mixCursor, t);
+            if (q >= 0) {
+              mixRotate = c.mixRotate + (channelValue(keyed.mix, q, 0, t) - c.mixRotate) * 1;
+              mixX = c.mixX + (channelValue(keyed.mix, q, 1, t) - c.mixX) * 1;
+              mixY = c.mixY + (channelValue(keyed.mix, q, 2, t) - c.mixY) * 1;
+            }
+          }
+        }
+        const o = k * 5;
+        this.pathValues[o] = position;
+        this.pathValues[o + 1] = spacing;
+        this.pathValues[o + 2] = mixRotate;
+        this.pathValues[o + 3] = mixX;
+        this.pathValues[o + 4] = mixY;
       }
     }
   }
   /** Every applied constraint in the document's order, each followed by the update order's repose (`applyConstraints`). */
   solveConstraints() {
     const cs = this.model.constraints;
+    const hasPath = this.model.hasPath;
     for (let k = 0; k < cs.length; k++) {
+      if (hasPath) this.snapSlotBones(k, false);
       const c = cs[k];
       if (!c.applied) continue;
       if (c.kind === "ik") this.solveIk(c, k);
-      else this.solveTransform(c, k);
+      else if (c.kind === "transform") this.solveTransform(c, k);
+      else if (c.kind === "slider") this.solveSlider(c, k);
+      else if (c.kind === "path") this.solvePath(c, k);
+      else if (this.physicsPhase !== "none" && !this.model.omitPhysics) {
+        const b = c.bones[0];
+        if (stepRuntimePhysics(this.physicsRecords[k], this.physicsStates[k], this.world, b * WORLDS, this.model.lengths[b], this.physicsTime, this.physicsPhase === "reset", this.environment)) {
+          this.changed[0] = this.inWorld[0] = b;
+          this.repose(1, 1);
+        }
+      }
+      if (hasPath) this.snapSlotBones(k, true);
+    }
+  }
+  snapSlotBones(at, after) {
+    const cs = this.model.constraints;
+    const W = this.world;
+    for (let k = 0; k < cs.length; k++) {
+      const c = cs[k];
+      if (c.kind !== "path" || c.slotEventAt !== at || c.slotEventAfter !== after || k === at && !after) continue;
+      const sb = c.slotBone * WORLDS;
+      this.pathSlotSign[k] = W[sb + W_A] * W[sb + W_D] - W[sb + W_B] * W[sb + W_C] > 0 ? 1 : -1;
+    }
+  }
+  /** Reset where the consumer starts: the setup pose or animation pose zero. */
+  resetPhysics(at = "animation") {
+    this.physicsTime = 0;
+    this.physicsLast = -1;
+    for (let k = 0; k < this.physicsStates.length; k++) resetPhysicsState(this.physicsStates[k], 0);
+    if (at === "animation") this.apply(0, "reset", 0);
+    else {
+      const current = this.current;
+      this.setupPose("reset");
+      this.current = current;
+    }
+    this.physicsReady = true;
+  }
+  checkPhysicsScope(scope) {
+    if (scope === void 0) return null;
+    if (!Array.isArray(scope)) throw new RuntimeInputError(`physics movement scope is ${String(scope)}, not an array of physics constraint names`);
+    const selected = this.physicsScope;
+    selected.fill(0);
+    const cs = this.model.constraints;
+    for (let i = 0; i < scope.length; i++) {
+      const name = scope[i];
+      if (typeof name !== "string") throw new RuntimeInputError(`physics movement scope name ${String(name)} is not a string`);
+      let found;
+      for (let k = 0; k < cs.length; k++) {
+        if (cs[k].kind === "physics" && cs[k].name === name) {
+          found = cs[k];
+          break;
+        }
+      }
+      if (found === void 0) {
+        for (let k = 0; k < cs.length; k++) {
+          if (cs[k].name === name) {
+            found = cs[k];
+            break;
+          }
+        }
+      }
+      if (found === void 0) throw new RuntimeInputError(`physics movement scope: no constraint "${name}"; this document declares [${cs.map((c) => c.name).join(", ")}]`);
+      if (found.kind !== "physics") throw new RuntimeInputError(`physics movement scope: constraint "${name}" is ${found.kind}, not physics`);
+      selected[found.index] = 1;
+    }
+    return this.model.ignorePhysicsScope ? null : selected;
+  }
+  /** External motion changes the previous origin, never the authored locals. */
+  physicsTranslate(x, y, scope) {
+    const selected = this.checkPhysicsScope(scope);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) throw new RuntimeInputError("physicsTranslate: x and y must be finite");
+    for (let k = 0; k < this.physicsStates.length; k++) {
+      if (selected !== null && selected[k] === 0) continue;
+      const s = this.physicsStates[k];
+      s.ux -= x;
+      s.uy -= y;
+      s.cx -= x;
+      s.cy -= y;
+    }
+  }
+  physicsRotate(x, y, degrees, scope) {
+    const selected = this.checkPhysicsScope(scope);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(degrees)) throw new RuntimeInputError("physicsRotate: x, y and degrees must be finite");
+    const r = degrees * RAD, cos = Math.cos(r), sin = Math.sin(r);
+    for (let k = 0; k < this.physicsStates.length; k++) {
+      if (selected !== null && selected[k] === 0) continue;
+      const s = this.physicsStates[k];
+      const dx = s.cx - x, dy = s.cy - y;
+      const tx = dx * cos - dy * sin - dx, ty = dx * sin + dy * cos - dy;
+      s.ux -= tx;
+      s.uy -= ty;
+      s.cx -= tx;
+      s.cy -= ty;
+    }
+  }
+  setEnvironment(env) {
+    if (!Number.isFinite(env.wind[0]) || !Number.isFinite(env.wind[1]) || !Number.isFinite(env.gravity[0]) || !Number.isFinite(env.gravity[1])) throw new RuntimeInputError("setEnvironment: wind and gravity must be finite");
+    this.environment[0] = env.wind[0];
+    this.environment[1] = env.wind[1];
+    this.environment[2] = env.gravity[0];
+    this.environment[3] = env.gravity[1];
+  }
+  /** The per-pass values start at setup, before any slider writes. */
+  physicsValues(anim, t, resets) {
+    const cs = this.model.constraints;
+    for (let k = 0; k < cs.length; k++) {
+      const c = cs[k];
+      if (c.kind !== "physics") continue;
+      const r = this.physicsRecords[k];
+      r.inertia = c.setup.inertia;
+      r.strength = c.setup.strength;
+      r.damping = c.setup.damping;
+      r.massInverse = c.setup.massInverse;
+      r.wind = c.setup.wind;
+      r.gravity = c.setup.gravity;
+      r.mix = c.setup.mix;
+    }
+    if (anim !== null) this.physicsTimelines(anim.physics, t, 1, false, true, resets);
+    if (resets) this.physicsLast = t;
+  }
+  physicsTimelines(timelines, t, alpha, additive, setup, resets = false) {
+    for (let q = 0; q < timelines.length; q++) {
+      const tl = timelines[q];
+      if (tl.kind === "reset") {
+        if (!resets) continue;
+        let crossed = false;
+        const last = this.physicsLast;
+        for (let i2 = 0; i2 < tl.curve.keys; i2++) {
+          const time = tl.curve.times[i2];
+          if (t < last ? time > last || time <= t : time > last && time <= t) crossed = true;
+        }
+        if (crossed) for (let j = 0; j < tl.targets.length; j++) resetPhysicsState(this.physicsStates[tl.targets[j]], this.physicsTime);
+        continue;
+      }
+      const i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+      if (i < 0) {
+        if (setup) for (let j = 0; j < tl.targets.length; j++) {
+          const k = tl.targets[j], r = this.physicsRecords[k];
+          const original = this.model.constraints[k].setup;
+          if (tl.kind === "mass") r.massInverse = original.massInverse;
+          else r[tl.kind] = original[tl.kind];
+        }
+        continue;
+      }
+      const v = channelValue(tl.curve, i, 0, t);
+      for (let j = 0; j < tl.targets.length; j++) {
+        const k = tl.targets[j], r = this.physicsRecords[k];
+        const from = setup ? this.model.constraints[k].setup : r;
+        if (tl.kind === "mass") {
+          const mass = 1 / from.massInverse;
+          r.massInverse = 1 / (mass + (v - mass) * alpha);
+        } else {
+          r[tl.kind] = additive && (tl.kind === "wind" || tl.kind === "gravity") ? r[tl.kind] + v * alpha : from[tl.kind] + (v - from[tl.kind]) * alpha;
+        }
+      }
+    }
+  }
+  /** Read the dial where previous constraints left it; this value is never track time. */
+  solveSlider(c, k) {
+    const alpha = this.sliderMix[k];
+    if (alpha === 0) return;
+    let time = this.sliderTime[k];
+    const r = c.setup, a = c.animation;
+    if (c.bone >= 0) {
+      const b = c.bone, w = b * WORLDS, l = b * LOCALS;
+      let value;
+      if (r.local) {
+        const field = c.property === 0 ? L_ROTATION : c.property === 1 ? L_X : c.property === 2 ? L_Y : c.property === 3 ? L_SCALE_X : c.property === 4 ? L_SCALE_Y : L_SHEAR_Y;
+        value = this.locals[l + field] + 0;
+      } else {
+        const W = this.world, x = W[w], y = W[w + 2], bx = W[w + 1], by = W[w + 3];
+        switch (c.property) {
+          case 0:
+            value = Math.atan2(y, x) * DEG + (x * by - bx * y > 0 ? 0 : -0);
+            if (value < 0) value += 360;
+            break;
+          case 1:
+            value = x * 0 + bx * 0 + W[w + W_X];
+            break;
+          case 2:
+            value = y * 0 + by * 0 + W[w + W_Y];
+            break;
+          case 3:
+            value = Math.sqrt(x * x + y * y) + 0;
+            break;
+          case 4:
+            value = Math.sqrt(bx * bx + by * by) + 0;
+            break;
+          default:
+            value = (Math.atan2(by, bx) - Math.atan2(y, x)) * DEG - 90 + 0;
+        }
+      }
+      time = r.to + (value - r.from) * r.scale;
+      time = r.loop ? a.duration === 0 ? 0 : a.duration + time % a.duration : Math.max(0, time);
+    }
+    const at = this.model.sliderAsTrack ? this.time : r.loop && a.duration !== 0 ? time % a.duration : time;
+    this.sliderAt[k] = at;
+    if (this.physicsPhase !== "none") this.physicsTimelines(a.physics, at, alpha, r.additive, false);
+    const L = this.locals, S = this.model.setup;
+    for (let q = 0; q < a.sliderBones.length; q++) {
+      const tl = a.sliderBones[q], i = keyAt(tl.curve, this.cursors, tl.cursor, at);
+      if (i < 0) continue;
+      const o = tl.bone * LOCALS;
+      for (let f = 0; f < tl.fields.length; f++) {
+        const n = o + tl.fields[f], v = channelValue(tl.curve, i, f, at), current = L[n], setup = S[n];
+        if (tl.multiply[f]) {
+          if (r.additive) L[n] = current + (v * setup - setup) * alpha;
+          else {
+            const target = setup * v, from = Math.abs(current) * Math.sign(target);
+            L[n] = alpha === 1 ? target : from + (target - from) * alpha;
+          }
+        } else L[n] = r.additive ? current + v * alpha : current + (setup + v - current) * alpha;
+      }
+    }
+    for (let q = 0; q < c.bones.length; q++) this.changed[q] = c.bones[q];
+    if (c.bones.length > 0) this.repose(c.bones.length, 0);
+  }
+  /** A path constraint (`solvePath` in `src/core/constraints_path.ts`), every buffer overwritten in place. */
+  solvePath(c, k) {
+    if (c.attachment < 0 || this.model.omitPath) return;
+    const o5 = k * 5;
+    const position = this.pathValues[o5];
+    const spacing = this.pathValues[o5 + 1];
+    const mixRotate = this.pathValues[o5 + 2];
+    const mixX = this.pathValues[o5 + 3];
+    const mixY = this.pathValues[o5 + 4];
+    if (mixRotate === 0 && mixX === 0 && mixY === 0) return;
+    const wantsTangent = c.rotateMode === PATH_ROTATE_TANGENT;
+    const scale = c.rotateMode === PATH_ROTATE_CHAIN_SCALE;
+    const bones = c.bones;
+    const boneCount = bones.length;
+    const spaceCount = wantsTangent ? boneCount : boneCount + 1;
+    const spaces = this.pathSpaces;
+    const lengths = this.pathLengths;
+    const W = this.world;
+    const modelLengths = this.model.lengths;
+    spaces[0] = 0;
+    if (c.spacingMode === PATH_SPACING_PERCENT) {
+      if (scale) {
+        for (let i = 0; i < spaceCount - 1; i++) {
+          const bi = bones[i];
+          const boneLength = modelLengths[bi];
+          const w = bi * WORLDS;
+          const x = boneLength * W[w + W_A];
+          const y = boneLength * W[w + W_C];
+          lengths[i] = Math.sqrt(x * x + y * y);
+        }
+      }
+      for (let i = 1; i < spaceCount; i++) spaces[i] = spacing;
+    } else if (c.spacingMode === PATH_SPACING_PROPORTIONAL) {
+      let sum = 0;
+      for (let i = 0, n = spaceCount - 1; i < n; ) {
+        const bi = bones[i];
+        const boneLength = modelLengths[bi];
+        if (boneLength < PATH_EPSILON) {
+          if (scale) lengths[i] = 0;
+          spaces[++i] = spacing;
+        } else {
+          const w = bi * WORLDS;
+          const x = boneLength * W[w + W_A];
+          const y = boneLength * W[w + W_C];
+          const length = Math.sqrt(x * x + y * y);
+          if (scale) lengths[i] = length;
+          spaces[++i] = length;
+          sum += length;
+        }
+      }
+      if (sum > 0) {
+        sum = spaceCount / sum * spacing;
+        for (let i = 1; i < spaceCount; i++) spaces[i] *= sum;
+      }
+    } else {
+      const addsLength = c.spacingMode === PATH_SPACING_LENGTH;
+      for (let i = 0, n = spaceCount - 1; i < n; ) {
+        const bi = bones[i];
+        const boneLength = modelLengths[bi];
+        if (boneLength < PATH_EPSILON) {
+          if (scale) lengths[i] = 0;
+          spaces[++i] = spacing;
+        } else {
+          const w = bi * WORLDS;
+          const x = boneLength * W[w + W_A];
+          const y = boneLength * W[w + W_C];
+          const length = Math.sqrt(x * x + y * y);
+          if (scale) lengths[i] = length;
+          spaces[++i] = (addsLength ? Math.max(0, boneLength + spacing) : spacing) * length / boneLength;
+        }
+      }
+    }
+    this.positionsOfPath(c, position, spaceCount, wantsTangent);
+    const positions = this.pathPositions;
+    let atX = positions[0];
+    let atY = positions[1];
+    let offsetRotation = c.offsetRotation;
+    let fromTip;
+    if (offsetRotation === 0) fromTip = c.rotateMode === PATH_ROTATE_CHAIN;
+    else {
+      fromTip = false;
+      let positive;
+      if (c.slotEventAt === k && !c.slotEventAfter) {
+        const sb = c.slotBone * WORLDS;
+        positive = W[sb + W_A] * W[sb + W_D] - W[sb + W_B] * W[sb + W_C] > 0;
+      } else {
+        positive = c.slotEventAt >= 0 && this.pathSlotSign[k] > 0;
+      }
+      offsetRotation *= positive ? RAD : -RAD;
+    }
+    for (let i = 0, p = 3; i < boneCount; i++, p += 3) {
+      const bi = bones[i];
+      const o = bi * WORLDS;
+      let wa = W[o + W_A];
+      let wb = W[o + W_B];
+      let wc = W[o + W_C];
+      let wd = W[o + W_D];
+      const wx = W[o + W_X] + (atX - W[o + W_X]) * mixX;
+      const wy = W[o + W_Y] + (atY - W[o + W_Y]) * mixY;
+      const x = positions[p];
+      const y = positions[p + 1];
+      const dx = x - atX;
+      const dy = y - atY;
+      if (scale) {
+        const length = lengths[i];
+        if (length >= PATH_EPSILON) {
+          const s = (Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
+          wa *= s;
+          wc *= s;
+        }
+      }
+      atX = x;
+      atY = y;
+      if (mixRotate > 0) {
+        const a = wa;
+        const bb = wb;
+        const cc = wc;
+        const d = wd;
+        let r;
+        if (wantsTangent) r = positions[p - 1];
+        else if (spaces[i + 1] === 0) r = positions[p + 2];
+        else r = Math.atan2(dy, dx);
+        r -= Math.atan2(cc, a);
+        if (fromTip) {
+          const cos2 = Math.cos(r);
+          const sin2 = Math.sin(r);
+          const length = modelLengths[bi];
+          atX += (length * (cos2 * a - sin2 * cc) - dx) * mixRotate;
+          atY += (length * (sin2 * a + cos2 * cc) - dy) * mixRotate;
+        } else r += offsetRotation;
+        if (r > RUNTIME_PI) r -= TWO_PI;
+        else if (r < -RUNTIME_PI) r += TWO_PI;
+        r *= mixRotate;
+        const cos = Math.cos(r);
+        const sin = Math.sin(r);
+        wa = cos * a - sin * cc;
+        wb = cos * bb - sin * d;
+        wc = sin * a + cos * cc;
+        wd = sin * bb + cos * d;
+      }
+      W[o + W_A] = wa;
+      W[o + W_B] = wb;
+      W[o + W_C] = wc;
+      W[o + W_D] = wd;
+      W[o + W_X] = wx;
+      W[o + W_Y] = wy;
+      this.changed[i] = bi;
+      this.inWorld[i] = bi;
+    }
+    if (boneCount > 0) this.repose(boneCount, boneCount);
+  }
+  computePathWorld(c) {
+    const at = this.model.attachments[c.attachment];
+    const W = this.world;
+    const pts = this.pathWorldPts;
+    const deformed = this.deformed[c.attachment] !== 0;
+    if (at.bindingCounts.length === 0) {
+      const b = c.slotBone * WORLDS;
+      const a = W[b + W_A];
+      const bb = W[b + W_B];
+      const cc = W[b + W_C];
+      const d = W[b + W_D];
+      const wx = W[b + W_X];
+      const wy = W[b + W_Y];
+      const local = deformed ? this.deform : at.local;
+      const lo = deformed ? at.deformOffset : 0;
+      for (let q = 0; q < c.pathVertices; q += 2) {
+        const x = local[lo + q];
+        const y = local[lo + q + 1];
+        pts[q] = x * a + y * bb + wx;
+        pts[q + 1] = x * cc + y * d + wy;
+      }
+      return;
+    }
+    const counts = at.bindingCounts;
+    const bones = at.bindingBones;
+    const xs = at.bindingX;
+    const ys = at.bindingY;
+    const weights = at.bindingWeights;
+    let n = 0;
+    let o = 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 weight = weights[n];
+        const x = deformed ? xs[n] + this.deform[at.deformOffset + n * 2] : xs[n];
+        const y = deformed ? ys[n] + this.deform[at.deformOffset + n * 2 + 1] : ys[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;
+      }
+      pts[o++] = wx;
+      pts[o++] = wy;
+    }
+  }
+  positionsOfPath(c, position, spaceCount, wantsTangent) {
+    this.computePathWorld(c);
+    const pts = this.pathWorldPts;
+    const vc = c.pathVertices;
+    const n = vc / 2;
+    const spaces = this.pathSpaces;
+    const out = this.pathPositions;
+    const outLen = spaceCount * 3 + 2;
+    for (let i = 0; i < outLen; i++) out[i] = 0;
+    const closed = c.closed;
+    if (!c.constantSpeed) {
+      const lengths = c.lengths;
+      const curveCount2 = n / 3 - (closed ? 1 : 2);
+      const total2 = lengths[curveCount2];
+      if (c.positionMode === PATH_POSITION_PERCENT) position *= total2;
+      const spaceScale2 = c.spacingMode === PATH_SPACING_PERCENT ? total2 : c.spacingMode === PATH_SPACING_PROPORTIONAL ? total2 / spaceCount : 1;
+      let curve = 0;
+      for (let i = 0, o = 0; i < spaceCount; i++, o += 3) {
+        const space = spaces[i] * spaceScale2;
+        position += space;
+        let p = position;
+        if (closed) {
+          p %= total2;
+          if (p < 0) p += total2;
+          curve = 0;
+        } else if (p < 0) {
+          onLineBefore(p, pts[2], pts[3], pts[4], pts[5], out, o);
+          continue;
+        } else if (p > total2) {
+          const m0 = 2 * (n - 3);
+          const m1 = 2 * (n - 2);
+          onLinePast(p - total2, pts[m0], pts[m0 + 1], pts[m1], pts[m1 + 1], out, o);
+          continue;
+        }
+        for (; ; curve++) {
+          const length = lengths[curve];
+          if (p > length) continue;
+          if (curve === 0) p /= length;
+          else {
+            const prev = lengths[curve - 1];
+            p = (p - prev) / (length - prev);
+          }
+          break;
+        }
+        const kk = 3 * curve + 1;
+        const i0 = kk % n * 2;
+        const i1 = (kk + 1) % n * 2;
+        const i2 = (kk + 2) % n * 2;
+        const i3 = (kk + 3) % n * 2;
+        onCurve(p, pts[i0], pts[i0 + 1], pts[i1], pts[i1 + 1], pts[i2], pts[i2 + 1], pts[i3], pts[i3 + 1], out, o, wantsTangent || i > 0 && space === 0);
+      }
+      return;
+    }
+    const chain = this.pathChain;
+    let chainLen = 0;
+    if (closed) {
+      for (let q = 2; q < vc; q++) chain[chainLen++] = pts[q];
+      chain[chainLen++] = pts[0];
+      chain[chainLen++] = pts[1];
+      chain[chainLen++] = pts[2];
+      chain[chainLen++] = pts[3];
+    } else {
+      for (let q = 2; q < vc - 2; q++) chain[chainLen++] = pts[q];
+    }
+    const curveCount = closed ? n / 3 : n / 3 - 1;
+    const curveEnds = this.pathCurveEnds;
+    let total = 0;
+    let cx0 = chain[0];
+    let cy0 = chain[1];
+    for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
+      const cx12 = chain[w];
+      const cy12 = chain[w + 1];
+      const cx22 = chain[w + 2];
+      const cy22 = chain[w + 3];
+      const x22 = chain[w + 4];
+      const y22 = chain[w + 5];
+      const h2x = (cx0 - cx12 * 2 + cx22) * 0.1875;
+      const h2y = (cy0 - cy12 * 2 + cy22) * 0.1875;
+      const d3x = ((cx12 - cx22) * 3 - cx0 + x22) * 0.09375;
+      const d3y = ((cy12 - cy22) * 3 - cy0 + y22) * 0.09375;
+      let d2x = h2x * 2 + d3x;
+      let d2y = h2y * 2 + d3y;
+      let d1x = (cx12 - cx0) * 0.75 + h2x + d3x * 0.16666667;
+      let d1y = (cy12 - cy0) * 0.75 + h2y + d3y * 0.16666667;
+      total += Math.sqrt(d1x * d1x + d1y * d1y);
+      d1x += d2x;
+      d1y += d2y;
+      d2x += d3x;
+      d2y += d3y;
+      total += Math.sqrt(d1x * d1x + d1y * d1y);
+      d1x += d2x;
+      d1y += d2y;
+      total += Math.sqrt(d1x * d1x + d1y * d1y);
+      d1x += d2x + d3x;
+      d1y += d2y + d3y;
+      total += Math.sqrt(d1x * d1x + d1y * d1y);
+      curveEnds[i] = total;
+      cx0 = x22;
+      cy0 = y22;
+    }
+    const pathTotal = curveCount > 0 ? curveEnds[curveCount - 1] : 0;
+    if (c.positionMode === PATH_POSITION_PERCENT) position *= pathTotal;
+    const spaceScale = c.spacingMode === PATH_SPACING_PERCENT ? pathTotal : c.spacingMode === PATH_SPACING_PROPORTIONAL ? pathTotal / spaceCount : 1;
+    const segmentEnds = this.pathSegmentEnds;
+    for (let s = 0; s < 10; s++) segmentEnds[s] = 0;
+    let curveTotal = 0;
+    let lastCurve = -1;
+    let x1 = 0, y1 = 0, cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
+    for (let i = 0, o = 0, curve = 0, segment = 0; i < spaceCount; i++, o += 3) {
+      const space = spaces[i] * spaceScale;
+      position += space;
+      let p = position;
+      if (closed) {
+        p %= pathTotal;
+        if (p < 0) p += pathTotal;
+        curve = 0;
+        segment = 0;
+      } else if (p < 0) {
+        onLineBefore(p, chain[0], chain[1], chain[2], chain[3], out, o);
+        continue;
+      } else if (p > pathTotal) {
+        onLinePast(p - pathTotal, chain[chainLen - 4], chain[chainLen - 3], chain[chainLen - 2], chain[chainLen - 1], out, o);
+        continue;
+      }
+      for (; ; curve++) {
+        const length = curveEnds[curve];
+        if (p > length) continue;
+        if (curve === 0) p /= length;
+        else {
+          const prev = curveEnds[curve - 1];
+          p = (p - prev) / (length - prev);
+        }
+        break;
+      }
+      if (curve !== lastCurve) {
+        lastCurve = curve;
+        const ii = curve * 6;
+        x1 = chain[ii];
+        y1 = chain[ii + 1];
+        cx1 = chain[ii + 2];
+        cy1 = chain[ii + 3];
+        cx2 = chain[ii + 4];
+        cy2 = chain[ii + 5];
+        x2 = chain[ii + 6];
+        y2 = chain[ii + 7];
+        const h2x = (x1 - cx1 * 2 + cx2) * 0.03;
+        const h2y = (y1 - cy1 * 2 + cy2) * 0.03;
+        const d3x = ((cx1 - cx2) * 3 - x1 + x2) * 6e-3;
+        const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 6e-3;
+        let d2x = h2x * 2 + d3x;
+        let d2y = h2y * 2 + d3y;
+        let d1x = (cx1 - x1) * 0.3 + h2x + d3x * 0.16666667;
+        let d1y = (cy1 - y1) * 0.3 + h2y + d3y * 0.16666667;
+        curveTotal = Math.sqrt(d1x * d1x + d1y * d1y);
+        segmentEnds[0] = curveTotal;
+        for (let s = 1; s < 8; s++) {
+          d1x += d2x;
+          d1y += d2y;
+          d2x += d3x;
+          d2y += d3y;
+          curveTotal += Math.sqrt(d1x * d1x + d1y * d1y);
+          segmentEnds[s] = curveTotal;
+        }
+        d1x += d2x;
+        d1y += d2y;
+        curveTotal += Math.sqrt(d1x * d1x + d1y * d1y);
+        segmentEnds[8] = curveTotal;
+        d1x += d2x + d3x;
+        d1y += d2y + d3y;
+        curveTotal += Math.sqrt(d1x * d1x + d1y * d1y);
+        segmentEnds[9] = curveTotal;
+        segment = 0;
+      }
+      p *= curveTotal;
+      for (; ; segment++) {
+        const length = segmentEnds[segment];
+        if (p > length) continue;
+        if (segment === 0) p /= length;
+        else {
+          const prev = segmentEnds[segment - 1];
+          p = segment + (p - prev) / (length - prev);
+        }
+        break;
+      }
+      onCurve(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent || i > 0 && space === 0);
+    }
+  }
+  sliderAttachments() {
+    for (let k = 0; k < this.model.constraints.length; k++) {
+      this.sliderSlots(k);
+      this.sliderDeforms(k);
+    }
+  }
+  sliderSlots(index) {
+    const cs = this.model.constraints;
+    {
+      const k = index, c = cs[k];
+      if (c.kind !== "slider" || !c.applied || this.sliderMix[k] === 0) return;
+      const a = c.animation, t = this.sliderAt[k], alpha = this.sliderMix[k];
+      if (!this.model.omitDrawOrder && a.drawOrder !== null) {
+        const di = keyAt(a.drawOrder.curve, this.cursors, a.drawOrder.cursor, t);
+        if (di >= 0) {
+          const ns = this.drawOrder.length, orders = a.drawOrder.orders, base = di * ns;
+          for (let s = 0; s < ns; s++) this.drawOrder[s] = orders[base + s];
+        }
+      }
+      for (let q = 0; q < a.slots.length; q++) {
+        const tl = a.slots[q], i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+        if (i < 0) continue;
+        if (tl.attachments !== null) {
+          const next = tl.attachments[i];
+          if (next !== this.shown[tl.slot] && next >= 0) this.deformed[next] = 0;
+          this.shown[tl.slot] = next;
+        } else {
+          const channels = tl.channels;
+          const slot = this.model.slots[tl.slot];
+          const o = tl.slot * 4, d = tl.slot * 3;
+          for (let f = 0; f < channels.length; f++) {
+            const at = channels[f], v = channelValue(tl.curve, i, f, t);
+            if (at < 4) {
+              const n = o + at;
+              this.light[n] = clamp01(alpha === 1 ? v : this.light[n] + (v - this.light[n]) * alpha);
+            } else if (slot.dark !== null && !this.model.omitDarkColour) {
+              const n = d + (at - 4);
+              this.dark[n] = clamp01(alpha === 1 ? v : this.dark[n] + (v - this.dark[n]) * alpha);
+            }
+          }
+        }
+      }
+    }
+  }
+  sliderDeforms(index) {
+    if (this.model.omitDeform) return;
+    const cs = this.model.constraints;
+    {
+      const k = index, c = cs[k];
+      if (c.kind !== "slider" || !c.applied || this.sliderMix[k] === 0) return;
+      const a = c.animation, t = this.sliderAt[k], alpha = this.sliderMix[k];
+      for (let q = 0; q < a.deforms.length; q++) {
+        const tl = a.deforms[q], i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+        if (i < 0) continue;
+        const held = i + 1 === tl.curve.keys || tl.curve.kinds[i] === CURVE_STEPPED;
+        const p = held ? 0 : deformFraction(tl.curve, i, t), start = i * tl.count;
+        for (let slot = 0; slot < this.shown.length; slot++) {
+          const index2 = this.shown[slot];
+          if (index2 < 0 || !this.model.slots[slot].live) continue;
+          const at = this.model.attachments[index2];
+          if (at.timeline !== tl.identity || at.deformCount === 0) continue;
+          const current = this.deformed[index2] !== 0;
+          for (let f = 0; f < tl.count; f++) {
+            const v = tl.held[start + f], target = held ? v : v + (tl.held[start + tl.count + f] - v) * p;
+            const setup = at.draw === DRAW_MESH ? at.local[f] : 0, n = at.deformOffset + f;
+            const from = current ? this.deform[n] : setup;
+            this.deform[n] = alpha === 1 && (!c.setup.additive || !current) ? target : c.setup.additive ? from + (target - setup) * alpha : from + (target - from) * alpha;
+          }
+          this.deformed[index2] = 1;
+        }
+      }
     }
   }
   solveIk(c, k) {
@@ -10094,7 +11631,10 @@ class RuntimePose {
     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. */
+  /** Absolute/additive transform, matching `solveTransform` in src/core/constraints.ts:
+   * read the source per target/property, edit locals or the scratch world,
+   * then repose the union in bone order (`repose` in that module). No read-back for a local target.
+   */
   solveTransform(c, k) {
     const W = this.world;
     const w = this.w;
@@ -10124,24 +11664,31 @@ class RuntimePose {
             v = v < lo ? lo : v > hi ? hi : v;
           }
           applied = true;
-          applyWorld(w, property, v, mix);
+          if (c.localTarget) {
+            const at = bi * LOCALS + PROPERTY_LOCAL[property];
+            const current = this.locals[at];
+            this.locals[at] = c.additive ? property === P_SCALE_X || property === P_SCALE_Y ? current * (1 + (v - 1) * mix) : current + v * mix : current + (v - current) * mix;
+          } else applyWorld(w, property, v, mix, c.additive);
         }
       }
       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];
+      if (!c.localTarget) {
+        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);
+    if (n > 0) this.repose(n, c.localTarget ? 0 : n);
   }
-  /** The source's world value of a property (`sourceValue`, world source). */
+  /** The source's current local or world value (`sourceValue` in src/core/constraints.ts). */
   sourceValue(c, property) {
+    if (c.localSource) return this.locals[c.source * LOCALS + PROPERTY_LOCAL[property]] + c.offsets[property];
     const W = this.world;
     const s = c.source * WORLDS;
     const o = c.offsets;
@@ -10221,7 +11768,10 @@ class RuntimePose {
     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. */
+  /** A bone's locals read back from its world transform (`localFromWorld` in src/core/constraints.ts).
+   * All five inherit modes: the no-scale forms read rotation first, rebuild
+   * `noScaleDirection`, and retain the x-angle residual as shearX in `decompose`.
+   */
   localFromWorld(bi) {
     const m = this.model;
     const W = this.world;
@@ -10255,6 +11805,21 @@ class RuntimePose {
     const wb = W[w + W_B];
     const wc = W[w + W_C];
     const wd = W[w + W_D];
+    if (mode === MODE_NO_SCALE || mode === MODE_NO_SCALE_OR_REFLECTION) {
+      const det = pa * pd - pb * pc;
+      const flip = mode === MODE_NO_SCALE && det < 0 ? -1 : 1;
+      const sign = det < 0 ? -1 : 1;
+      const rotation = Math.atan2((pa * wc - pc * wa) * sign, (pd * wa - pb * wc) * sign) * DEG;
+      const rr = rotation * RAD;
+      const cos = Math.cos(rr), sin = Math.sin(rr);
+      let ux = pa * cos + pb * sin, uy = pc * cos + pd * sin;
+      const length = 1 / Math.sqrt(ux * ux + uy * uy);
+      ux *= length;
+      uy *= length;
+      this.decompose(l, ux * wa + uy * wc, (ux * wc - uy * wa) * flip, ux * wb + uy * wd, (ux * wd - uy * wb) * flip, true);
+      L[l + L_ROTATION] = rotation;
+      return;
+    }
     if (mode === MODE_ONLY_TRANSLATION) {
       this.decompose(l, wa, wc, wb, wd);
       return;
@@ -10273,7 +11838,7 @@ class RuntimePose {
     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) {
+  decompose(l, la, lc, lb, ld, shearX = false) {
     const L = this.locals;
     const sx = Math.sqrt(la * la + lc * lc);
     const yLength = Math.sqrt(lb * lb + ld * ld);
@@ -10287,11 +11852,11 @@ class RuntimePose {
     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 + (shearX ? L_SHEAR_X : 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);
+    let shear = yAngle - ((shearX ? 0 : xAngle) + right);
     shear = shear > 180 ? shear - 360 : shear < -180 ? shear + 360 : shear;
     L[l + L_SHEAR_Y] = yLength > 1e-5 ? shear : 0;
   }
@@ -10302,16 +11867,32 @@ class RuntimePose {
   slotValues(anim, t) {
     const slots = this.model.slots;
     const light = this.light;
+    const dark = this.dark;
     for (let s = 0; s < slots.length; s++) {
       const slot = slots[s];
       this.shown[s] = slot.setupAttachment;
+      this.drawOrder[s] = s;
       const o = s * 4;
       light[o] = slot.light[0];
       light[o + 1] = slot.light[1];
       light[o + 2] = slot.light[2];
       light[o + 3] = slot.light[3];
+      const setupDark = slot.dark;
+      if (setupDark !== null) {
+        const d = s * 3;
+        dark[d] = setupDark[0];
+        dark[d + 1] = setupDark[1];
+        dark[d + 2] = setupDark[2];
+      }
     }
     if (anim === null) return;
+    if (!this.model.omitDrawOrder && anim.drawOrder !== null) {
+      const di = keyAt(anim.drawOrder.curve, this.cursors, anim.drawOrder.cursor, t);
+      if (di >= 0) {
+        const ns = slots.length, orders = anim.drawOrder.orders, base = di * ns;
+        for (let s = 0; s < ns; s++) this.drawOrder[s] = orders[base + s];
+      }
+    }
     const timelines = anim.slots;
     for (let k = 0; k < timelines.length; k++) {
       const tl = timelines[k];
@@ -10322,11 +11903,18 @@ class RuntimePose {
         continue;
       }
       const channels = tl.channels;
-      const setup = slots[tl.slot].light;
+      const slot = slots[tl.slot];
+      const setup = slot.light;
+      const setupDark = slot.dark;
       const o = tl.slot * 4;
+      const d = tl.slot * 3;
       for (let c = 0; c < channels.length; c++) {
         const at = channels[c];
-        light[o + at] = i < 0 ? setup[at] : clamp01(channelValue(tl.curve, i, c, t));
+        if (at < 4) {
+          light[o + at] = i < 0 ? setup[at] : clamp01(channelValue(tl.curve, i, c, t));
+        } else if (setupDark !== null && !this.model.omitDarkColour) {
+          dark[d + (at - 4)] = i < 0 ? setupDark[at - 4] : clamp01(channelValue(tl.curve, i, c, t));
+        }
       }
     }
   }
@@ -10355,6 +11943,13 @@ class RuntimePose {
       }
     }
   }
+  /** Recompute vertices and overwrite clipping output, without per-frame allocation.
+   * Concave/inverse rows describe the core's drawn coverage, not Spine's native triangle list.
+   */
+  computeClipped() {
+    this.computeVertices();
+    this.clipping?.frame(this);
+  }
   /** Every shown attachment's world vertices into `vertices` at its offset (`regionCorners`, `worldVertices`). */
   computeVertices() {
     const m = this.model;
@@ -10425,10 +12020,10 @@ class RuntimePose {
     }
   }
 }
-function applyWorld(w, property, v, mix) {
+function applyWorld(w, property, v, mix, additive) {
   switch (property) {
     case P_ROTATE: {
-      let r = v * RAD - Math.atan2(w[W_C], w[W_A]);
+      let r = additive ? v * RAD : 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;
@@ -10443,10 +12038,10 @@ function applyWorld(w, property, v, mix) {
       return;
     }
     case P_X:
-      w[W_X] = w[W_X] + (v - w[W_X]) * mix;
+      w[W_X] = additive ? w[W_X] + v * mix : w[W_X] + (v - w[W_X]) * mix;
       return;
     case P_Y:
-      w[W_Y] = w[W_Y] + (v - w[W_Y]) * mix;
+      w[W_Y] = additive ? w[W_Y] + v * mix : w[W_Y] + (v - w[W_Y]) * mix;
       return;
     case P_SCALE_X:
     case P_SCALE_Y: {
@@ -10454,7 +12049,7 @@ function applyWorld(w, property, v, mix) {
       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;
+      const k = additive ? 1 + (v - 1) * mix : 1 + (v - s) * mix / s;
       w[p] *= k;
       w[q] *= k;
       return;
@@ -10462,8 +12057,8 @@ function applyWorld(w, property, v, mix) {
     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;
+      let r = (v + 90) * RAD - (additive ? 90 * RAD : yAngle - xAngle);
+      if (!additive) 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;
@@ -10471,6 +12066,43 @@ function applyWorld(w, property, v, mix) {
     }
   }
 }
+function onLineBefore(p, x1, y1, x2, y2, out, o) {
+  const r = Math.atan2(y2 - y1, x2 - x1);
+  out[o] = x1 + p * Math.cos(r);
+  out[o + 1] = y1 + p * Math.sin(r);
+  out[o + 2] = r;
+}
+function onLinePast(p, x0, y0, x1, y1, out, o) {
+  const r = Math.atan2(y1 - y0, x1 - x0);
+  out[o] = x1 + p * Math.cos(r);
+  out[o + 1] = y1 + p * Math.sin(r);
+  out[o + 2] = r;
+}
+function onCurve(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, wantsTangent) {
+  if (Number.isNaN(p)) {
+    out[o] = x1;
+    out[o + 1] = y1;
+    out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+    return;
+  }
+  const t2 = p * p;
+  const t3 = t2 * p;
+  const u = 1 - p;
+  const u2 = u * u;
+  const u3 = u2 * u;
+  const ut = u * p;
+  const ut3x = ut * 3;
+  const w1 = u * ut3x;
+  const w2 = ut3x * p;
+  const x = x1 * u3 + cx1 * w1 + cx2 * w2 + x2 * t3;
+  const y = y1 * u3 + cy1 * w1 + cy2 * w2 + y2 * t3;
+  out[o] = x;
+  out[o + 1] = y;
+  if (wantsTangent) {
+    if (p < 1e-3) out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+    else out[o + 2] = Math.atan2(y - (y1 * u2 + cy1 * ut * 2 + cy2 * t2), x - (x1 * u2 + cx1 * ut * 2 + cx2 * t2));
+  }
+}
 function frameSource(doc, parsed) {
   if (doc.pages === null) {
     throw new CoreInputError(
@@ -10734,6 +12366,10 @@ function checkedLiveFrame(frame2, current) {
   if (drawing) liveDrawings.set(lease, drawing);
   return lease;
 }
+function withLiveClip(metadata, template) {
+  Object.defineProperty(metadata, "clip", { get: () => template?.clip ?? null });
+  return metadata;
+}
 class RuntimeFrames {
   model;
   pose;
@@ -10742,6 +12378,7 @@ class RuntimeFrames {
   order;
   tint;
   templates;
+  clips;
   colours;
   /** Incremented when a draw refresh changes colour without a pose step. */
   revision = 0;
@@ -10755,6 +12392,11 @@ class RuntimeFrames {
     this.tint = new Float64Array(this.model.slots.length * 4);
     const colours = [];
     const metadata = [];
+    this.clips = this.model.attachments.map((attachment) => attachment.clip === void 0 ? null : {
+      polygon: numbers(this.pose.vertices, attachment.offset, attachment.count),
+      inverse: attachment.clip.inverse,
+      convex: attachment.clip.convex
+    });
     this.templates = this.model.attachments.map((attachment, index) => {
       const identity = attachment;
       if (identity.skin === void 0 || identity.placeholder === void 0) {
@@ -10772,8 +12414,9 @@ class RuntimeFrames {
         if (template.kind === "region") template.corners = vertices;
         else template.vertices = vertices;
         template.tint = numbers(this.tint, attachment.slot * 4, 4);
+        if (slot.dark !== null) template.dark = numbers(this.pose.dark, attachment.slot * 3, 3);
       }
-      metadata.push(Object.freeze({
+      const item = {
         slot: slot.name,
         slotIndex: attachment.slot,
         attachment: attachment.name,
@@ -10788,9 +12431,10 @@ class RuntimeFrames {
         count: attachment.count,
         uvs: Object.freeze(template?.uvs ?? []),
         triangles: Object.freeze(template?.kind === "mesh" ? template.triangles : []),
-        dark: template?.dark ? Object.freeze(template.dark) : null,
+        dark: template?.dark ?? null,
         clip: null
-      }));
+      };
+      metadata.push(Object.freeze(this.pose.clipping === null ? item : withLiveClip(item, template)));
       return template;
     });
     this.colours = colours;
@@ -10818,32 +12462,76 @@ class RuntimeFrames {
     }
     if (colorChanged) this.revision++;
     let count = 0;
-    for (let si = 0; si < this.pose.shown.length; si++) {
+    let clip = null;
+    let end = null;
+    for (let z = 0; z < this.pose.drawOrder.length; z++) {
+      const si = this.pose.drawOrder[z];
       const ai = this.pose.shown[si];
+      const slot = this.model.slots[si];
+      const attachment = ai < 0 ? null : this.model.attachments[ai];
+      if (attachment?.clip !== void 0) {
+        if (clip !== null && end === slot.name) clip = null;
+        if (clip === null && this.model.active[attachment.bone] && draws(slot.name)) {
+          clip = this.clips[ai];
+          end = attachment.clip.end;
+        }
+        continue;
+      }
       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;
+      if (template && this.model.active[slot.bone]) {
+        template.z = z;
+        if (clip === null) {
+          if (template.clip !== void 0) delete template.clip;
+        } else template.clip = clip;
+        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)) {
+          this.order[count] = ai;
+          this.renderFrame.order[count++] = template;
+        }
+      }
+      if (clip !== null && end === slot.name) clip = null;
     }
     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 order = [];
+    const copies = /* @__PURE__ */ new Map();
+    let clip = null;
+    let end = null;
+    for (let z = 0; z < this.pose.drawOrder.length; z++) {
+      const si = this.pose.drawOrder[z];
       const ai = this.pose.shown[si];
+      const attachment = ai < 0 ? null : this.model.attachments[ai];
+      const name = this.model.slots[si].name;
+      if (attachment?.clip !== void 0) {
+        if (clip !== null && end === name) clip = null;
+        if (clip === null && this.model.active[attachment.bone] && (draws === void 0 || draws(name))) {
+          clip = this.clips[ai];
+          end = attachment.clip.end;
+        }
+        continue;
+      }
       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);
+      if (slot && this.model.active[this.model.slots[si].bone] && (draws === void 0 || draws(name))) {
+        const common = { ...slot, z, tint: slot.tint.slice() };
+        if (slot.dark) common.dark = slot.dark.slice();
+        delete common.clip;
+        if (clip !== null) {
+          let copy = copies.get(clip);
+          if (!copy) {
+            copy = { ...clip, polygon: clip.polygon.slice() };
+            copies.set(clip, copy);
+          }
+          common.clip = copy;
+        }
+        order.push(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 });
+      }
+      if (clip !== null && end === name) clip = null;
     }
-    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 };
   }
 }
@@ -11575,6 +13263,70 @@ class RigPlayer {
     if (x !== 0 || y !== 0) live.physicsTranslate(x, y);
     if (motion.rotation) live.physicsRotate(0, 0, motion.rotation);
   }
+  /**
+   * Extra apparent motion for selected physics, synchronously before evaluation.
+   * World distances are X right/Y up; rotation is XY roll around an explicit
+   * world pivot, not yaw/pitch. Does not move bones or draw. A step(0), reset,
+   * seek/skin replay or track promotion may consume/discard external history.
+   * Writes outside the selection are untouched; solver dependencies still apply.
+   */
+  physicsMoved(scope, motion) {
+    const object = (value, fields, where) => {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`physicsMoved: ${where} must be an object`);
+      for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !fields.includes(key)) throw new Error(`physicsMoved: unknown ${where} field ${String(key)}`);
+      return value;
+    };
+    const finite2 = (value, field) => {
+      if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`physicsMoved: ${field} must be a finite number, got ${String(value)}`);
+      return value;
+    };
+    const selection = object(scope, ["bone", "subtree", "constraints"], "scope");
+    const keys = Object.keys(selection);
+    if (keys.length !== 1) throw new Error("physicsMoved: scope must name exactly one of bone, subtree, constraints");
+    const kind = keys[0];
+    let names;
+    if (kind === "constraints") {
+      if (!Array.isArray(selection.constraints)) throw new Error("physicsMoved: constraints must be an array of exact physics names");
+      names = [];
+      for (const name of selection.constraints) {
+        if (typeof name !== "string") throw new Error(`physicsMoved: constraint name ${String(name)} must be a string`);
+        const c = this.view.constraints.find((c2) => c2.kind === "physics" && c2.name === name) ?? this.view.constraints.find((c2) => c2.name === name);
+        if (c === void 0) throw new Error(`physicsMoved: no constraint ${JSON.stringify(name)}`);
+        if (c.kind !== "physics") throw new Error(`physicsMoved: constraint ${JSON.stringify(name)} is ${c.kind}, not physics`);
+        if (!names.includes(name)) names.push(name);
+      }
+    } else {
+      const name = selection[kind];
+      if (typeof name !== "string" || !this.view.bones.some((b) => b.name === name)) throw new Error(`physicsMoved: no bone ${JSON.stringify(name)}`);
+      const parents = new Map(this.view.bones.map((b) => [b.name, b.parent]));
+      const includes = (bone2) => {
+        if (kind === "bone") return bone2 === name;
+        for (let at = bone2; at !== void 0; at = parents.get(at)) if (at === name) return true;
+        return false;
+      };
+      names = this.view.constraints.filter((c) => c.kind === "physics" && includes(c.record?.bone)).map((c) => c.name);
+    }
+    const input = object(motion, ["translation", "rotation"], "motion");
+    if (Object.keys(input).length !== 1) throw new Error("physicsMoved: motion must name exactly one of translation, rotation");
+    let x, y, degrees;
+    if ("translation" in input) {
+      const t = object(input.translation, ["x", "y"], "translation");
+      x = finite2(t.x, "translation.x");
+      y = finite2(t.y, "translation.y");
+    } else {
+      const r = object(input.rotation, ["degrees", "pivot"], "rotation");
+      degrees = finite2(r.degrees, "rotation.degrees");
+      if (!Array.isArray(r.pivot) || r.pivot.length !== 2) throw new Error("physicsMoved: rotation.pivot must be two finite world coordinates");
+      x = finite2(r.pivot[0], "rotation.pivot[0]");
+      y = finite2(r.pivot[1], "rotation.pivot[1]");
+    }
+    if (names.length === 0 || (degrees === void 0 ? x === 0 && y === 0 : degrees === 0)) return;
+    const live = this.stepper();
+    if (live === null) return;
+    if (degrees === void 0) live.physicsTranslate(x, y, names);
+    else live.physicsRotate(x, y, degrees, names);
+    this.clearSeekCache();
+  }
   /** Stops stepping; `frame` keeps drawing the pose it holds. */
   pause() {
     this.paused = true;
@@ -12455,6 +14207,11 @@ class RigPlayer {
       this.poserLabel = "oracle: explicitly selected";
       return;
     }
+    const physics = this.view.constraints.find((constraint) => constraint.kind === "physics");
+    if (physics) {
+      this.poserLabel = `oracle: physics constraint "${physics.name}" requires player clock, seek and movement integration`;
+      return;
+    }
     try {
       this.runtimeModel = compileRuntime(this.view);
       this.poserLabel = this.trackMode ? "oracle: track composition" : this.adjustFn !== null ? "oracle: local adjustment" : "runtime";