@rig-c/core 2.76.0 → 2.77.0

package/docs/AUTHORING.md

@@ -12647,7 +12647,7 @@ verdict on those figures.
 | <a id="CE_COMPILE_ALPHA_CLIP_CONFLICT"></a>`CE_COMPILE_ALPHA_CLIP_CONFLICT` | Names authored fields or convex/inverse flags conflicting with generated inside-clipping geometry. Use one authored/generated form.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦: alphaClip conflicts with [⟧<br>⟦vertexCount⟧<br>⟦vertices⟧<br>⟦weights⟧<br>⟦boneIndexing⟧<br>⟦, ⟧<br>⟦], convex=⟧<br>⟦, inverse=⟧<br>⟦; required ordinary inside clipping with generated geometry only. Remove authored geometry/flags.⟧ |
 | <a id="CE_COMPILE_ALPHA_CLIP_DEFORM"></a>`CE_COMPILE_ALPHA_CLIP_DEFORM` | Names animation and source/clip key/frame counts that cannot share the existing projection contract. Give matching explicit supported transform keys in compatible actual frames, with constant world shares where needed, or author the corresponding clip geometry and motion; weighted binding does not copy source deform.<br>Exact fixed diagnostic chunks (named values between chunks vary): ⟦ alphaClip from "⟧<br>⟦"⟧<br>⟦: animation "⟧<br>⟦" has ⟧<br>⟦ source and ⟧<br>⟦ clip keys; source frame=⟧<br>⟦no vertex geometry⟧<br>⟦clip frame=⟧<br>⟦, constant world influence shares=⟧<br>⟦Required matching explicit affine/depth-yaw/pitch transforms in compatible DeformGeometry frames, ⟧<br>⟦with constant shares for world-space transfer. Fix the named frame/keys or author corresponding clip motion.⟧ |
 
-## 15. Posing in place for a player — the runtime poser (stage 3)
+## 15. Posing in place for a player — the runtime poser (stage 4)
 
 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,
@@ -12682,13 +12682,13 @@ 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 3 poses |
+| | what stage 4 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 | 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 |
+| timelines | `rotate`, `translate(x/y)`, `scale(x/y)`, `shear(x/y)`; a slot's `attachment`, `rgba`, `rgb` and `alpha`; ik, transform and path timelines; linear, stepped and Bézier keys, each read from a per-pose key cursor |
+| constraints | physics with its exact clock, reset and parameter timelines, and optional constraint-scoped external translate/rotate; value-mapped sliders with bone/slot/deform/physics composition; path constraints across all position, spacing and rotate modes on open or closed, constant-speed or arc-length, weighted or unweighted, deformed curves; one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
 | 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` |
+| deform | weighted and unweighted mesh and path timelines, linear/stepped/Bézier, per-pose key cursors and in-place buffers; linked meshes inherit their source's timelines only with `timelines: true` |
 | skins and events | named/no-skin views with their skin-required bones and constraints; event delivery in key order over `(last, time]`, tail then head across a wrap |
 | time | one animation at full weight from the setup pose, at a time (`apply`) or stepped as a looping track (`step`, the track time wrapped by the duration as `openTrack` wraps it) |
 
@@ -12740,8 +12740,12 @@ looping track; it takes the initial reset at animation zero if needed.
 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({
+throws `RuntimeInputError` naming the call. `physicsTranslate(x, y, scope?)` and
+`physicsRotate(x, y, degrees, scope?)` shift the previous origins across every
+physics constraint when `scope` is omitted, or only across the named physics
+constraints (`scope: []` moves none; duplicate names apply once; an unknown or
+non-physics constraint name throws `RuntimeInputError` before mutating any
+state); `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.
@@ -12765,7 +12769,7 @@ 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 3), N construct(s) missing:
+reads `not posed by the runtime poser (stage 4), 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
@@ -12774,13 +12778,12 @@ refused: nothing is posed approximately.
 
 | feature | refuses | what it is |
 | --- | --- | --- |
-| `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) |
+| `inactive-constrained-bone` | the model | an applied ik, transform or path 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 |
 | `clipping`, `null-atlas-region` | the model when shown at setup, else the animation that keys it | a clipping attachment; a region whose atlas rectangle the model states as `null` |
 | `skin-conflict` | as above | a placeholder the skins fill differently |
-| `oracle-absent` | the model | a pose the oracle itself leaves out (`constraintsAbsentWhy`) |
+| `oracle-absent` | the model | a pose the oracle itself leaves out (`constraintsAbsentWhy`, `pathAnimationsWhy`, `steppedPreviousPassWhy`, `sliderDeformsWalkedPathWhy`) |
 | `inherit-timeline`, `sequence-timeline`, `draw-order-timeline`, `dark-colour-timeline` | the animation | a timeline of that kind (`dark-colour` is `rgba2` / `rgb2`) |
 
 A call it cannot answer throws `RuntimeInputError`, naming the call:

package/package.json

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

package/src/runtime/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 3: what it poses, and what it refuses
+ * ## Stage 4: 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, world-space absolute transforms, physics and value-mapped sliders with their
+ * two-bone ik, world-space absolute transforms, path constraints, physics (with optional movement scope) and value-mapped sliders with their
  * timelines; skin-required bones and constraints under the view's skin. One
  * animation at full weight from the setup pose, at a time or stepped as a
  * looping track. Everything else is refused at load by name with the list of

package/src/runtime/model.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's load-time half (issue #1591, stage 3): a skin view of
+ * The runtime poser's load-time half (issue #1591, stage 4): 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,9 +12,9 @@
  * (`RuntimeMissing`), and:
  *
  * - **refuses the model** (`RuntimeRefusal`, every missing feature listed)
- *   when one is a property of the whole model — a path constraint, a transform constraint reading or
+ *   when one is a property of the whole model — a transform constraint reading or
  *   writing local values or adding (`localSource`, `localTarget`,
- *   `additive`), an ik or transform constraint over a bone the view leaves
+ *   `additive`), an ik, transform or path constraint over a bone the view leaves
  *   inactive, a world-space transform onto a `noScale` or
  *   `noScaleOrReflection` bone, a clipping attachment or a region with no
  *   atlas rectangle shown at setup, a placeholder the skins fill
@@ -26,8 +26,7 @@
  *   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 3 adds indexed physics and value-mapped sliders, including their
- * parameter timelines and per-pass writes. Mesh deforms, named/no-skin views
+ * `RUNTIME_FEATURES` is the closed list of what can be named. Stage 4 adds path constraints and scoped physics movement (`physicsTranslate`/`physicsRotate` with an optional constraint scope) on top of Stage 3's indexed physics and value-mapped sliders. Mesh and path deforms, named/no-skin views
  * 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.
@@ -47,19 +46,19 @@
  */
 import type { ModelVertices } from '../model.ts';
 import { activeBones, constraintRecords, CORE_REGION_KINDS, foldInheritMode, readBlend, readColour, shownAttachment, shownRow, sourceOfDoc, underSkin, type CompiledDocument, type CoreAnimation, type CoreBlendMode } from '../core/index.ts';
-import { constraintInactiveWhy, constraintsAbsentWhy, TRANSFORM_PROPERTIES, type CoreIkRecord, type CoreTransformRecord } from '../core/constraints.ts';
+import { constraintInactiveWhy, constraintsAbsentWhy, pathAnimationsWhy, TRANSFORM_PROPERTIES, type CoreIkRecord, type CoreTransformRecord } from '../core/constraints.ts';
+import { slotBonePlan, type CorePathRecord, type SlotBoneEvent } from '../core/constraints_path.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 { steppedPreviousPassWhy, type CorePhysicsRecord, type 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 = 3;
+export const RUNTIME_STAGE = 4;
 
 /** Every construct the runtime poser can refuse, by the name its refusals carry. */
 export const RUNTIME_FEATURES = [
-  'path-constraint',
   'local-transform',
   'additive-transform',
   'inactive-constrained-bone',
@@ -125,11 +124,13 @@ export interface RuntimePlant {
   readonly eventWrapOffByOne?: boolean;
   /** 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. */
+  /** Omit deform / multiply offsets by weights too early / omit path / ignore physics scope: negative controls only. */
   readonly omitPhysics?: boolean;
   readonly sliderAsTrack?: boolean;
   readonly omitDeform?: boolean;
   readonly deformAfterWeights?: boolean;
+  readonly omitPath?: boolean;
+  readonly ignorePhysicsScope?: boolean;
 }
 
 // A bone's local values, seven per bone.
@@ -177,6 +178,17 @@ export const IK_BEND_POSITIVE = 1;
 export const IK_COMPRESS = 2;
 export const IK_STRETCH = 4;
 
+// A path constraint's position, spacing and rotate modes.
+export const PATH_POSITION_FIXED = 0;
+export const PATH_POSITION_PERCENT = 1;
+export const PATH_SPACING_LENGTH = 0;
+export const PATH_SPACING_FIXED = 1;
+export const PATH_SPACING_PERCENT = 2;
+export const PATH_SPACING_PROPORTIONAL = 3;
+export const PATH_ROTATE_TANGENT = 0;
+export const PATH_ROTATE_CHAIN = 1;
+export const PATH_ROTATE_CHAIN_SCALE = 2;
+
 /** Degrees to radians, with the runtime's pi (`src/core/world.ts`). */
 export const RAD = RUNTIME_PI / 180;
 
@@ -281,6 +293,36 @@ export interface RuntimeSlider {
   animation: RuntimeAnimation;
 }
 
+export interface RuntimePath {
+  readonly kind: 'path';
+  readonly name: string;
+  readonly index: number;
+  readonly applied: boolean;
+  readonly bones: Int32Array;
+  readonly slot: number;
+  readonly slotBone: number;
+  /** Setup path attachment index into `model.attachments`, or −1 when the slot shows no path. */
+  attachment: number;
+  /** Number of vertex coordinates (`2 * vertexCount`) in the setup path attachment. */
+  pathVertices: number;
+  readonly closed: boolean;
+  readonly constantSpeed: boolean;
+  readonly lengths: Float64Array;
+  readonly positionMode: number;
+  readonly spacingMode: number;
+  readonly rotateMode: number;
+  readonly offsetRotation: number;
+  readonly position: number;
+  readonly spacing: number;
+  readonly mixRotate: number;
+  readonly mixX: number;
+  readonly mixY: number;
+  /** Constraint index whose `before` or `after` state sets the slot bone's determinant sign (`slotBonePlan`), or −1. */
+  readonly slotEventAt: number;
+  readonly slotEventAfter: boolean;
+  readonly setup: CorePathRecord;
+}
+
 export interface RuntimePhysicsTimeline {
   readonly kind: PhysicsTimelineKind;
   readonly targets: Int32Array;
@@ -293,7 +335,15 @@ export interface RuntimeSliderTimeline {
   readonly timeCursor: number;
   readonly mixCursor: number;
 }
-export type RuntimeConstraint = RuntimeIk | RuntimeTransform | RuntimePhysics | RuntimeSlider;
+export interface RuntimePathTimeline {
+  readonly position: RuntimeCurve | null;
+  readonly spacing: RuntimeCurve | null;
+  readonly mix: RuntimeCurve | null;
+  readonly positionCursor: number;
+  readonly spacingCursor: number;
+  readonly mixCursor: number;
+}
+export type RuntimeConstraint = RuntimeIk | RuntimeTransform | RuntimePhysics | RuntimeSlider | RuntimePath;
 
 /** 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 {
@@ -351,6 +401,7 @@ export interface RuntimeAnimation {
   readonly deforms: readonly RuntimeDeformTimeline[];
   readonly physics: readonly RuntimePhysicsTimeline[];
   readonly sliders: ReadonlyArray<RuntimeSliderTimeline | null>;
+  readonly paths: ReadonlyArray<RuntimePathTimeline | null>;
   readonly slots: readonly RuntimeSlotTimeline[];
   /** Per constraint of the plan, its timeline in this animation or `null`. */
   readonly constraints: ReadonlyArray<RuntimeConstraintTimeline | null>;
@@ -368,6 +419,11 @@ export interface RuntimeModel {
   readonly deformAfterWeights: boolean;
   readonly omitPhysics: boolean;
   readonly sliderAsTrack: boolean;
+  readonly omitPath: boolean;
+  readonly ignorePhysicsScope: boolean;
+  readonly hasPath: boolean;
+  readonly maxPathSpaces: number;
+  readonly maxPathVertices: number;
   readonly deformCount: number;
   readonly eventWrapOffByOne: boolean;
   readonly restoreEventsFromStart: boolean;
@@ -443,7 +499,7 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
   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}`);
 
   // --- bones ---
@@ -454,6 +510,12 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
     if (i === undefined) 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: string): number => {
+    const i = slotIndex.get(name);
+    if (i === undefined) 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);
@@ -491,9 +553,13 @@ 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') refusals.note(`${c.kind}-constraint`, `${c.kind} constraint "${c.name}"`);
-  for (const r of constraintRecords(doc)) {
-    if (r.kind === 'path') continue;
+  const records = constraintRecords(doc);
+  const skipped = new Set<number>();
+  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) : new Map<number, SlotBoneEvent | null>();
+  for (const r of records) {
     const applied = constraintInactiveWhy(r, active) === null;
     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;
@@ -507,7 +573,9 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
     }
     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 {
+    else if (r.kind === 'path') {
+      constraints.push(compilePath(r, index, applied, bones, indexOf, slotIndexOf, pathPlan.get(index) ?? null));
+    } 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);
@@ -585,8 +653,10 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
       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);
     }
-    // A bounding box, a path, a refused record admitted by a plant: the row's name and path, and nothing drawn.
+    // A bounding box, a refused record admitted by a plant: the row's name and path, and nothing drawn.
     if (made === null) made = vertexAttachment(at, DRAW_NONE, new Float64Array(0), 0);
     attachments.push(made);
     vertexCount += made.count;
@@ -607,7 +677,21 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
       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;
+    }
+  }
 
   // --- animations ---
   const animations = new Map<string, RuntimeAnimation>();
@@ -635,6 +719,11 @@ export function compileRuntime(doc: CompiledDocument, options: RuntimeOptions =
     sliderAsTrack: plant.sliderAsTrack === true,
     omitDeform: plant.omitDeform === true,
     deformAfterWeights: plant.deformAfterWeights === true,
+    omitPath: plant.omitPath === true,
+    ignorePhysicsScope: plant.ignorePhysicsScope === true,
+    hasPath,
+    maxPathSpaces,
+    maxPathVertices,
     deformCount,
     eventWrapOffByOne: plant.eventWrapOffByOne === true,
     restoreEventsFromStart: plant.restoreEventsFromStart === true,
@@ -700,6 +789,12 @@ function meshAttachment(at: AttachmentHead, vertices: ModelVertices, indexOf: (n
   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) };
 }
 
+/** A path attachment's vertices and bindings: stored and deformed like a mesh, never drawn into `RuntimePose.vertices`. */
+function pathAttachment(at: AttachmentHead, vertices: ModelVertices, indexOf: (name: string) => number, rewrite: RuntimePlant['bindingIndex'], bones: number): RuntimeAttachment {
+  const m = meshAttachment(at, vertices, indexOf, rewrite, bones);
+  return { ...m, draw: DRAW_NONE, count: 0 };
+}
+
 function compileIk(r: CoreIkRecord, index: number, applied: boolean, bones: Int32Array, indexOf: (name: string) => number): RuntimeIk {
   return {
     kind: 'ik', name: r.name, index, applied, bones, target: indexOf(r.target),
@@ -712,6 +807,43 @@ function ikFlags(bendPositive: boolean, compress: boolean, stretch: boolean): nu
   return (bendPositive ? IK_BEND_POSITIVE : 0) | (compress ? IK_COMPRESS : 0) | (stretch ? IK_STRETCH : 0);
 }
 
+function compilePath(
+  r: CorePathRecord,
+  index: number,
+  applied: boolean,
+  bones: Int32Array,
+  indexOf: (name: string) => number,
+  slotIndexOf: (name: string) => number,
+  ev: SlotBoneEvent | null,
+): RuntimePath {
+  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: CoreTransformRecord, index: number, applied: boolean, bones: Int32Array, indexOf: (name: string) => number): RuntimeTransform {
   const fromProperty: number[] = [];
   const fromOffset: number[] = [];
@@ -835,6 +967,19 @@ function compileAnimation(
     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 paths = constraints.map((c): RuntimePathTimeline | null => {
+    if (c.kind !== 'path') return null;
+    const keyed = anim.constraints.path.find((t) => t.name === c.name);
+    if (keyed === undefined) return null;
+    return {
+      position: keyed.position === undefined ? null : compileCurve(keyed.position, 1),
+      spacing: keyed.spacing === undefined ? null : compileCurve(keyed.spacing, 1),
+      mix: keyed.mix === undefined ? null : compileCurve(keyed.mix, 3),
+      positionCursor: cursors++,
+      spacingCursor: 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)),
@@ -846,5 +991,5 @@ function compileAnimation(
     const arrays = keys.map(k => heldArray(g.vertices, k));
     return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
   });
-  return { name, duration: tl.duration, physics, sliders, deforms, bones, sliderBones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map(key => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
+  return { name, duration: tl.duration, physics, sliders, paths, deforms, bones, sliderBones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map(key => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
 }

package/src/runtime/pose.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime poser's per-instance half (issue #1591, stage 3): one
+ * The runtime poser's per-instance half (issue #1591, stage 4): one
  * `RuntimePose` per skeleton on screen, every buffer allocated when it is
  * made and overwritten in place on every pose, so that posing a frame
  * allocates nothing.
@@ -9,10 +9,11 @@
  * The oracle's sample, as `src/core/animation.ts` poses it (`poseAnimations`):
  * every pose is posed from the setup pose — the bones' setup local values,
  * then the animation's bone timelines at `t` at full weight, then the world
- * transforms parents first, then the ik and transform constraints in the
+ * transforms parents first, then each slot's colour, attachment and own deform
+ * timelines, then the ik, transform, path, physics and slider constraints in the
  * document's order with their timelines' values at `t`, each followed by the
- * bones below what it moved posed again; then each slot's colour and what it
- * shows; then, when asked, every shown attachment's world vertices. Nothing
+ * bones below what it moved posed again, then the sliders' slot and deform
+ * timelines; then, when asked, every shown attachment's world vertices. Nothing
  * of one unstepped pose survives but key cursors. A stepped pose also keeps
  * its physics clock, offsets, velocities and lags; sliders select values
  * within this pose rather than advancing an independent track.
@@ -22,9 +23,9 @@
  * Every formula below is the one the named function of `src/core/` computes,
  * in its order of operations, on the same doubles: a bone's frame and its
  * five inherit modes (`world.ts`), the timelines (`animation.ts`), the one-
- * and two-bone ik, the world-space transform, the read-back of a moved bone's
- * local values and the update order (`constraints.ts`), a region's corners
- * and a mesh's vertices (`vertices.ts`). Each of those orders was fixed
+ * and two-bone ik, the world-space transform, the path constraint (`constraints_path.ts`),
+ * the read-back of a moved bone's local values and the update order (`constraints.ts`),
+ * a region's corners and a mesh's vertices (`vertices.ts`). Each of those orders was fixed
  * there by measurement against spine-core 4.3.13 to the last bit; the runtime
  * does not re-measure them, it is held to the oracle at tolerance 0
  * (`tools/core_gate.ts`, *The runtime poser*), so an order changed here is a
@@ -32,7 +33,7 @@
  *
  * ⚠️ The exactness hazards, each kept as the oracle has it: the setup value
  * plus 0 before a timeline's first key (which turns a `-0` setup into `0`);
- * a keyed ik or transform value reaching the pose through the setup blend
+ * a keyed ik, transform or path value reaching the pose through the setup blend
  * `setup + (value − setup)·1`; `Math.PI` for a folded uniform two-bone ik and
  * the runtime's 3.1415927 everywhere else; the `(−180, 180]` wrap; a mix of
  * exactly 0 touching nothing; an inactive bone posed as zeros by the
@@ -62,6 +63,13 @@ import {
   MODE_NO_SCALE_OR_REFLECTION,
   MODE_NORMAL,
   MODE_ONLY_TRANSLATION,
+  PATH_POSITION_PERCENT,
+  PATH_ROTATE_CHAIN,
+  PATH_ROTATE_CHAIN_SCALE,
+  PATH_ROTATE_TANGENT,
+  PATH_SPACING_LENGTH,
+  PATH_SPACING_PERCENT,
+  PATH_SPACING_PROPORTIONAL,
   RAD,
   RuntimeInputError,
   SCALE_Y_UNIFORM,
@@ -74,9 +82,11 @@ import {
   W_Y,
   WORLDS,
   type RuntimeAnimation,
+  type RuntimeConstraint,
   type RuntimeEvent,
   type RuntimeIk,
   type RuntimeModel,
+  type RuntimePath,
   type RuntimeTransform,
   type RuntimeSlider,
   type RuntimePhysicsTimeline,
@@ -84,6 +94,7 @@ import {
 
 const DEG = RUNTIME_DEG;
 const TWO_PI = 2 * RUNTIME_PI;
+const PATH_EPSILON = 0.00001;
 // The transform properties, by `TRANSFORM_PROPERTIES` index (src/core/constraints.ts).
 const P_ROTATE = 0;
 const P_X = 1;
@@ -134,11 +145,20 @@ export class RuntimePose {
 
   private current: RuntimeAnimation | null = null;
   private readonly cursors: Int32Array;
-  // The constraints' values as posed: an ik's mix, softness and flags, a transform's six mixes.
+  // The constraints' values as posed: an ik's mix, softness and flags, a transform's six mixes, a path's position, spacing and three mixes.
   private readonly ikMix: Float64Array;
   private readonly ikSoftness: Float64Array;
   private readonly ikFlags: Uint8Array;
   private readonly mixes: Float64Array;
+  private readonly pathValues: Float64Array;
+  private readonly pathSlotSign: Int8Array;
+  private readonly pathSpaces: Float64Array;
+  private readonly pathLengths: Float64Array;
+  private readonly pathPositions: Float64Array;
+  private readonly pathWorldPts: Float64Array;
+  private readonly pathChain: Float64Array;
+  private readonly pathCurveEnds: Float64Array;
+  private readonly pathSegmentEnds = new Float64Array(10);
   // The update order's scratch: the bones a constraint changed and moved in world space, in order (repeats kept, as the oracle keeps them), and per-bone marks.
   private readonly changed: Int32Array;
   private readonly inWorld: Int32Array;
@@ -156,6 +176,7 @@ export class RuntimePose {
   private readonly hasPhysics: boolean;
   private readonly physicsStates: PhysicsState[];
   private readonly physicsRecords: Array<CorePhysicsRecord | null>;
+  private readonly physicsScope: Uint8Array;
   private readonly environment = new Float64Array([1, 0, 0, 1]);
   private readonly sliderTime: Float64Array;
   private readonly sliderMix: Float64Array;
@@ -174,6 +195,7 @@ export class RuntimePose {
     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);
@@ -186,6 +208,16 @@ export 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);
     // Sized by the longest target list (`RuntimeModel.scratch`): a transform may name one bone several times, and every entry is applied and reposed.
     this.changed = new Int32Array(model.scratch);
     this.inWorld = new Int32Array(model.scratch);
@@ -233,9 +265,11 @@ export class RuntimePose {
     this.physicsValues(null, 0, false);
     this.locals.set(this.model.setup);
     this.hierarchy();
+    this.slotValues(null, 0);
+    this.deformValues(null, 0);
     this.constraintValues(null, 0);
     this.solveConstraints();
-    this.attachmentValues(null, 0);
+    this.sliderAttachments();
   }
 
   /** The animation posed at its time `t`, from the setup pose (the header). */
@@ -255,9 +289,11 @@ export class RuntimePose {
     this.time = t;
     this.boneTimelines(anim, t);
     this.hierarchy();
+    this.slotValues(anim, t);
+    this.deformValues(anim, t);
     this.constraintValues(anim, t);
     this.solveConstraints();
-    this.attachmentValues(anim, t);
+    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). */
@@ -496,6 +532,37 @@ export class RuntimePose {
         }
         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;
       }
     }
   }
@@ -503,12 +570,15 @@ export class RuntimePose {
   /** Every applied constraint in the document's order, each followed by the update order's repose (`applyConstraints`). */
   private solveConstraints(): void {
     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 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)) {
@@ -516,6 +586,18 @@ export class RuntimePose {
           this.repose(1, 1);
         }
       }
+      if (hasPath) this.snapSlotBones(k, true);
+    }
+  }
+
+  private snapSlotBones(at: number, after: boolean): void {
+    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;
     }
   }
 
@@ -533,19 +615,54 @@ export class RuntimePose {
     this.physicsReady = true;
   }
 
+  private checkPhysicsScope(scope: readonly string[] | undefined): Uint8Array | null {
+    if (scope === undefined) 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: RuntimeConstraint | undefined;
+      for (let k = 0; k < cs.length; k++) {
+        if (cs[k].kind === 'physics' && cs[k].name === name) {
+          found = cs[k];
+          break;
+        }
+      }
+      if (found === undefined) {
+        for (let k = 0; k < cs.length; k++) {
+          if (cs[k].name === name) {
+            found = cs[k];
+            break;
+          }
+        }
+      }
+      if (found === undefined) 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: number, y: number): void {
+  physicsTranslate(x: number, y: number, scope?: readonly string[]): void {
+    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: number, y: number, degrees: number): void {
+  physicsRotate(x: number, y: number, degrees: number, scope?: readonly string[]): void {
+    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;
@@ -662,9 +779,394 @@ export class RuntimePose {
     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);
+  /** A path constraint (`solvePath` in `src/core/constraints_path.ts`), every buffer overwritten in place. */
+  private solvePath(c: RuntimePath, k: number): void {
+    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: boolean;
+    if (offsetRotation === 0) fromTip = c.rotateMode === PATH_ROTATE_CHAIN;
+    else {
+      fromTip = false;
+      let positive: boolean;
+      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: number;
+        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 cos = Math.cos(r);
+          const sin = Math.sin(r);
+          const length = modelLengths[bi];
+          atX += (length * (cos * a - sin * cc) - dx) * mixRotate;
+          atY += (length * (sin * a + cos * 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);
+  }
+
+  private computePathWorld(c: RuntimePath): void {
+    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;
+    }
+  }
+
+  private positionsOfPath(c: RuntimePath, position: number, spaceCount: number, wantsTangent: boolean): void {
+    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 curveCount = n / 3 - (closed ? 1 : 2);
+      const total = lengths[curveCount];
+      if (c.positionMode === PATH_POSITION_PERCENT) position *= total;
+      const spaceScale = c.spacingMode === PATH_SPACING_PERCENT ? total : c.spacingMode === PATH_SPACING_PROPORTIONAL ? total / spaceCount : 1;
+      let curve = 0;
+      for (let i = 0, o = 0; i < spaceCount; i++, o += 3) {
+        const space = spaces[i] * spaceScale;
+        position += space;
+        let p = position;
+        if (closed) {
+          p %= total;
+          if (p < 0) p += total;
+          curve = 0;
+        } else if (p < 0) {
+          onLineBefore(p, pts[2], pts[3], pts[4], pts[5], out, o);
+          continue;
+        } else if (p > total) {
+          const m0 = 2 * (n - 3);
+          const m1 = 2 * (n - 2);
+          onLinePast(p - total, 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 cx1 = chain[w];
+      const cy1 = chain[w + 1];
+      const cx2 = chain[w + 2];
+      const cy2 = chain[w + 3];
+      const x2 = chain[w + 4];
+      const y2 = chain[w + 5];
+      const h2x = (cx0 - cx1 * 2 + cx2) * 0.1875;
+      const h2y = (cy0 - cy1 * 2 + cy2) * 0.1875;
+      const d3x = ((cx1 - cx2) * 3 - cx0 + x2) * 0.09375;
+      const d3y = ((cy1 - cy2) * 3 - cy0 + y2) * 0.09375;
+      let d2x = h2x * 2 + d3x;
+      let d2y = h2y * 2 + d3y;
+      let d1x = (cx1 - cx0) * 0.75 + h2x + d3x * 0.16666667;
+      let d1y = (cy1 - 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 = x2;
+      cy0 = y2;
+    }
+    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) * 0.006;
+        const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
+        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));
+    }
+  }
+
+  private sliderAttachments(): void {
     for (let k = 0; k < this.model.constraints.length; k++) {
       this.sliderSlots(k);
       this.sliderDeforms(k);
@@ -1388,3 +1890,43 @@ function applyWorld(w: Float64Array, property: number, v: number, mix: number):
     }
   }
 }
+
+function onLineBefore(p: number, x1: number, y1: number, x2: number, y2: number, out: Float64Array, o: number): void {
+  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: number, x0: number, y0: number, x1: number, y1: number, out: Float64Array, o: number): void {
+  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: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Float64Array, o: number, wantsTangent: boolean): void {
+  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 < 0.001) 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));
+  }
+}