@rig-c/core 2.74.1 → 2.76.0

package/docs/AUTHORING.md

@@ -5578,6 +5578,43 @@ skeleton's units and axes, and its change of rotation as `physicsRotate(0, 0,
 Δ)`, before the `step` that poses the frame. Nothing set, every pose is the
 one the track posed before these existed (`CO57`).
 
+Both `LiveTrack` and `LiveTracks` also accept an optional last `scope` argument
+for movement, a readonly array of **exact physics constraint names** (play #197):
+
+```ts
+track.physicsTranslate(dx, dy, ['hair_left', 'hair_right']);
+track.physicsRotate(pivotX, pivotY, deltaDegrees, ['hair_left', 'hair_right']);
+```
+
+Omitted or `undefined` means every existing state, exactly as before. `[]`
+selects none; repeated names select once, in the existing state order. Every
+name is checked against the document before any state changes: an unknown name
+is refused as `physics movement scope: no constraint "name"`; a non-physics
+constraint is refused naming its kind. A non-array scope or non-string name
+also refuses. Finite movement/pivot checks still apply, including an empty
+scope. A declared inactive constraint is a valid selection; movement creates
+no state for it. No document, parameter override, clock or held pose is changed.
+
+These are synchronous **before-evaluation** inputs: only the selected remembered
+origins (`ux`, `uy`, `cx`, `cy`) change, so the next `step` sees extra apparent
+motion. Distances and the explicit pivot are skeleton world units, x right,
+y up; the angle is degrees CCW **in the XY plane**, not yaw or pitch. The turn
+is the displacement of each remembered origin around the pivot, not a direct
+angular impulse; an origin at the pivot has no displacement. The caller derives
+any projected yaw/pitch displacement from its own geometry and depth. Do not
+supply it again for movement the bone itself already makes.
+
+The ordinary step still owns reset, inertia, limits and integration. A reset
+or first active update can overwrite this input; an intervening `step(0)` may
+consume it without the intended positive-time response. There is no queue or
+motion-history replay. Input writes leave all unselected states unchanged;
+after stepping, exact isolation holds for independent chains. Descendants or
+constraints that read a selected bone may react through their normal solver
+dependencies. Scope does not suppress that coupling or expand itself to cover it.
+`CO64` checks single/composed tracks, both resets, exact independent-state
+isolation, native per-constraint operations, empty/all/repeated selections and
+atomic named refusals; the existing `CO56`/`CO57` cover unscoped movement.
+
 For a live preview of one named constraint (issue #1541), both `LiveTrack` and
 `LiveTracks` on `rig-c/core` expose:
 
@@ -12610,7 +12647,7 @@ verdict on those figures.
 | <a id="CE_COMPILE_ALPHA_CLIP_CONFLICT"></a>`CE_COMPILE_ALPHA_CLIP_CONFLICT` | Names authored fields or convex/inverse flags conflicting with generated inside-clipping geometry. Use one authored/generated form.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦: alphaClip conflicts with [⟧<br>⟦vertexCount⟧<br>⟦vertices⟧<br>⟦weights⟧<br>⟦boneIndexing⟧<br>⟦, ⟧<br>⟦], convex=⟧<br>⟦, inverse=⟧<br>⟦; required ordinary inside clipping with generated geometry only. Remove authored geometry/flags.⟧ |
 | <a id="CE_COMPILE_ALPHA_CLIP_DEFORM"></a>`CE_COMPILE_ALPHA_CLIP_DEFORM` | Names animation and source/clip key/frame counts that cannot share the existing projection contract. Give matching explicit supported transform keys in compatible actual frames, with constant world shares where needed, or author the corresponding clip geometry and motion; weighted binding does not copy source deform.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦ alphaClip from "⟧<br>⟦"⟧<br>⟦: animation "⟧<br>⟦" has ⟧<br>⟦ source and ⟧<br>⟦ clip keys; source frame=⟧<br>⟦no vertex geometry⟧<br>⟦clip frame=⟧<br>⟦, constant world influence shares=⟧<br>⟦Required matching explicit affine/depth-yaw/pitch transforms in compatible DeformGeometry frames, ⟧<br>⟦with constant shares for world-space transfer. Fix the named frame/keys or author corresponding clip motion.⟧ |
 
-## 15. Posing in place for a player — the runtime poser (stage 2)
+## 15. Posing in place for a player — the runtime poser (stage 3)
 
 rigc poses a model document twice over, on purpose (issue #1591). The **oracle**
 (`src/core/`) is the reference: each pose is a pure function of the document,
@@ -12645,11 +12682,11 @@ exact resolved table identity `(skin, model.slots[attachment.slot].name, placeho
 The display `name` may be shared by different placeholders; it is never a table
 key to guess the source from. These load-time strings do not change the pose path.
 
-| | what stage 2 poses |
+| | what stage 3 poses |
 | --- | --- |
 | bones | local and world transforms, all five inherit modes, skin-required bones under the view's skin (an inactive bone is zeros, as the oracle poses it) |
 | timelines | `rotate`, `translate(x/y)`, `scale(x/y)`, `shear(x/y)`; a slot's `attachment`, `rgba`, `rgb` and `alpha`; ik and transform timelines; linear, stepped and Bézier keys, each read from a per-pose key cursor |
-| constraints | one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
+| constraints | physics with its exact clock, reset and parameter timelines; value-mapped sliders with bone/slot/deform/physics composition; one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
 | vertices | regions, meshes, weighted meshes and linked meshes, written into the pose's buffer |
 | deform | weighted and unweighted mesh timelines, linear/stepped/Bézier, per-pose key cursors and in-place buffers; linked meshes inherit their source's timelines only with `timelines: true` |
 | skins and events | named/no-skin views with their skin-required bones and constraints; event delivery in key order over `(last, time]`, tail then head across a wrap |
@@ -12692,9 +12729,43 @@ back to the definition's **volume**, matching the measured runtime rather than
 inventing a correction. An explicit `ignore: ['events']` diagnostic still mutes
 the list; normal compilation never does.
 
+Physics is explicit on a direct pose: `apply(time, 'none')` leaves physics inert;
+`apply(time, 'reset', delta)` or `apply(time, 'update', delta)` first applies
+reset keys over `(last, time]` against the old clock, then adds `delta` to the
+physics clock and solves. A backwards animation time crosses the tail then head
+of the interval, as a looping track does. `step(dt)` updates physics and the
+looping track; it takes the initial reset at animation zero if needed.
+`resetPhysics('animation')` starts at that animation's pose zero;
+`resetPhysics('setup')` starts from setup before applying the animation.
+The physics clock is a running sum, never the animation time; constructor option
+`{ clock: physicsClockStep }` can select the render clock without changing track
+time. `physicsTime` exposes that sum. A non-finite or negative delta/clock result
+throws `RuntimeInputError` naming the call. `physicsTranslate(x, y)` and
+`physicsRotate(x, y, degrees)` shift the previous origins; `setEnvironment({
+wind: [x, y], gravity: [x, y] })` supplies the skeleton directions (positive y
+points down), all numbers finite. Offsets, velocities, lags and buffers belong
+to each pose; a zero physics mix does not consume its constraint's clock.
+
+A slider reads its dial where earlier constraints left it: local or world
+property mapped as `to + (value - from) * scale`, clamped at zero or looped by
+its animation duration. A boneless slider uses its keyed `time`. The selected
+animation is applied at that value, never advanced as a track, and fires no
+events or physics reset keys. Mix zero does not re-pose bones; nonzero mix
+re-poses every keyed bone even before its first key. Its bone targets compose
+in authored order, including repeated names; each entry uses the same setup
+values and blends from the current pose. Ordinary tracks still read only the
+last target for each bone. An earlier unsupported inherit target is refused
+when a slider applies it, even if the track's last target would hide it.
+Absolute/additive bone and
+deform blends and slot switches follow the oracle, including direct scale and
+colour targets at mix one. Slider physics writes last one pass and affect only
+constraints later in update order. An unsupported timeline in a slider's
+animation refuses the whole model under that timeline's existing feature name,
+so an unselected track cannot hide a construct the slider always applies.
+
 **Everything else is refused at load, by name.** `RuntimeRefusal.missing` lists
 every construct met, each `{ feature, detail, animation }`, and the message
-reads `not posed by the runtime poser (stage 2), N construct(s) missing:
+reads `not posed by the runtime poser (stage 3), N construct(s) missing:
 <feature>: <detail>; …`. A model-level feature refuses the whole model; an
 animation-level one refuses that animation alone (`model.refused`;
 `model.animation(name)` and `setAnimation(name)` throw its refusal) and every
@@ -12703,7 +12774,7 @@ refused: nothing is posed approximately.
 
 | feature | refuses | what it is |
 | --- | --- | --- |
-| `path-constraint`, `physics-constraint`, `slider-constraint` | the model | a constraint of that kind |
+| `path-constraint` | the model | a constraint of that kind |
 | `local-transform`, `additive-transform` | the model | a transform constraint with `localSource` or `localTarget`, or `additive` |
 | `inactive-constrained-bone` | the model | an applied ik or transform constraint naming a bone the view leaves inactive (what the oracle writes there depends on the pass before) |
 | `noscale-world-target` | the model | a world-space transform onto a `noScale` or `noScaleOrReflection` bone, whose local values would be read back in that mode |
@@ -12718,7 +12789,7 @@ this document's [...]`, `apply: the time NaN is not finite`.
 
 **The gate.** `tools/core_gate.ts` runs a third dumper (`runtimeDump` in
 `tools/pose_oracle.ts`) over every row it builds, at the oracle's samples, and
-compares its document with the oracle's in full doubles at tolerance 0 twice:
+compares both unstepped and stepped documents with the oracle's in full doubles at tolerance 0 twice:
 through `compare` and cell by cell (which reads the bones `compare`'s
 ill-conditioned rule leaves out). One `RUNTIME` line per row reads `IDENTICAL`
 (covered whole and equal), `SKIP` (refused at load, or animations or events left

package/package.json

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

package/src/core/constraints_physics.ts

@@ -645,8 +645,9 @@ export const DEFAULT_PHYSICS_ENVIRONMENT: PhysicsEnvironment = Object.freeze({ w
  * pose. A constraint with no state yet has not been updated, and its first
  * update is pending, so the runtime's translation of it is read by nothing.
  */
-export function translatePhysics(ctx: PhysicsStepContext, x: number, y: number): void {
-  for (const s of ctx.states.values()) {
+export function translatePhysics(ctx: PhysicsStepContext, x: number, y: number, scope?: ReadonlySet<string>): void {
+  for (const [name, s] of ctx.states) {
+    if (scope !== undefined && !scope.has(name)) continue;
     s.ux -= x;
     s.uy -= y;
     s.cx -= x;
@@ -661,11 +662,12 @@ export function translatePhysics(ctx: PhysicsStepContext, x: number, y: number):
  * a translation of each constraint by how far that turn carries the origin it
  * last saw, as `PhysicsConstraint.rotate` computes it.
  */
-export function rotatePhysics(ctx: PhysicsStepContext, x: number, y: number, degrees: number): void {
+export function rotatePhysics(ctx: PhysicsStepContext, x: number, y: number, degrees: number, scope?: ReadonlySet<string>): void {
   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 !== undefined && !scope.has(name)) continue;
     const dx = s.cx - x;
     const dy = s.cy - y;
     const tx = dx * cos - dy * sin - dx;

package/src/core/raw.ts

@@ -728,20 +728,36 @@ export function environmentOf(ctx: PhysicsStepContext): PhysicsEnvironment {
   return ctx.env ?? DEFAULT_PHYSICS_ENVIRONMENT;
 }
 
+/** Validate the complete explicit selection before any remembered state changes. */
+export function checkedPhysicsScope(doc: CompiledDocument, scope: readonly string[] | undefined, who: string): ReadonlySet<string> | undefined {
+  if (scope === undefined) return undefined;
+  if (!Array.isArray(scope)) throw new CoreInputError(`${who} physics movement scope is ${String(scope)}, not an array of physics constraint names`);
+  const selected = new Set<string>();
+  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 === undefined) 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;
+}
+
 /** A live track's `physicsTranslate` (issue #1416): `x` and `y` finite, or refused by name before anything moves; then `translatePhysics`. */
-export function translateOn(ctx: PhysicsStepContext, x: number, y: number, who: string): void {
+export function translateOn(ctx: PhysicsStepContext, x: number, y: number, who: string, scope?: ReadonlySet<string>): void {
   for (const [k, v] of [['x', x], ['y', y]] as const) {
     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);
 }
 
 /** A live track's `physicsRotate` (issue #1416): `x`, `y` and `degrees` finite, or refused by name before anything moves; then `rotatePhysics`. */
-export function rotateOn(ctx: PhysicsStepContext, x: number, y: number, degrees: number, who: string): void {
+export function rotateOn(ctx: PhysicsStepContext, x: number, y: number, degrees: number, who: string, scope?: ReadonlySet<string>): void {
   for (const [k, v] of [['x', x], ['y', y], ['degrees', degrees]] as const) {
     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);
 }
 
 /**

package/src/core/track.ts

@@ -222,7 +222,7 @@
  * history, so a seek is "open, then step to the time".
  */
 import { CoreInputError, type CompiledDocument } from './index.ts';
-import { checkedClock, environmentOf, openRawTrack, rotateOn, setEnvironmentOn, stepRawTrack, translateOn, type RawPose, type RawReset, type TrackState, type WalkMode } from './raw.ts';
+import { checkedClock, checkedPhysicsScope, environmentOf, openRawTrack, rotateOn, setEnvironmentOn, stepRawTrack, translateOn, type RawPose, type RawReset, type TrackState, type WalkMode } from './raw.ts';
 import type { LocalAdjust, TimelinePlant } from './animation.ts';
 import type { PhysicsEnvironment } from './constraints_physics.ts';
 import { LivePhysicsParameters, type PhysicsParameterPatch, type PhysicsParameterRead } from './physics_parameters.ts';
@@ -261,10 +261,12 @@ export interface LiveTrack {
   readPhysicsParameters(name: string): PhysicsParameterRead;
   /** Removes the patch for the next pose without resetting velocities, offsets or the clock. */
   clearPhysicsParameters(name: string): void;
-  /** spine-core's `Skeleton.physicsTranslate`: the consumer moved the whole rig by `(x, y)` in the skeleton's world (y up) since the last pose, and every physics constraint's next update sees it. */
-  physicsTranslate(x: number, y: number): void;
-  /** spine-core's `Skeleton.physicsRotate`: the consumer turned the whole rig by `degrees` (counter-clockwise) about `(x, y)` in the skeleton's world since the last pose. */
-  physicsRotate(x: number, y: number, degrees: number): void;
+  /** Scope omitted: all physics; otherwise exact physics names, validated atomically. Empty selects none, duplicates select once.
+   * Movement changes remembered world origins synchronously, before the next evaluation.
+   * spine-core's `Skeleton.physicsTranslate`: the consumer moved the whole rig by `(x, y)` in the skeleton's world (y up) since the last pose, and every physics constraint's next update sees it. */
+  physicsTranslate(x: number, y: number, scope?: readonly string[]): void;
+  /** Same scope contract as physicsTranslate. The consumer turned by `degrees` (counter-clockwise) about explicit `(x, y)` in the skeleton's world; changes remembered origins, not tip direction or angular velocity. */
+  physicsRotate(x: number, y: number, degrees: number, scope?: readonly string[]): void;
 }
 
 /** The two modes: a track that holds at its duration is the raw entry's walk; a looping one fires its events across the wrap and cuts its clipped rows (`live`). Neither keeps a non-finite value. */
@@ -336,14 +338,14 @@ class Track implements LiveTrack {
     this.parameters.clear(name);
   }
 
-  physicsTranslate(x: number, y: number): void {
+  physicsTranslate(x: number, y: number, scope?: readonly string[]): void {
     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: number, y: number, degrees: number): void {
+  physicsRotate(x: number, y: number, degrees: number, scope?: readonly string[]): void {
     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. */

package/src/core/tracks.ts

@@ -164,7 +164,7 @@ import { activeBones, CoreInputError, rawNumber, shownAttachment, viewColours, W
 import { channelAt, keyIndexAt, SLOT_COLOUR_TIMELINES, slotRowsFrom, steppedLocalsWorld, type BoneTimelineKind, type CoreKey, type LocalAdjust, type SlotBase, type SlotColourKind, type TimelinePlant } from './animation.ts';
 import { deformAt, setupArray, type CoreAttachmentTimeline } from './deform.ts';
 import { eventsFired, type CoreEventKey, type CoreEventRow } from './events.ts';
-import { checkedClock, environmentOf, openRawTracksPath, rotateOn, setEnvironmentOn, translateOn, type RawPose, type RawReset, type RawTracksPath } from './raw.ts';
+import { checkedClock, checkedPhysicsScope, environmentOf, openRawTracksPath, rotateOn, setEnvironmentOn, translateOn, type RawPose, type RawReset, type RawTracksPath } from './raw.ts';
 import type { PhysicsEnvironment } from './constraints_physics.ts';
 import { LivePhysicsParameters, type PhysicsParameterPatch, type PhysicsParameterRead } from './physics_parameters.ts';
 import { slotTimelinesApply } from './skins.ts';
@@ -240,10 +240,12 @@ export interface LiveTracks {
   readPhysicsParameters(name: string): PhysicsParameterRead;
   /** Removes the patch without resetting the physics history, as LiveTrack.clearPhysicsParameters. */
   clearPhysicsParameters(name: string): void;
-  /** spine-core's `Skeleton.physicsTranslate`, as `LiveTrack.physicsTranslate`. */
-  physicsTranslate(x: number, y: number): void;
-  /** spine-core's `Skeleton.physicsRotate`, as `LiveTrack.physicsRotate`. */
-  physicsRotate(x: number, y: number, degrees: number): void;
+  /** Scope omitted: all physics; otherwise exact physics names, validated atomically. Empty selects none, duplicates select once.
+   * Movement changes remembered world origins synchronously, before the next evaluation.
+   * spine-core's `Skeleton.physicsTranslate`, as `LiveTrack.physicsTranslate`. */
+  physicsTranslate(x: number, y: number, scope?: readonly string[]): void;
+  /** Same exact-name scope and explicit world pivot as `LiveTrack.physicsRotate`. */
+  physicsRotate(x: number, y: number, degrees: number, scope?: readonly string[]): void;
 }
 
 /**
@@ -1384,14 +1386,14 @@ class Tracks implements LiveTracks {
     this.parameters.clear(name);
   }
 
-  physicsTranslate(x: number, y: number): void {
+  physicsTranslate(x: number, y: number, scope?: readonly string[]): void {
     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: number, y: number, degrees: number): void {
+  physicsRotate(x: number, y: number, degrees: number, scope?: readonly string[]): void {
     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\''));
   }
 
   private live(call: string): void {

package/src/runtime/curves.ts

@@ -78,7 +78,9 @@ export function compileCurve(keys: readonly CoreKey[], channels: number): Runtim
 /** The last key at or before `t` (−1 before the first), found from `cursors[slot]` and left there — the header's first read. */
 export function keyAt(curve: RuntimeCurve, cursors: Int32Array, slot: number, t: number): number {
   const times = curve.times;
-  let i = cursors[slot];
+  // A slider can evaluate another animation between two reads of this one.
+  // Shared cursor slots are only search hints: keep the hint inside THIS curve.
+  let i = Math.min(cursors[slot], curve.keys - 1);
   while (i >= 0 && times[i] > t) i--;
   while (i + 1 < curve.keys && times[i + 1] <= t) i++;
   cursors[slot] = i;

package/src/runtime/index.ts

@@ -21,12 +21,12 @@
  * corpus through both at the oracle's samples and compares full doubles at
  * tolerance 0 (*The runtime poser* there). The oracle is not changed for it.
  *
- * ## Stage 2: what it poses, and what it refuses
+ * ## Stage 3: what it poses, and what it refuses
  *
  * Bones and their five inherit modes; the rotate, translate, scale and shear
  * timelines; a slot's attachment and colour (`rgba`, `rgb`, `alpha`)
  * timelines; weighted/unweighted deform timelines; region, mesh, weighted mesh and linked mesh vertices; one- and
- * two-bone ik and world-space, absolute transform constraints with their
+ * two-bone ik, world-space absolute transforms, physics and value-mapped sliders with their
  * timelines; skin-required bones and constraints under the view's skin. One
  * animation at full weight from the setup pose, at a time or stepped as a
  * looping track. Everything else is refused at load by name with the list of
@@ -81,4 +81,5 @@ export {
   L_SHEAR_Y,
 } from './model.ts';
 export type { RuntimeAnimation, RuntimeEvent, RuntimeAttachment, RuntimeFeature, RuntimeMissing, RuntimeModel, RuntimeOptions, RuntimePlant, RuntimeSlot } from './model.ts';
+export type { RuntimePoseOptions, RuntimePhysicsPhase } from './pose.ts';
 export { RuntimePose } from './pose.ts';

package/src/runtime/model.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's load-time half (issue #1591, stage 2): a skin view of
+ * The runtime poser's load-time half (issue #1591, stage 3): a skin view of
  * the compiled model (`readModel`, then `underSkin` / `underNoSkin` — the
  * oracle's reader and its views, read and never written) compiled once into
  * index-resolved bones and slots, a constraint plan, compiled timelines and
@@ -12,7 +12,7 @@
  * (`RuntimeMissing`), and:
  *
  * - **refuses the model** (`RuntimeRefusal`, every missing feature listed)
- *   when one is a property of the whole model — a path, physics or slider constraint, a transform constraint reading or
+ *   when one is a property of the whole model — a path constraint, a transform constraint reading or
  *   writing local values or adding (`localSource`, `localTarget`,
  *   `additive`), an ik or transform constraint over a bone the view leaves
  *   inactive, a world-space transform onto a `noScale` or
@@ -26,9 +26,9 @@
  *   attachment key showing a clipping attachment or a region with no atlas
  *   rectangle. Every other animation of the model is posed.
  *
- * `RUNTIME_FEATURES` is the closed list of what can be named. Stage 2 adds mesh deform timelines to the
- * named/no-skin views and event keys, with immutable payloads compiled
- * at load. `ignore: ['events']` remains an explicit diagnostic opt-out; it is
+ * `RUNTIME_FEATURES` is the closed list of what can be named. Stage 3 adds indexed physics and value-mapped sliders, including their
+ * parameter timelines and per-pass writes. Mesh deforms, named/no-skin views
+ * and immutable event deliveries remain covered. `ignore: ['events']` remains an explicit diagnostic opt-out; it is
  * never the default. A merged view with conflicting attachments still refuses
  * by name, as the oracle itself cannot resolve that view without file order.
  *
@@ -50,16 +50,16 @@ import { activeBones, constraintRecords, CORE_REGION_KINDS, foldInheritMode, rea
 import { constraintInactiveWhy, constraintsAbsentWhy, TRANSFORM_PROPERTIES, type CoreIkRecord, type CoreTransformRecord } from '../core/constraints.ts';
 import { RUNTIME_PI } from '../core/world.ts';
 import { heldArray, timelineIdentity } from '../core/deform.ts';
+import type { CorePhysicsRecord, PhysicsTimelineKind } from '../core/constraints_physics.ts';
+import type { CoreSliderRecord } from '../core/constraints_slider.ts';
 import { compileCurve, compileDeformCurve, type RuntimeCurve } from './curves.ts';
 
 /** The stage of issue #1591 this poser implements. */
-export const RUNTIME_STAGE = 2;
+export const RUNTIME_STAGE = 3;
 
 /** Every construct the runtime poser can refuse, by the name its refusals carry. */
 export const RUNTIME_FEATURES = [
   'path-constraint',
-  'physics-constraint',
-  'slider-constraint',
   'local-transform',
   'additive-transform',
   'inactive-constrained-bone',
@@ -126,6 +126,8 @@ export interface RuntimePlant {
   /** The old restore behavior, which repeats keys up to the restored time. */
   readonly restoreEventsFromStart?: boolean;
   /** Omit deform / multiply offsets by weights too early: negative controls only. */
+  readonly omitPhysics?: boolean;
+  readonly sliderAsTrack?: boolean;
   readonly omitDeform?: boolean;
   readonly deformAfterWeights?: boolean;
 }
@@ -257,7 +259,41 @@ export interface RuntimeTransform {
   readonly clamp: boolean;
 }
 
-export type RuntimeConstraint = RuntimeIk | RuntimeTransform;
+export interface RuntimePhysics {
+  readonly kind: 'physics';
+  readonly name: string;
+  readonly index: number;
+  readonly applied: boolean;
+  readonly bones: Int32Array;
+  readonly setup: CorePhysicsRecord;
+}
+
+export interface RuntimeSlider {
+  readonly kind: 'slider';
+  readonly name: string;
+  readonly index: number;
+  readonly applied: boolean;
+  readonly bones: Int32Array;
+  readonly bone: number;
+  readonly property: number;
+  readonly setup: CoreSliderRecord;
+  /** Resolved after every animation is compiled. Never a track. */
+  animation: RuntimeAnimation;
+}
+
+export interface RuntimePhysicsTimeline {
+  readonly kind: PhysicsTimelineKind;
+  readonly targets: Int32Array;
+  readonly curve: RuntimeCurve;
+  readonly cursor: number;
+}
+export interface RuntimeSliderTimeline {
+  readonly time: RuntimeCurve | null;
+  readonly mix: RuntimeCurve | null;
+  readonly timeCursor: number;
+  readonly mixCursor: number;
+}
+export type RuntimeConstraint = RuntimeIk | RuntimeTransform | RuntimePhysics | RuntimeSlider;
 
 /** A bone timeline: the bone, its curve, and per channel the local field it writes and whether it multiplies the setup value (scale) or adds to it. */
 export interface RuntimeBoneTimeline {
@@ -310,7 +346,11 @@ export interface RuntimeAnimation {
   readonly name: string;
   readonly duration: number;
   readonly bones: readonly RuntimeBoneTimeline[];
+  /** Every authored target in order; sliders compose duplicates that tracks discard. */
+  readonly sliderBones: readonly RuntimeBoneTimeline[];
   readonly deforms: readonly RuntimeDeformTimeline[];
+  readonly physics: readonly RuntimePhysicsTimeline[];
+  readonly sliders: ReadonlyArray<RuntimeSliderTimeline | null>;
   readonly slots: readonly RuntimeSlotTimeline[];
   /** Per constraint of the plan, its timeline in this animation or `null`. */
   readonly constraints: ReadonlyArray<RuntimeConstraintTimeline | null>;
@@ -326,6 +366,8 @@ export interface RuntimeModel {
   /** Control-only boundary defect; fixed at load. */
   readonly omitDeform: boolean;
   readonly deformAfterWeights: boolean;
+  readonly omitPhysics: boolean;
+  readonly sliderAsTrack: boolean;
   readonly deformCount: number;
   readonly eventWrapOffByOne: boolean;
   readonly restoreEventsFromStart: boolean;
@@ -449,13 +491,21 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
 
   // --- constraints, in the document's order ---
   const constraints: RuntimeConstraint[] = [];
-  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 c of doc.constraints) if (c.kind === 'path') refusals.note(`${c.kind}-constraint`, `${c.kind} constraint "${c.name}"`);
   for (const r of constraintRecords(doc)) {
-    if (r.kind !== 'ik' && r.kind !== 'transform') continue;
+    if (r.kind === 'path') continue;
     const applied = constraintInactiveWhy(r, active) === null;
-    const bones = Int32Array.from(r.bones.map(indexOf));
-    if (applied && r.bones.some((b) => !active.has(b))) refusals.note('inactive-constrained-bone', `${r.kind} constraint "${r.name}" names bone(s) ${r.bones.filter((b) => !active.has(b)).map((b) => `"${b}"`).join(', ')}, which the view leaves inactive — what the oracle writes there depends on the pass before`);
+    const 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 as unknown as RuntimeAnimation });
+      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 ')}`);
@@ -573,9 +623,16 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
     }
   }
 
+  for (const c of constraints) if (c.kind === 'slider') {
+    const a = animations.get(c.setup.animation);
+    if (a !== undefined) 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,
     deformCount,
@@ -714,18 +771,32 @@ function compileAnimation(
 
   const lastBy = <T extends { name: string }>(targets: readonly T[]): Map<string, T> => new Map(targets.map((t) => [t.name, t]));
   const bones: RuntimeBoneTimeline[] = [];
-  for (const target of lastBy(tl.bones).values()) {
+  type BoneTarget = (typeof tl.bones)[number];
+  const byTarget = new Map<BoneTarget, RuntimeBoneTimeline[]>();
+  const compileBones = (target: BoneTarget, forSlider: boolean): RuntimeBoneTimeline[] => {
+    const cached = byTarget.get(target);
+    if (cached !== undefined) return cached;
+    const keyed: RuntimeBoneTimeline[] = [];
+    byTarget.set(target, keyed);
     const bone = boneIndex.get(target.name);
-    if (bone === undefined) continue;
+    if (bone === undefined) 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, 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, 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;
+  };
+  // Keep the track's last-target Map order and reuse those exact curves/cursors.
+  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: RuntimeSlotTimeline[] = [];
   const keyedSlots = [...lastBy(tl.slots).values()].flatMap((target) => {
     const si = slotIndex.get(target.name);
@@ -752,12 +823,22 @@ function compileAnimation(
       const keyed = anim.constraints.ik.find((x) => x.name === c.name);
       if (keyed === undefined) 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 === undefined) continue;
       constraintTimelines[c.index] = { constraint: c.index, curve: compileCurve(keyed.keys, TRANSFORM_PROPERTIES.length), cursor: cursors++, flags: null };
     }
   }
+  const sliders = constraints.map((c): RuntimeSliderTimeline | null => {
+    if (c.kind !== 'slider') return null;
+    const keyed = anim.constraints.slider.find(t => t.name === c.name);
+    if (keyed === undefined) 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 physics: RuntimePhysicsTimeline[] = (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 is RuntimePhysics => 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: RuntimeDeformTimeline[] = deform.map(a => {
     const g = doc.skins.find(s => s.name === a.skin)?.attachments[a.slot]?.[a.attachment]?.geometry;
     if (g === undefined || g.kind === 'region' || g.kind === 'linkedmesh') throw new RuntimeInputError(`deform "${a.skin}/${a.slot}/${a.attachment}" has no vertex geometry (readModel refuses it first)`);
@@ -765,5 +846,5 @@ function compileAnimation(
     const arrays = keys.map(k => heldArray(g.vertices, k));
     return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
   });
-  return { name, duration: tl.duration, 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, deforms, bones, sliderBones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map(key => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
 }

package/src/runtime/physics.ts

@@ -0,0 +1,235 @@
+/** Indexed in-place physics. Arithmetic and operation order mirror the measured oracle;
+ * state is allocated once per pose, never during an update. */
+import type { CorePhysicsRecord } from '../core/constraints_physics.ts';
+import { RUNTIME_PI } from '../core/world.ts';
+const PI2 = RUNTIME_PI * 2;
+const INV_PI2 = 1 / PI2;
+export interface PhysicsState {
+  /** The next update takes the bone where it is and integrates nothing: set by a reset and on a constraint never updated. */
+  pending: boolean;
+  lastTime: number;
+  remaining: number;
+  ux: number;
+  uy: number;
+  cx: number;
+  cy: number;
+  tx: number;
+  ty: number;
+  xOffset: number;
+  xLag: number;
+  xVelocity: number;
+  yOffset: number;
+  yLag: number;
+  yVelocity: number;
+  rotateOffset: number;
+  rotateLag: number;
+  rotateVelocity: number;
+  scaleOffset: number;
+  scaleLag: number;
+  scaleVelocity: number;
+}
+
+/** A constraint's state before its first update: pending, its clock at 0. */
+export function freshPhysicsState(): PhysicsState {
+  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 };
+}
+
+/** A reset: offsets, velocities and lags cleared, nothing remaining, the clock read at `time`, pending. */
+export function resetPhysicsState(s: PhysicsState, time: number): void {
+  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;
+}
+
+export function stepRuntimePhysics(r: CorePhysicsRecord, s: PhysicsState, w: Float64Array, boneOffset: number, length: number, time: number, reset: boolean, env: Float64Array): boolean {
+  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);
+  // The interpolation weight of the previous update, before this one's time is added: the rotate and the scale-only inertia read the pose as it was shown.
+  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;
+        // The environment's directions (issue #1416), as the runtime weighs them; the skeleton's scale is 1 here, so its factor is left out.
+        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) {
+        // The rotation's share turns the y column here, and the x column with the shear below.
+        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;
+    // The transverse column follows the authored mode (issue #1453), after
+    // the X column: the native Volume branch bounds reciprocal compression
+    // below 0.7; it is not an area-preservation promise on that branch.
+    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;
+}

package/src/runtime/pose.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's per-instance half (issue #1591, stage 2): one
+ * The runtime poser's per-instance half (issue #1591, stage 3): one
  * `RuntimePose` per skeleton on screen, every buffer allocated when it is
  * made and overwritten in place on every pose, so that posing a frame
  * allocates nothing.
@@ -13,8 +13,9 @@
  * document's order with their timelines' values at `t`, each followed by the
  * bones below what it moved posed again; then each slot's colour and what it
  * shows; then, when asked, every shown attachment's world vertices. Nothing
- * of one pose survives into the next but the key cursors, which only make
- * the key search start nearer.
+ * of one unstepped pose survives but key cursors. A stepped pose also keeps
+ * its physics clock, offsets, velocities and lags; sliders select values
+ * within this pose rather than advancing an independent track.
  *
  * ## The arithmetic is the oracle's
  *
@@ -37,6 +38,8 @@
  * exactly 0 touching nothing; an inactive bone posed as zeros by the
  * hierarchy and never posed again by a constraint, nor the bones below it.
  */
+import type { CorePhysicsRecord } from '../core/constraints_physics.ts';
+import { freshPhysicsState, resetPhysicsState, stepRuntimePhysics, type PhysicsState } from './physics.ts';
 import { COLLAPSED_X_AXIS_SQ, RUNTIME_DEG, RUNTIME_PI } from '../core/world.ts';
 import { channelValue, keyAt, deformFraction, CURVE_STEPPED } from './curves.ts';
 import {
@@ -75,6 +78,8 @@ import {
   type RuntimeIk,
   type RuntimeModel,
   type RuntimeTransform,
+  type RuntimeSlider,
+  type RuntimePhysicsTimeline,
 } from './model.ts';
 
 const DEG = RUNTIME_DEG;
@@ -98,6 +103,10 @@ function volumeScaleY(scaleY: number, s: number): number {
 
 const clamp01 = (v: number): number => (v < 0 ? 0 : v > 1 ? 1 : v);
 
+/** A caller-supplied physics clock; animation/track time still uses dt itself. */
+export interface RuntimePoseOptions { readonly clock?: (dt: number) => number }
+export type RuntimePhysicsPhase = 'none' | 'reset' | 'update';
+
 /** One skeleton's pose, every value in place. Read `world`, `light`, `shown` and `vertices` after a pose. */
 export class RuntimePose {
   readonly model: RuntimeModel;
@@ -139,8 +148,29 @@ export class RuntimePose {
   private readonly visit: Uint8Array;
   private readonly w = new Float64Array(WORLDS);
 
-  constructor(model: RuntimeModel) {
+  /** Sum of caller-supplied physics deltas, independent of animation time. */
+  physicsTime = 0;
+  private physicsLast = -1;
+  private physicsPhase: RuntimePhysicsPhase = 'none';
+  private physicsReady = false;
+  private readonly hasPhysics: boolean;
+  private readonly physicsStates: PhysicsState[];
+  private readonly physicsRecords: Array<CorePhysicsRecord | null>;
+  private readonly environment = new Float64Array([1, 0, 0, 1]);
+  private readonly sliderTime: Float64Array;
+  private readonly sliderMix: Float64Array;
+  private readonly sliderAt: Float64Array;
+  private readonly clock: ((dt: number) => number) | undefined;
+
+  constructor(model: RuntimeModel, options: RuntimePoseOptions = {}) {
     this.model = model;
+    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;
@@ -168,6 +198,10 @@ export 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: string): void {
     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;
@@ -190,40 +224,57 @@ export class RuntimePose {
   }
 
   /** The setup pose: every constraint applied with its own values, every slot as it is set up. */
-  setupPose(): void {
+  setupPose(physics: RuntimePhysicsPhase = 'none'): void {
+    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.attachmentValues(null, 0);
   }
 
   /** The animation posed at its time `t`, from the setup pose (the header). */
-  apply(t: number): void {
+  apply(t: number, physics: RuntimePhysicsPhase = 'none', delta = 0): void {
     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;
+    // Reset keys see the old clock. The skeleton moves by delta only after application.
+    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.attachmentValues(anim, t);
   }
 
   /** One step of a looping track: the track time moved by `dt`, the animation posed at it wrapped by the duration (`loopedTime` in src/core/raw.ts). */
   step(dt: number): void {
     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) {
+      // Initial physics setup must not consume the event interval of this step.
+      const lastEventTime = this.eventTime;
+      this.apply(this.time, 'reset', 0);
+      this.eventTime = lastEventTime;
+    }
+    const moved = this.clock === undefined ? 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. */
@@ -427,9 +478,24 @@ export class RuntimePose {
           this.ikSoftness[k] = c.softness + (channelValue(tl.curve, i, 1, t) - c.softness) * 1;
           this.ikFlags[k] = (tl.flags as Uint8Array)[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;
       }
     }
   }
@@ -441,7 +507,222 @@ export class RuntimePose {
       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 (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);
+        }
+      }
+    }
+  }
+
+  /** Reset where the consumer starts: the setup pose or animation pose zero. */
+  resetPhysics(at: 'setup' | 'animation' = 'animation'): void {
+    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;
+  }
+
+  /** External motion changes the previous origin, never the authored locals. */
+  physicsTranslate(x: number, y: number): void {
+    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++) {
+      const s = this.physicsStates[k];
+      s.ux -= x; s.uy -= y; s.cx -= x; s.cy -= y;
+    }
+  }
+
+  physicsRotate(x: number, y: number, degrees: number): void {
+    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++) {
+      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: { readonly wind: readonly [number, number]; readonly gravity: readonly [number, number] }): void {
+    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. */
+  private physicsValues(anim: RuntimeAnimation | null, t: number, resets: boolean): void {
+    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;
+  }
+
+  private physicsTimelines(timelines: readonly RuntimePhysicsTimeline[], t: number, alpha: number, additive: boolean, setup: boolean, resets = false): void {
+    for (let q = 0; q < timelines.length; q++) {
+      const tl = timelines[q];
+      if (tl.kind === 'reset') {
+        if (!resets) continue; // a slider applies at one value; no key is crossed
+        let crossed = false;
+        const last = this.physicsLast;
+        for (let i = 0; i < tl.curve.keys; i++) {
+          const time = tl.curve.times[i];
+          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) {
+        // A track's before-first key restores setup even if an earlier global
+        // timeline wrote this parameter. A slider's before-first key writes nothing.
+        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] as { setup: CorePhysicsRecord }).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] as { setup: CorePhysicsRecord }).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. */
+  private solveSlider(c: RuntimeSlider, k: number): void {
+    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: number;
+      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);
+  }
+
+  private attachmentValues(anim: RuntimeAnimation | null, t: number): void {
+    this.slotValues(anim, t);
+    this.deformValues(anim, t);
+    for (let k = 0; k < this.model.constraints.length; k++) {
+      this.sliderSlots(k);
+      this.sliderDeforms(k);
+    }
+  }
+
+  private sliderSlots(index: number): void {
+    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.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!;
+          for (let f = 0; f < channels.length; f++) {
+            const n = tl.slot * 4 + channels[f], v = channelValue(tl.curve, i, f, t);
+            this.light[n] = clamp01(alpha === 1 ? v : this.light[n] + (v - this.light[n]) * alpha);
+          }
+        }
+      }
+    }
+  }
+
+  private sliderDeforms(index: number): void {
+    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 index = this.shown[slot];
+          if (index < 0 || !this.model.slots[slot].live) continue;
+          const at = this.model.attachments[index];
+          if (at.timeline !== tl.identity || at.deformCount === 0) continue;
+          const current = this.deformed[index] !== 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[index] = 1;
+        }
+      }
     }
   }
 
@@ -868,6 +1149,20 @@ export 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;
@@ -887,7 +1182,7 @@ export class RuntimePose {
   }
 
   /** A local matrix with columns `(la, lc)` and `(lb, ld)` as rotation, scales and shear (`decompose`). */
-  private decompose(l: number, la: number, lc: number, lb: number, ld: number): void {
+  private decompose(l: number, la: number, lc: number, lb: number, ld: number, shearX = false): void {
     const L = this.locals;
     const sx = Math.sqrt(la * la + lc * lc);
     const yLength = Math.sqrt(lb * lb + ld * ld);
@@ -901,11 +1196,11 @@ export 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 > 0.00001 ? shear : 0;
   }