spine-html 1.12.1 → 1.14.0

package/dist/index.js

@@ -377,6 +377,83 @@ function timelineIdentity(slot, shown) {
   return `${shown.skin}/${slot}/${shown.placeholder}`;
 }
 const nameOf = (a) => `${a.skin}/${a.slot}/${a.attachment}`;
+const identitiesOfView = /* @__PURE__ */ new WeakMap();
+function readIdentity(doc, resolve, slot, placeholder) {
+  const s = resolve(doc, { ...slot, setup: placeholder });
+  if (s === null || "conflict" in s || s.record.geometry === void 0) return null;
+  const g = s.record.geometry;
+  const source = g.kind === "linkedmesh" ? doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source] : s.record;
+  const sg = source?.geometry;
+  return Object.freeze({
+    entry: Object.freeze({ slot: slot.name, bone: slot.bone, name: shownRow(s).name, placeholder: s.placeholder, skin: s.skin, geometry: g }),
+    identity: timelineIdentity(slot.name, s),
+    vertices: sg !== void 0 && sg.kind !== "region" && sg.kind !== "linkedmesh" ? sg.vertices : null,
+    count: source?.sequenceCount,
+    fillers: Object.freeze(fillingSkins(doc, slot.name, s.placeholder).map((k) => `"${k}"`))
+  });
+}
+function identityOf(doc, resolve, slot, placeholder) {
+  if (placeholder === null) return null;
+  if (resolve !== shownAttachment) return readIdentity(doc, resolve, slot, placeholder);
+  let slots = identitiesOfView.get(doc);
+  if (slots === void 0) identitiesOfView.set(doc, slots = /* @__PURE__ */ new Map());
+  let placeholders = slots.get(slot.name);
+  if (placeholders === void 0) slots.set(slot.name, placeholders = /* @__PURE__ */ new Map());
+  if (placeholders.has(placeholder)) return placeholders.get(placeholder);
+  const identity = readIdentity(doc, resolve, slot, placeholder);
+  placeholders.set(placeholder, identity);
+  return identity;
+}
+const attachmentsByIdentity = /* @__PURE__ */ new WeakMap();
+const switchesBySlot = /* @__PURE__ */ new WeakMap();
+function matchingAttachments(timelines, identity) {
+  let index = attachmentsByIdentity.get(timelines);
+  if (index === void 0) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const a of timelines) {
+      const name = nameOf(a);
+      const found = rows.get(name);
+      if (found === void 0) rows.set(name, [a]);
+      else found.push(a);
+    }
+    attachmentsByIdentity.set(timelines, index = rows);
+  }
+  return index.get(identity);
+}
+function slotSwitches(slots, slot) {
+  let index = switchesBySlot.get(slots);
+  if (index === void 0) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const target of slots) {
+      for (const tl of target.timelines) {
+        if (tl.kind !== "attachment" || tl.keys === void 0) continue;
+        const found = rows.get(target.name);
+        if (found === void 0) rows.set(target.name, [tl.keys]);
+        else found.push(tl.keys);
+      }
+    }
+    switchesBySlot.set(slots, index = rows);
+  }
+  return index.get(slot);
+}
+function applyAttachment(now, values2, timelines, t, blend, evalDeform, blendOf2, evalFrame) {
+  if (now === null || now.identity === null) return values2;
+  const matching = matchingAttachments(timelines, now.identity);
+  if (matching === void 0) return values2;
+  values2 ??= { deform: null, frame: null, seen: [] };
+  if (!values2.seen.includes(now.identity)) values2.seen.push(now.identity);
+  for (const a of matching) {
+    if (a.deform !== null && now.vertices !== null) {
+      const target = evalDeform(now.vertices, a.deform, t);
+      if (target !== null) values2.deform = blend === null ? target : blendOf2(now.vertices, values2.deform, target, blend.alpha, blend.additive);
+    }
+    if (a.sequence !== null && now.count !== void 0) {
+      const f = evalFrame(a.sequence, now.count, t);
+      if (f !== null) values2.frame = f;
+    }
+  }
+  return values2;
+}
 function attachmentStates(doc, resolve, placeholders, sample, sliders, plant = {}, mixed) {
   const evalDeform = plant.deform ?? deformAt;
   const blendOf2 = plant.deformBlend ?? blendDeform;
@@ -389,64 +466,37 @@ function attachmentStates(doc, resolve, placeholders, sample, sliders, plant = {
     const live = gate(doc, slot, active);
     let placeholder = placeholders.get(slot.name) ?? null;
     const base = live ? mixed?.get(slot.name) : void 0;
-    let deform = base?.deform ?? null;
-    let frame2 = null;
-    const seen = base === void 0 ? [] : [...base.seen];
-    const state = () => {
-      if (placeholder === null) return null;
-      const s = resolve(doc, { ...slot, setup: placeholder });
-      if (s === null || "conflict" in s || s.record.geometry === void 0) return null;
-      const g = s.record.geometry;
-      const source = g.kind === "linkedmesh" ? doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source] : s.record;
-      const sg = source?.geometry;
-      const vertices = sg !== void 0 && sg.kind !== "region" && sg.kind !== "linkedmesh" ? sg.vertices : null;
-      return { s, identity: timelineIdentity(slot.name, s), vertices, count: source?.sequenceCount };
-    };
-    const apply = (timelines, t, blend) => {
-      const now2 = state();
-      if (now2 === null || now2.identity === null) return;
-      for (const a of timelines) {
-        if (nameOf(a) !== now2.identity) continue;
-        if (!seen.includes(now2.identity)) seen.push(now2.identity);
-        if (a.deform !== null && now2.vertices !== null) {
-          const target = evalDeform(now2.vertices, a.deform, t);
-          if (target !== null) deform = blend === null ? target : blendOf2(now2.vertices, deform, target, blend.alpha, blend.additive);
-        }
-        if (a.sequence !== null && now2.count !== void 0) {
-          const f = evalFrame(a.sequence, now2.count, t);
-          if (f !== null) frame2 = f;
-        }
-      }
-    };
-    if (sample !== null && live) apply(sample.timelines.attachments, sample.t, null);
-    for (const app of live ? sliders : []) {
-      for (const target of app.timelines.slots) {
-        if (target.name !== slot.name) continue;
-        for (const tl of target.timelines) {
-          if (tl.kind !== "attachment" || tl.keys === void 0) continue;
-          const i = keyIndexAt(tl.keys, app.at);
-          if (i < 0) continue;
-          const next = tl.keys[i].name ?? null;
-          if (next !== placeholder) {
-            deform = null;
-            frame2 = null;
+    let values2 = base === void 0 || base.deform === null && base.seen.length === 0 ? null : { deform: base.deform, frame: null, seen: [...base.seen] };
+    let now = identityOf(doc, resolve, slot, placeholder);
+    if (sample !== null && live) values2 = applyAttachment(now, values2, sample.timelines.attachments, sample.t, null, evalDeform, blendOf2, evalFrame);
+    if (live) for (const app of sliders) {
+      const switches = slotSwitches(app.timelines.slots, slot.name);
+      if (switches !== void 0) for (const keys of switches) {
+        const i = keyIndexAt(keys, app.at);
+        if (i < 0) continue;
+        const next = keys[i].name ?? null;
+        if (next !== placeholder) {
+          if (values2 !== null) {
+            values2.deform = null;
+            values2.frame = null;
           }
           placeholder = next;
+          now = identityOf(doc, resolve, slot, placeholder);
         }
       }
-      apply(app.timelines.attachments, app.at, { alpha: app.alpha, additive: app.additive });
+      values2 = applyAttachment(now, values2, app.timelines.attachments, app.at, app, evalDeform, blendOf2, evalFrame);
     }
-    const now = state();
     if (now === null) continue;
-    const entry = { slot: slot.name, bone: slot.bone, name: shownRow(now.s).name, placeholder: now.s.placeholder, skin: now.s.skin, geometry: now.s.record.geometry };
+    const entry = values2 === null || values2.deform === null && values2.frame === null ? now.entry : { ...now.entry };
     shown.push(entry);
-    const fillers = fillingSkins(doc, slot.name, now.s.placeholder).map((k) => `"${k}"`);
-    if (seen.length > 0 && fillers.length > 1) {
-      why.push(`slot "${slot.name}" shows placeholder "${now.s.placeholder}", which skins ${fillers.join(", ")} fill, and ${seen.map((x) => `"${x}"`).join(", ")} key(s) it — which record --skin all shows, and so whether the timeline moves it, is the Spine file's skin order, not the model's`);
+    if (values2 !== null && values2.seen.length > 0 && now.fillers.length > 1) {
+      why.push(`slot "${slot.name}" shows placeholder "${now.entry.placeholder}", which skins ${now.fillers.join(", ")} fill, and ${values2.seen.map((x) => `"${x}"`).join(", ")} key(s) it — which record --skin all shows, and so whether the timeline moves it, is the Spine file's skin order, not the model's`);
       continue;
     }
-    if (deform !== null) entry.deform = deform;
-    if (frame2 !== null) entry.frame = frame2;
+    if (values2 !== null) {
+      if (values2.deform !== null) entry.deform = values2.deform;
+      if (values2.frame !== null) entry.frame = values2.frame;
+    }
   }
   return { shown, why };
 }
@@ -712,8 +762,8 @@ function clipTriangles(polygon, vertices, triangles, uvs, reading = {}) {
   }
   return { clipped, vertices: outV, uvs: outUv, triangles: outT, sources };
 }
-const REGION_UVS = [0, 1, 0, 0, 1, 0, 1, 1];
-const REGION_TRIANGLES = [0, 1, 2, 2, 3, 0];
+const REGION_UVS = Object.freeze([0, 1, 0, 0, 1, 0, 1, 1]);
+const REGION_TRIANGLES = Object.freeze([0, 1, 2, 2, 3, 0]);
 function poseClipped(walk, round, clip = clipTriangles, through = (shape, v, t, uv) => clipThrough(shape, v, t, uv, clip)) {
   const rows = [];
   const refused = [];
@@ -968,6 +1018,15 @@ function clipThrough(shape, vertices, triangles, uvs, clip = clipTriangles, read
   return { clipped, vertices: outV, uvs: outUv, triangles: outT, sources };
 }
 const RAD$2 = RUNTIME_PI / 180;
+const meshArraysByGeometry = /* @__PURE__ */ new WeakMap();
+function meshArraysOf(mesh) {
+  let kept = meshArraysByGeometry.get(mesh);
+  if (kept === void 0) {
+    kept = Object.freeze({ uvs: Object.freeze([...mesh.uvs]), triangles: Object.freeze([...mesh.triangles]) });
+    meshArraysByGeometry.set(mesh, kept);
+  }
+  return kept;
+}
 const EXACT_COORDS = (v) => v;
 function regionCorners(region, bone2) {
   const { width: W, height: H } = region;
@@ -1019,6 +1078,34 @@ function worldVertices(vertices, bone2, world, coords = Math.fround) {
   }
   return out;
 }
+function deformedWorldVertices(vertices, deform, bone2, world) {
+  const out = [];
+  if (!vertices.weighted) {
+    for (let i = 0; i + 1 < deform.length; i += 2) {
+      const x = deform[i];
+      const y = deform[i + 1];
+      out.push(x * bone2.a + y * bone2.b + bone2.worldX, x * bone2.c + y * bone2.d + bone2.worldY);
+    }
+    return out;
+  }
+  let k = 0;
+  for (const influences of vertices.bindings) {
+    let wx = 0;
+    let wy = 0;
+    for (const binding of influences) {
+      const t = world.get(binding.bone);
+      if (t === void 0) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
+      const x = Math.fround(binding.x) + deform[k];
+      const y = Math.fround(binding.y) + deform[k + 1];
+      k += 2;
+      const weight = Math.fround(binding.weight);
+      wx += (x * t.a + y * t.b + t.worldX) * weight;
+      wy += (x * t.c + y * t.d + t.worldY) * weight;
+    }
+    out.push(wx, wy);
+  }
+  return out;
+}
 const isRecord$7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const finite$1 = (v) => typeof v === "number" && Number.isFinite(v);
 const RECT_FIELDS = ["width", "height", "offsetX", "offsetY", "originalWidth", "originalHeight"];
@@ -1149,42 +1236,55 @@ function readPathGeometry(raw, vertices, where, problems) {
   if (problems.length !== before) return void 0;
   return { kind: "path", vertices, closed: raw.closed === true, constantSpeed: raw.constantSpeed !== false, lengths };
 }
+function roundedRow(values2, round) {
+  for (let i = 0; i < values2.length; i++) {
+    const r = round(values2[i]);
+    if (Object.is(r, values2[i])) continue;
+    const out = values2.slice(0, i);
+    out.push(r);
+    for (let j = i + 1; j < values2.length; j++) out.push(round(values2[j]));
+    return out;
+  }
+  return values2;
+}
 function poseGeometry(shown, world, sourceOf, round, plant = {}, draw) {
   const region = plant.region ?? regionCorners;
   const vertices = plant.vertices ?? worldVertices;
   const attachments = [];
   const clips = [];
   const nulls = [];
+  const walked = draw !== void 0 && shown.some((s) => s.geometry.kind === "clipping");
   const steps = /* @__PURE__ */ new Map();
   for (const s of shown) {
     const bone2 = world.get(s.bone);
     if (bone2 === void 0) throw new Error(`slot "${s.slot}": bone "${s.bone}" has no world transform`);
     const g = s.geometry;
-    const drawn = (v) => s.deform === void 0 ? vertices(v, bone2, world) : vertices(deformedVertices(v, s.deform), bone2, world, EXACT_COORDS);
+    const deform = s.deform;
+    const drawn = (v) => deform === void 0 ? vertices(v, bone2, world) : plant.vertices === void 0 ? deformedWorldVertices(v, deform, bone2, world) : vertices(deformedVertices(v, deform), bone2, world, EXACT_COORDS);
     if (g.kind === "region") {
       const rect = s.frame === void 0 ? g.region.atlas : g.region.frames?.[s.frame] ?? g.region.atlas;
       if (rect === null) {
         nulls.push(`slot "${s.slot}" shows region "${s.name}" (skin "${s.skin}", placeholder "${s.placeholder}")`);
         continue;
       }
-      const corners = region({ ...g.region, atlas: rect }, bone2);
-      attachments.push([s.slot, s.name, "region", corners.map(round)]);
-      steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: corners, triangles: [...REGION_TRIANGLES], uvs: [...REGION_UVS] });
+      const corners = region(rect === g.region.atlas ? g.region : { ...g.region, atlas: rect }, bone2);
+      attachments.push([s.slot, s.name, "region", roundedRow(corners, round)]);
+      if (walked) steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: corners, triangles: REGION_TRIANGLES, uvs: REGION_UVS });
     } else if (g.kind === "mesh") {
       const world2 = drawn(g.vertices);
-      attachments.push([s.slot, s.name, "mesh", world2.map(round)]);
-      steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: world2, triangles: g.triangles, uvs: g.uvs });
+      attachments.push([s.slot, s.name, "mesh", roundedRow(world2, round)]);
+      if (walked) steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: world2, triangles: g.triangles, uvs: g.uvs });
     } else if (g.kind === "linkedmesh") {
       const source = sourceOf(g.skin, g.slot, g.source);
       if (typeof source === "string") throw new Error(`slot "${s.slot}": ${source} (readModel refuses it first)`);
       const world2 = drawn(source);
-      attachments.push([s.slot, s.name, "mesh", world2.map(round)]);
+      attachments.push([s.slot, s.name, "mesh", roundedRow(world2, round)]);
       const mesh = draw?.meshOf(g.skin, g.slot, g.source);
       if (draw !== void 0 && mesh === void 0) throw new Error(`slot "${s.slot}": the linked mesh's source "${g.source}" carries no triangles (readModel refuses it first)`);
-      if (mesh !== void 0) steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: world2, triangles: mesh.triangles, uvs: mesh.uvs });
+      if (walked && mesh !== void 0) steps.set(s.slot, { slot: s.slot, kind: "draw", attachment: s.name, vertices: world2, triangles: mesh.triangles, uvs: mesh.uvs });
     } else if (g.kind === "clipping") {
       const polygon = drawn(g.vertices);
-      clips.push([s.slot, s.name, g.end, polygon.map(round)]);
+      clips.push([s.slot, s.name, g.end, roundedRow(polygon, round)]);
       steps.set(s.slot, { slot: s.slot, kind: "clip", attachment: s.name, active: draw?.active.has(s.bone) ?? false, end: g.end, polygon, inverse: g.inverse, convex: g.convex });
     }
   }
@@ -1193,7 +1293,12 @@ function poseGeometry(shown, world, sourceOf, round, plant = {}, draw) {
   let clippedWhy = draw === void 0 ? "the draw order was not given" : attachmentsWhy;
   let drawnClipped = null;
   let drawnClippedWhy = clippedWhy;
-  if (draw !== void 0 && attachmentsWhy === null) {
+  if (draw !== void 0 && attachmentsWhy === null && !walked) {
+    clipped = [];
+    clippedWhy = null;
+    drawnClipped = [];
+    drawnClippedWhy = null;
+  } else if (draw !== void 0 && attachmentsWhy === null) {
     const walk = draw.order.map((slot) => steps.get(slot) ?? { slot, kind: "none" });
     const posed = poseClipped(walk, round, draw.clip, draw.through);
     clipped = posed.rows;
@@ -2157,6 +2262,15 @@ function stepPhysics(r, w, length, ctx) {
     const k = 1 + (s.scaleOffset - s.scaleLag * z) * mix * r.scaleX;
     w.a *= k;
     w.c *= k;
+    if (r.scaleYMode === "Uniform") {
+      w.b *= k;
+      w.d *= k;
+    } else if (r.scaleYMode === "Volume") {
+      const magnitude = Math.abs(k);
+      const transverse = magnitude >= 0.7 ? 1 / magnitude : 4 - 3.67347 * magnitude;
+      w.b *= transverse;
+      w.d *= transverse;
+    }
   }
   s.tx = l * w.a;
   s.ty = l * w.c;
@@ -3317,7 +3431,8 @@ function applyConstraints(bones, world, active, records, previous = null, applie
     if (c.kind === "physics") {
       if (physics !== void 0) {
         const w = { ...state.world.get(c.bone) };
-        const posed = physicsPose?.records.get(c.name) ?? c;
+        const authored = physicsPose?.records.get(c.name) ?? c;
+        const posed = physics.parameters?.apply(authored) ?? authored;
         if ((physics.step ?? stepPhysics)(posed, w, bone(state, c.bone).length ?? 0, physics)) {
           state.world.set(c.bone, w);
           changed = [c.bone];
@@ -3598,7 +3713,7 @@ function readBoneTimeline(kind, keysValue, where, problems) {
     }
     const channels = BONE_TIMELINE_CHANNELS[kind];
     unknownKeyFields(raw, ["time", ...channels, "curve"], at, problems);
-    const values = channels.map((c) => {
+    const values2 = channels.map((c) => {
       const v = raw[c];
       if (typeof v !== "number" || !Number.isFinite(v)) {
         problems.push(`${at}: ${c} is ${JSON.stringify(v)}, not a finite number — the writer states every channel on every key`);
@@ -3606,7 +3721,7 @@ function readBoneTimeline(kind, keysValue, where, problems) {
       }
       return v;
     });
-    return { time: Math.fround(time), values: values.map(Math.fround), stated: { time, values }, curve: readCurve(raw, channels.length, i === listed.length - 1, at, problems) };
+    return { time: Math.fround(time), values: values2.map(Math.fround), stated: { time, values: values2 }, curve: readCurve(raw, channels.length, i === listed.length - 1, at, problems) };
   });
 }
 function hexChannels(hex, count) {
@@ -3623,22 +3738,22 @@ function readSlotTimeline(kind, keysValue, where, problems) {
       return { time: Math.fround(time), values: [], stated: { time, values: [] }, curve: "stepped", name: typeof raw.name === "string" ? raw.name : null };
     }
     const shape = SLOT_COLOUR_TIMELINES[kind];
-    let values = [];
+    let values2 = [];
     if (kind === "alpha") {
       unknownKeyFields(raw, ["time", "value", "curve"], at, problems);
       const v = raw.value;
       if (typeof v !== "number" || !Number.isFinite(v)) problems.push(`${at}: value is ${JSON.stringify(v)}, not a finite number`);
-      else values = [v];
+      else values2 = [v];
     } else {
       unknownKeyFields(raw, ["time", ...shape.fields.map(([f]) => f), "curve"], at, problems);
       for (const [field, digits] of shape.fields) {
         const v = raw[field];
         if (!isHex(v, digits)) problems.push(`${at}: ${field} is ${JSON.stringify(v)}, not ${digits} hex digits — the one spelling the writer gives a ${kind} key's ${field}`);
-        else values.push(...hexChannels(v, field === "dark" || digits === 6 ? 3 : 4));
+        else values2.push(...hexChannels(v, field === "dark" || digits === 6 ? 3 : 4));
       }
     }
-    if (values.length !== shape.channels.length) values = shape.channels.map(() => 0);
-    return { time: Math.fround(time), values: values.map(Math.fround), stated: { time, values }, curve: readCurve(raw, shape.channels.length, i === listed.length - 1, at, problems) };
+    if (values2.length !== shape.channels.length) values2 = shape.channels.map(() => 0);
+    return { time: Math.fround(time), values: values2.map(Math.fround), stated: { time, values: values2 }, curve: readCurve(raw, shape.channels.length, i === listed.length - 1, at, problems) };
   });
 }
 function constraintKeyTimes(value, where, problems) {
@@ -3934,7 +4049,7 @@ class StepLocals {
     this.write("shearY", v);
   }
 }
-function adjustLocals(doc, bones, adjust) {
+function adjustLocals(doc, bones, adjust, context) {
   const views = /* @__PURE__ */ new Map();
   const names = doc.bones.map((b) => b.name);
   adjust({
@@ -3949,7 +4064,7 @@ function adjustLocals(doc, bones, adjust) {
       }
       return view;
     }
-  });
+  }, context);
 }
 const clamp01$1 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function posedSlots(doc, timelines, t, plant = {}, sliders = [], placeholders) {
@@ -4036,7 +4151,7 @@ function posedBoneStep(doc, timelines, t, plant, constraints, sliders, step) {
   const bones = posedBones(doc, timelines, t, plant);
   if (constraints !== void 0 && step !== void 0) return steppedLocals(doc, bones, plant, () => pathDeformed(doc, posedRecords(constraintRecords(doc), constraints, t), timelines, t, plant), constraints.physicsKeyed ?? [], t, sliders, step);
   const active = activeBones(doc);
-  if (step?.adjust !== void 0) adjustLocals(doc, bones, step.adjust);
+  if (step?.adjustment !== void 0) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
   let world = (plant.evaluate ?? worldTransforms)(bones, active);
   if (constraints !== void 0) {
     const setupRecords = constraintRecords(doc);
@@ -4049,7 +4164,7 @@ function posedBoneStep(doc, timelines, t, plant, constraints, sliders, step) {
 }
 function steppedLocals(doc, bones, plant, records, physicsKeyed, t, sliders, step) {
   const active = activeBones(doc);
-  if (step.adjust !== void 0) adjustLocals(doc, bones, step.adjust);
+  if (step.adjustment !== void 0) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
   let world = (plant.evaluate ?? worldTransforms)(bones, active);
   const stepped = stepPhysicsRecords(records(), physicsKeyed, t, active, step.ctx, step.before);
   world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(stepped) : stepped, null, sliders, step.ctx, void 0, solverRules(plant.solver));
@@ -4702,8 +4817,8 @@ function shownRow(shown) {
   return { name, path: CORE_REGION_KINDS.has(shown.record.kind) ? shown.record.path ?? name : null };
 }
 const shownOfView = /* @__PURE__ */ new WeakMap();
-function shownAttachment(doc, slot) {
-  if (slot.setup === null) return null;
+function shownAttachment(doc, slot, placeholder = slot.setup) {
+  if (placeholder === null) return null;
   let bySlot = shownOfView.get(doc);
   if (bySlot === void 0) {
     bySlot = /* @__PURE__ */ new Map();
@@ -4714,9 +4829,9 @@ function shownAttachment(doc, slot) {
     byPlaceholder = /* @__PURE__ */ new Map();
     bySlot.set(slot.name, byPlaceholder);
   }
-  if (byPlaceholder.has(slot.setup)) return byPlaceholder.get(slot.setup);
-  const resolved = resolveShown(doc, slot.name, slot.setup);
-  byPlaceholder.set(slot.setup, resolved);
+  if (byPlaceholder.has(placeholder)) return byPlaceholder.get(placeholder);
+  const resolved = resolveShown(doc, slot.name, placeholder);
+  byPlaceholder.set(placeholder, resolved);
   return resolved;
 }
 function resolveShown(doc, slotName, placeholder) {
@@ -4907,6 +5022,13 @@ function drawnGeometry(doc, shown, world, order, plant, mode) {
   if (geometry.drawnClipped === null) throw new CoreInputError(`the raw pose leaves the clipped triangles out: ${geometry.drawnClippedWhy}`);
   return { rows: geometry.attachments, clips: geometry.clips, drawnClipped: geometry.drawnClipped };
 }
+function numbersOf(values2, what, mode) {
+  return allNumbers(values2) ? values2 : values2.map((v) => numberOf(v, what, mode));
+}
+function allNumbers(values2) {
+  for (const v of values2) if (v === null) return false;
+  return true;
+}
 function rawDrawn(doc, shown, world, order, plant, mode = RAW_MODE) {
   const geometry = drawnGeometry(doc, shown, world, order, plant, mode);
   const rows = geometry.rows;
@@ -4923,25 +5045,56 @@ function rawDrawn(doc, shown, world, order, plant, mode = RAW_MODE) {
     let triangles;
     let hull = null;
     if (g.kind === "region") {
-      uvs = [...REGION_UVS];
-      triangles = [...REGION_TRIANGLES];
+      uvs = REGION_UVS;
+      triangles = REGION_TRIANGLES;
     } else {
       const source = g.kind === "mesh" ? g : doc.skins.find((x) => x.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
       if (source === void 0 || source.kind !== "mesh") throw new CoreInputError(`slot "${s.slot}": the linked mesh's source carries no mesh`);
-      uvs = [...source.uvs];
-      triangles = [...source.triangles];
+      ({ uvs, triangles } = (plant.meshArrays ?? meshArraysOf)(source));
       hull = source.hull ?? null;
     }
     const sequenceIndex = s.frame ?? record?.sequenceSetup ?? 0;
-    drawn.push({ slot: s.slot, attachment: row[1], kind: row[2], vertices: row[3].map((v) => numberOf(v, `vertex of slot "${s.slot}"`, mode)), uvs, triangles, hull, sequenceIndex, colour });
+    drawn.push({ slot: s.slot, attachment: row[1], kind: row[2], vertices: numbersOf(row[3], `vertex of slot "${s.slot}"`, mode), uvs, triangles, hull, sequenceIndex, colour });
   }
-  const clips = geometry.clips.map((c) => [c[0], c[1], c[2], c[3].map((v) => numberOf(v, `clip vertex of slot "${c[0]}"`, mode))]);
-  const clipped = geometry.drawnClipped.map((c) => [c[0], c[1], c[2], c[3].map((v) => numberOf(v, `clipped vertex of slot "${c[0]}"`, mode)), c[4].map((v) => numberOf(v, `clipped uv of slot "${c[0]}"`, mode)), c[5]]);
+  const clips = geometry.clips.map((c) => [c[0], c[1], c[2], numbersOf(c[3], `clip vertex of slot "${c[0]}"`, mode)]);
+  const clipped = geometry.drawnClipped.map((c) => [c[0], c[1], c[2], numbersOf(c[3], `clipped vertex of slot "${c[0]}"`, mode), numbersOf(c[4], `clipped uv of slot "${c[0]}"`, mode), c[5]]);
   return { drawn, clips, clipped };
 }
 function poseRawSetup(doc, plant = {}) {
   return setupPoseIn(doc, plant, RAW_MODE);
 }
+function sameSetupMeshDefinition(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length) return false;
+  const left = a;
+  const right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameSetupMeshDefinition(left[key], right[key]));
+}
+function readSetupMesh$1(doc, target) {
+  const view = target.skin === void 0 ? doc : target.skin === null ? underNoSkin(doc) : underSkin(doc, target.skin);
+  const where = `setup mesh slot ${JSON.stringify(target.slot)} attachment ${JSON.stringify(target.attachment)} under skin ${JSON.stringify(view.skin)}`;
+  const slot = view.slots.find((s) => s.name === target.slot);
+  if (slot === void 0) throw new CoreInputError(`${where}: no such slot`);
+  const resolved = shownAttachment(view, slot, target.attachment);
+  if (resolved === null) throw new CoreInputError(`${where}: no such attachment`);
+  const fills = fillingSkins(view, slot.name, target.attachment);
+  const definitions = fills.map((name) => view.skins.find((k) => k.name === name)?.attachments[slot.name]?.[target.attachment]);
+  if ("conflict" in resolved || definitions.some((r) => !sameSetupMeshDefinition(r, definitions[0]))) {
+    throw new CoreInputError(`${where}: skins [${fills.join(", ")}] fill this attachment differently; choose a named skin`);
+  }
+  const geometry = resolved.record.geometry;
+  const mesh = geometry?.kind === "linkedmesh" ? view.skins.find((s) => s.name === geometry.skin)?.attachments[geometry.slot]?.[geometry.source]?.geometry : geometry;
+  if (mesh?.kind !== "mesh") throw new CoreInputError(`${where}: ${resolved.record.kind} is not a mesh`);
+  const { world, shown, drawOrder } = setupPosed(view, {}, RAW_MODE);
+  const selected = shown.find((s) => s.slot === slot.name && s.placeholder === target.attachment && s.skin === resolved.skin);
+  const bone2 = world.get(slot.bone);
+  if (bone2 === void 0) throw new CoreInputError(`${where}: no setup transform for bone ${JSON.stringify(slot.bone)}`);
+  const vertices = selected === void 0 ? numbersOf(worldVertices(mesh.vertices, bone2, world).map(rawNumber), `${where} vertex`, RAW_MODE) : rawDrawn(view, [selected], world, drawOrder, {}).drawn[0].vertices;
+  return { slot: slot.name, attachment: target.attachment, skin: resolved.skin, vertices: [...vertices], triangles: [...mesh.triangles], hull: mesh.hull ?? null };
+}
 function setupPoseIn(doc, plant, mode) {
   const { world, shown, slots, drawOrder } = setupPosed(doc, plant, mode);
   const drawn = rawDrawn(doc, shown, world, drawOrder, plant, mode);
@@ -5015,10 +5168,11 @@ function animationOf(doc, animation) {
   if (anim === void 0) throw new CoreInputError(`animation "${animation}" is not one of this document's [${doc.animations.map((a) => a.name).join(", ")}]`);
   return anim;
 }
-function openWalk(doc, anim, plant, reset, mode, shape, adjust) {
+function openWalk(doc, anim, plant, reset, mode, shape, adjust, before) {
   const why = constraintsAbsentWhy(doc) ?? pathAnimationsWhy(doc) ?? steppedPreviousPassWhy(doc);
   if (why !== null) throw new CoreInputError(`the raw walk leaves the bones out: ${why}`);
   const ctx = freshStepContext(plant.physicsStep);
+  before?.(ctx);
   if (mode.loop && mode.wrapResets !== false) ctx.loop = true;
   const track = { doc, anim, duration: anim.timelines.duration, mode, plant, raw: { ...plant, ...roundPlant(mode) }, resolve: plant.shown ?? shownAttachment, shape, ctx, adjust, trackTime: 0, last: -1 };
   if (reset === "setup") {
@@ -5041,8 +5195,9 @@ function stepWalk(track, dt, first = false) {
   ctx.time += mode.clock === void 0 ? dt : mode.clock(dt, t - (first ? 0 : Math.max(last, 0)));
   const fire = plant.events ?? eventsFired;
   const keys = anim.timelines.events;
+  const adjustment = adjust === void 0 ? void 0 : { callback: adjust, context: { trackTime, animation: anim.name, globalTime: trackTime } };
   const pose = poseStepFrom(doc, plant, resolve, shape, mode, ctx, first, trackTime, t, {
-    world: (sliders) => shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjust }),
+    world: (sliders) => shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }),
     slots: (sliders, placeholders) => posedSlots(doc, anim.timelines, t, raw, sliders, placeholders),
     drawOrder: anim.timelines.drawOrder,
     at: t,
@@ -5090,12 +5245,56 @@ function openRawTracksPath(doc, plant) {
     step: (first, trackTime, animationTime, posers) => poseStepFrom(doc, plant, resolve, RAW_SHAPE, RAW_MODE, ctx, first, trackTime, animationTime, posers)
   };
 }
-function openRawTrack(doc, animation, plant, reset, mode, adjust) {
-  return openWalk(doc, animationOf(doc, animation), plant, reset, mode, RAW_SHAPE, adjust);
+function openRawTrack(doc, animation, plant, reset, mode, adjust, before) {
+  return openWalk(doc, animationOf(doc, animation), plant, reset, mode, RAW_SHAPE, adjust, before);
 }
 function stepRawTrack(track, dt) {
   return stepWalk(track, dt);
 }
+const FIELDS = ["strength", "damping", "inertia", "wind", "gravity", "mix"];
+const values = (r) => ({ strength: r.strength, damping: r.damping, inertia: r.inertia, wind: r.wind, gravity: r.gravity, mix: r.mix });
+class LivePhysicsParameters {
+  constructor(doc) {
+    this.doc = doc;
+    this.overrides = /* @__PURE__ */ new Map();
+    this.evaluated = /* @__PURE__ */ new Map();
+  }
+  named(name) {
+    const constraint = this.doc.constraints.find((c) => c.name === name);
+    if (constraint === void 0) throw new CoreInputError(`physics parameters: no constraint "${String(name)}"; this document declares [${this.doc.constraints.map((c) => c.name).join(", ")}]`);
+    if (constraint.kind !== "physics") throw new CoreInputError(`physics parameters: constraint "${name}" is ${constraint.kind}, not physics`);
+  }
+  set(name, patch) {
+    this.named(name);
+    if (typeof patch !== "object" || patch === null || Array.isArray(patch)) throw new CoreInputError(`physics parameters: constraint "${name}" patch is ${String(patch)}, not an object of finite fields [${FIELDS.join(", ")}]`);
+    const checked = {};
+    for (const key of Reflect.ownKeys(patch)) {
+      if (typeof key !== "string" || !FIELDS.includes(key)) throw new CoreInputError(`physics parameters: constraint "${name}" field "${String(key)}" is unknown; expected [${FIELDS.join(", ")}]`);
+      const field = key;
+      const value = patch[field];
+      if (typeof value !== "number" || !Number.isFinite(value)) throw new CoreInputError(`physics parameters: constraint "${name}" field "${field}" is ${String(value)}, not a finite number`);
+      checked[field] = value;
+    }
+    if (Reflect.ownKeys(checked).length > 0) this.overrides.set(name, { ...this.overrides.get(name), ...checked });
+  }
+  read(name) {
+    this.named(name);
+    const patch = this.overrides.get(name);
+    const effective = this.evaluated.get(name);
+    return { override: patch === void 0 ? null : { ...patch }, effective: effective === void 0 ? null : { ...effective } };
+  }
+  clear(name) {
+    this.named(name);
+    this.overrides.delete(name);
+  }
+  /** Called only for an active constraint, after the sliders and immediately before its step. */
+  apply(record) {
+    const patch = this.overrides.get(record.name);
+    const posed = patch === void 0 ? record : { ...record, ...patch };
+    this.evaluated.set(record.name, values(posed));
+    return posed;
+  }
+}
 const HELD = { loop: false, keep: false };
 const LOOPED = { loop: true, keep: false, live: true };
 function openTrack(doc, animation, options, plant = {}) {
@@ -5105,11 +5304,15 @@ function openTrack(doc, animation, options, plant = {}) {
   if (options.clock !== void 0 && typeof options.clock !== "function") throw new CoreInputError(`the live track's options.clock is ${typeof options.clock}, not a function`);
   const mode = options.loop ? LOOPED : HELD;
   const clock = options.clock === void 0 ? void 0 : checkedClock(options.clock, "the live track's");
-  const { track, first } = openRawTrack(doc, animation, plant, options.reset, clock === void 0 ? mode : { ...mode, clock: (dt) => clock(dt) }, options.adjust);
-  return new Track(track, first);
+  const parameters = new LivePhysicsParameters(doc);
+  const { track, first } = openRawTrack(doc, animation, plant, options.reset, clock === void 0 ? mode : { ...mode, clock: (dt) => clock(dt) }, options.adjust, (ctx) => {
+    ctx.parameters = parameters;
+  });
+  return new Track(track, first, parameters);
 }
 class Track {
-  constructor(track, first) {
+  constructor(track, first, parameters) {
+    this.parameters = parameters;
     this.steps = 0;
     this.refused = null;
     this.track = track;
@@ -5132,6 +5335,17 @@ class Track {
     this.live("setEnvironment");
     setEnvironmentOn(this.track.ctx, environment, "the live track's");
   }
+  setPhysicsParameters(name, patch) {
+    this.live("setPhysicsParameters");
+    this.parameters.set(name, patch);
+  }
+  readPhysicsParameters(name) {
+    return this.parameters.read(name);
+  }
+  clearPhysicsParameters(name) {
+    this.live("clearPhysicsParameters");
+    this.parameters.clear(name);
+  }
   physicsTranslate(x, y) {
     this.live("physicsTranslate");
     translateOn(this.track.ctx, x, y, "the live track's");
@@ -6063,6 +6277,8 @@ class Tracks {
     this.time = 0;
     this.refused = null;
     this.mixer = new Mixer(doc, plant);
+    this.parameters = new LivePhysicsParameters(doc);
+    this.path.ctx.parameters = this.parameters;
   }
   get trackTime() {
     return this.time;
@@ -6074,6 +6290,17 @@ class Tracks {
     this.live("setEnvironment");
     setEnvironmentOn(this.path.ctx, environment, "the live tracks'");
   }
+  setPhysicsParameters(name, patch) {
+    this.live("setPhysicsParameters");
+    this.parameters.set(name, patch);
+  }
+  readPhysicsParameters(name) {
+    return this.parameters.read(name);
+  }
+  clearPhysicsParameters(name) {
+    this.live("clearPhysicsParameters");
+    this.parameters.clear(name);
+  }
   physicsTranslate(x, y) {
     this.live("physicsTranslate");
     translateOn(this.path.ctx, x, y, "the live tracks'");
@@ -6178,9 +6405,14 @@ class Tracks {
     ctx.time += this.clock === void 0 ? dt : this.clock(dt);
     const pose = new Pose(doc, this.plant);
     const animationTime = this.mixer.apply(pose);
+    const entry = this.mixer.tracks[0] ?? null;
+    const adjustment = this.adjust === void 0 ? void 0 : {
+      callback: this.adjust,
+      context: { trackTime: entry?.trackTime ?? null, animation: entry?.anim.name ?? null, globalTime: this.time }
+    };
     const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));
     return path.step(first, this.time, animationTime, {
-      world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjust: this.adjust }),
+      world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjustment }),
       slots: (sliders, placeholders) => slotRowsFrom(doc, path.raw, sliders, placeholders, (_slot, _live) => {
         const s = pose.slots[doc.slots.indexOf(_slot)];
         return { placeholder: s.placeholder, light: s.light, dark: s.dark };
@@ -8343,6 +8575,9 @@ function affine(u0, v0, u1, v1, u2, v2, x0, y0, x1, y1, x2, y2) {
   const d = (eu1 * ey2 - eu2 * ey1) * inv;
   return [a, b, c, d, x0 - a * u0 - c * v0, y0 - b * u0 - d * v0];
 }
+function readSetupMesh(assets, target) {
+  return readSetupMesh$1(underNoSkin(assets.document.doc), target);
+}
 const SETS_SPECS = ["spine-parts-sets/1", "rig-parts-sets/1"];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8949,12 +9184,16 @@ class RigPlayer {
   setsByName;
   activeSet = null;
   adjustFn = null;
+  /** Current preview patches, reapplied through the public core API on replay; no edit history. */
+  physicsPatches = /* @__PURE__ */ new Map();
+  /** Public read snapshots belonging to a restored seek pose, not the core's private evaluation cache. */
+  heldParameters = null;
   slotFilter = null;
   /** `slotFilter` as a predicate; every slot when null. */
   draws = () => true;
   /** Handed to every track the player opens; reads the current `adjust` so setting it later needs no reopen. */
-  adjustHook = (locals) => {
-    if (this.adjustFn !== null) this.adjustFn(locals);
+  adjustHook = (locals, ctx) => {
+    if (this.adjustFn !== null) this.adjustFn(locals, ctx);
   };
   listeners = {
     event: /* @__PURE__ */ new Set(),
@@ -9051,7 +9290,7 @@ class RigPlayer {
       this.animation = name;
       this.loop = loop;
       this.track = openTrack(this.view, name, { loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
-      this.setRawPose(this.track.first);
+      this.setRawPose(this.initializeSingle(this.track));
       this.applyEnvironment(this.track);
       return;
     }
@@ -9157,6 +9396,7 @@ class RigPlayer {
     this.tracks = tracks;
     this.track = null;
     this.setRawPose(tracks.start());
+    this.applyPhysicsParameters(tracks);
     this.applyEnvironment(tracks);
     if (time > 0) this.stepTo(time);
     return tracks;
@@ -9164,10 +9404,54 @@ class RigPlayer {
   /** Stores `raw` and applies `activeSet` when one is active. Zero work when `activeSet === null`. */
   setRawPose(raw) {
     this.rawPose = raw;
+    this.heldParameters = null;
     this.pose = this.activeSet === null ? raw : applySetToPose(this.view, raw, this.activeSet);
     this.poseGeneration++;
     this.cachedIdentity = null;
   }
+  /**
+   * Sets a named physics constraint's pending patch, after keyed/slider values
+   * and before the integrator on the next evaluation. No pose or clock change.
+   * Unknown names/kinds/fields and non-finite values are refused atomically by
+   * the core. Requires a live track (call play/queue first).
+   */
+  setPhysicsParameters(name, patch) {
+    const live = this.requirePhysicsTrack("setPhysicsParameters", name);
+    live.setPhysicsParameters(name, patch);
+    const standing = live.readPhysicsParameters(name).override;
+    if (standing !== null) this.physicsPatches.set(name, standing);
+    this.clearSeekCache();
+  }
+  /** Pending override and the held pose's last active evaluation, detached. Does not evaluate a pose. */
+  readPhysicsParameters(name) {
+    const read = this.requirePhysicsTrack("readPhysicsParameters", name).readPhysicsParameters(name);
+    if (this.heldParameters === null) return read;
+    const effective = this.heldParameters.get(name)?.effective ?? null;
+    return { override: read.override, effective: effective === null ? null : { ...effective } };
+  }
+  /** Removes only the patch; authored values resume next evaluation. Physics history is retained. */
+  clearPhysicsParameters(name) {
+    this.requirePhysicsTrack("clearPhysicsParameters", name).clearPhysicsParameters(name);
+    this.physicsPatches.delete(name);
+    this.clearSeekCache();
+  }
+  requirePhysicsTrack(operation, name) {
+    const live = this.stepper();
+    if (live === null) throw new Error(`${operation}(${JSON.stringify(name)}) before play: no live track`);
+    return live;
+  }
+  /** No private parameter state is copied into the core's seek snapshots. */
+  readParameters(live) {
+    return new Map(this.view.constraints.filter((c) => c.kind === "physics").map((c) => [c.name, live.readPhysicsParameters(c.name)]));
+  }
+  applyPhysicsParameters(live) {
+    for (const [name, patch] of this.physicsPatches) live.setPhysicsParameters(name, patch);
+  }
+  /** Like the environment, standing patches are pending after the ordinary first pose; no extra evaluation. */
+  initializeSingle(live) {
+    this.applyPhysicsParameters(live);
+    return live.first;
+  }
   /**
    * The world the rig's physics answers (#121): `wind` and `gravity`, as
    * spine-core's skeleton-level `windX/windY` and `gravityX/gravityY` — x to
@@ -9246,6 +9530,7 @@ class RigPlayer {
       restoreStepperState(stepper, exactHit.state);
       this.rawPose = exactHit.rawPose;
       this.pose = exactHit.pose;
+      this.heldParameters = exactHit.parameters;
       this.poseGeneration++;
       this.cachedIdentity = null;
       return;
@@ -9257,24 +9542,32 @@ class RigPlayer {
       if (cache.frontierSteps <= SEEK_FINE_STEP_LIMIT || cache.frontierSteps % SEEK_COARSE_STRIDE === 0) {
         cache.grid.set(cache.frontierSteps, {
           state: captureStepperState(cache.frontier),
-          rawPose: raw
+          rawPose: raw,
+          parameters: this.readParameters(cache.frontier)
         });
       }
     }
+    let parameters;
     const gridHit = cache.grid.get(steps);
     if (gridHit !== void 0) {
       restoreStepperState(stepper, gridHit.state);
       this.rawPose = gridHit.rawPose;
+      parameters = gridHit.parameters;
     } else {
       const baseStep = steps - steps % SEEK_COARSE_STRIDE;
       const baseSnap = cache.grid.get(baseStep);
       restoreStepperState(stepper, baseSnap.state);
       this.rawPose = baseSnap.rawPose;
       for (let i = baseStep; i < steps; i++) this.rawPose = stepper.step(this.seekStep);
+      parameters = this.readParameters(stepper);
     }
     const rest = time - stepper.trackTime;
-    if (rest > 0) this.rawPose = stepper.step(rest);
+    if (rest > 0) {
+      this.rawPose = stepper.step(rest);
+      parameters = this.readParameters(stepper);
+    }
     if (this.rawPose !== null) this.setRawPose(this.rawPose);
+    this.heldParameters = parameters;
     if (this.rawPose !== null && this.pose !== null) {
       if (cache.exact.size >= SEEK_EXACT_LIMIT) {
         const oldest = cache.exact.keys().next().value;
@@ -9283,7 +9576,8 @@ class RigPlayer {
       cache.exact.set(time, {
         state: captureStepperState(stepper),
         rawPose: this.rawPose,
-        pose: this.pose
+        pose: this.pose,
+        parameters
       });
     }
   }
@@ -9304,16 +9598,17 @@ class RigPlayer {
       const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
       tracks.setAnimation(0, this.animation, { loop: this.loop, mixDuration: 0 });
       firstPose = tracks.start();
+      this.applyPhysicsParameters(tracks);
       this.applyEnvironment(tracks);
       frontier = tracks;
     } else {
       const track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
-      firstPose = track.first;
+      firstPose = this.initializeSingle(track);
       this.applyEnvironment(track);
       frontier = track;
     }
     const grid = /* @__PURE__ */ new Map();
-    grid.set(0, { state: captureStepperState(frontier), rawPose: firstPose });
+    grid.set(0, { state: captureStepperState(frontier), rawPose: firstPose, parameters: this.readParameters(frontier) });
     this.seekCache = {
       mode,
       frontier,
@@ -9331,11 +9626,12 @@ class RigPlayer {
       this.trackCount = 1;
       this.tracks = tracks;
       this.setRawPose(tracks.start());
+      this.applyPhysicsParameters(tracks);
       this.applyEnvironment(tracks);
       return;
     }
     this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
-    this.setRawPose(this.track.first);
+    this.setRawPose(this.initializeSingle(this.track));
     this.applyEnvironment(this.track);
   }
   /** What is open: the tracks, the single track, or nothing before `play`. */
@@ -9867,6 +10163,7 @@ export {
   DomRenderer,
   RigPlayer,
   loadModel,
+  readSetupMesh,
   revokeRegions,
   unpackRegions
 };