spine-html 1.12.1 → 1.13.0

package/README.md

@@ -450,6 +450,42 @@ box, an inverse clip removes nothing, and bounding boxes, paths and points do
 not draw and do not count. Both cost nothing until called and read the same
 numbers in `dom` and `canvas` mode.
 
+`readSetupMesh` reads a named mesh from loaded assets before or during playback,
+including an attachment the setup pose does not select:
+
+```ts
+import { readSetupMesh } from '@rig-c/play';
+
+const mesh = readSetupMesh(assets, { slot: 'flag', attachment: 'alternate' });
+// mesh: { slot, attachment, skin, vertices, triangles, hull }
+// vertices: flat world x,y pairs, Y up; hull counts vertices, or is null.
+```
+
+Names are exact slot names and attachment table keys, not display names or atlas
+regions. Omitted or `null` skin means no skin set, as for a fresh player. A named
+`skin` uses that skin's activation lists with default-table fallback; the returned
+`skin` names the supplying table. `skin: 'all'` uses all activation lists and
+refuses differing definitions rather than guessing a merge order. Linked meshes
+retain the requested identity and borrow source topology/bindings; unweighted
+vertices use the queried slot's bone. Inactive bones retain core's zero matrix.
+The result and its arrays are detached and mutable. Missing slot/attachment/skin,
+non-mesh and ambiguous targets throw core's named `CoreInputError` messages;
+setup/non-finite refusals propagate unchanged. The read creates no player and
+changes no document, existing player, time, generation or rendered frame.
+
+**Setup-slider boundary (core 2.66.0):** selected meshes include setup-slider
+deform, exactly as core's setup pose does. Unselected meshes use stored geometry
+through the same setup constraint/reset-physics matrices, without switching the
+attachment or borrowing another selection's deform. Core measured **four of six
+nonselected official-runtime comparisons differing by up to
+`2.9999999999999982` world units (about 3.0)**: spine-core 4.3.13's
+`computeWorldVertices` borrows the selected slot's deform, including for a linked
+mesh with `timelines: false`. The other two nonselected calls and all three
+selected reads agree exactly. This wrapper passes core's output through; it does
+not correct or round it. Stored-only formula comparisons therefore have a
+different domain from selected geometry with setup deform. See
+[core AUTHORING §14, including S1538_09](https://github.com/rig-c/core/blob/v2.66.0/docs/AUTHORING.md#14-read-a-named-mesh-at-setup).
+
 ### Drawing some slots only
 
 `slots` is a draw filter — an allow list of slot names or a predicate — settable up
@@ -1009,6 +1045,7 @@ name, and unloading is still elements first, bitmaps second.
 | `skeleton.findBone('head').worldX`, `.worldY`, `.a` … `.d` | `player.bone('head')` | `{ x, y, a, b, c, d, rotationX, rotationY, scaleX, scaleY, active }`, the core's world transform for the pose the player holds (the setup pose before `play`). An unknown name is refused by name. Since 1.1.0. |
 | `bone.scaleY = …` on a `Skeleton` between `state.apply` and `updateWorldTransform` | `RigPlayerOptions.adjust`, `player.adjust`, `player.repose()` | A function called once per pose with the pose's bone locals (`bones.bone('mouth').scaleY = v`). A write lasts one pose: the core poses every step from the setup pose, so write the value you want, every pose — nothing compounds. See *Adjusting bones*. Since 1.2.0. |
 | `skeleton.getBounds(offset, size)` | `player.bounds()` | `{ x, y, width, height }` or null, world units, Y up: the box of every drawn region's corners and mesh's vertices, a slot under a clip counted inside the clip's own box. `ModelAssets.stage` remains the declared framing, not this box. Since 1.1.0. |
+| named setup mesh geometry | `readSetupMesh(assets, { slot, attachment, skin? })` | Detached full-double world x/y (Y up), triangles and hull for any named mesh/linked mesh, including non-setup selections; no player/time mutation. Selected geometry includes setup-slider deform; unselected geometry is stored geometry through unchanged setup matrices. See the measured official-runtime distinction under *Reading the pose*. |
 
 ### No counterpart in 1.0.0
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { type CanvasBackend, CanvasRenderer, type CanvasViewport } from './CanvasRenderer.js';
 export { DomRenderer, type MeshBackend, type MeshSourceRect } from './DomRenderer.js';
 export { type PageLayout, type PageRegion, type RegionEncoding, type RegionImage, revokeRegions, type UnpackRegionsOptions, unpackRegions } from './DomTexture.js';
-export { type LoadModelOptions, loadModel, type ModelAssets, type ModelDocument, type RegionLoading, type RigSet } from './loadModel.js';
+export { type LoadModelOptions, loadModel, type ModelAssets, type ModelDocument, readSetupMesh, type RegionLoading, type RigSet, type SetupMesh, type SetupMeshTarget } from './loadModel.js';
 export { type AdjustableBones, type BoneAdjust, type BoneLocals, type BoneWorld, type PlayOptions, type PoseBounds, type QueueOptions, type RenderMode, type RigComplete, type RigEnvironment, type RigEvent, RigPlayer, type RigPlayerOptions, type SlotFilter, type SlotIdentity, type SlotIdentityReason, type SlotIdentitySnapshot, type TrackEntry } from './player.js';
 export type { BlendMode, PosedClip, PosedFrame, PosedMesh, PosedRegion, PosedSlot, } from './posedFrame.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnK,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACzI,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC7W,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnK,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC9L,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC7W,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC"}

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, values, timelines, t, blend, evalDeform, blendOf2, evalFrame) {
+  if (now === null || now.identity === null) return values;
+  const matching = matchingAttachments(timelines, now.identity);
+  if (matching === void 0) return values;
+  values ??= { deform: null, frame: null, seen: [] };
+  if (!values.seen.includes(now.identity)) values.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) values.deform = blend === null ? target : blendOf2(now.vertices, values.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) values.frame = f;
+    }
+  }
+  return values;
+}
 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 values = 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) values = applyAttachment(now, values, 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 (values !== null) {
+            values.deform = null;
+            values.frame = null;
           }
           placeholder = next;
+          now = identityOf(doc, resolve, slot, placeholder);
         }
       }
-      apply(app.timelines.attachments, app.at, { alpha: app.alpha, additive: app.additive });
+      values = applyAttachment(now, values, 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 = values === null || values.deform === null && values.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 (values !== null && values.seen.length > 0 && now.fillers.length > 1) {
+      why.push(`slot "${slot.name}" shows placeholder "${now.entry.placeholder}", which skins ${now.fillers.join(", ")} fill, and ${values.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 (values !== null) {
+      if (values.deform !== null) entry.deform = values.deform;
+      if (values.frame !== null) entry.frame = values.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(values, round) {
+  for (let i = 0; i < values.length; i++) {
+    const r = round(values[i]);
+    if (Object.is(r, values[i])) continue;
+    const out = values.slice(0, i);
+    out.push(r);
+    for (let j = i + 1; j < values.length; j++) out.push(round(values[j]));
+    return out;
+  }
+  return values;
+}
 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;
@@ -4702,8 +4816,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 +4828,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 +5021,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(values, what, mode) {
+  return allNumbers(values) ? values : values.map((v) => numberOf(v, what, mode));
+}
+function allNumbers(values) {
+  for (const v of values) 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 +5044,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,7 +5167,7 @@ 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);
@@ -8343,6 +8495,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);
@@ -9867,6 +10022,7 @@ export {
   DomRenderer,
   RigPlayer,
   loadModel,
+  readSetupMesh,
   revokeRegions,
   unpackRegions
 };