spine-rigc 2.13.0 → 2.13.2

package/package.json

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

package/src/assertions/model/stepped_poses.ts

@@ -42,9 +42,11 @@ const modeOf = (bone: ModelBone): string | null => (foldInheritMode(bone.inherit
 /** A channel the walk computed; a slot row holds `null` only where a rounding wrote one, which the walk does not. */
 const channel = (v: number | null): number => (v === null ? Number.NaN : v);
 
-/** One walk pose as A10 reads it, each bone's mode taken from `posed` (the bones the timelines posed at the pose's time). */
-function frameOf(pose: WalkPose, posed: readonly ModelBone[]): SteppedFrame {
-  const modes = new Map(posed.map((b) => [b.name, modeOf(b)]));
+/** Each bone's posed mode as the facts spell it (`modeOf`), by name. */
+const modesOf = (posed: readonly ModelBone[]): ReadonlyMap<string, string | null> => new Map(posed.map((b) => [b.name, modeOf(b)]));
+
+/** One walk pose as A10 reads it, each bone's mode taken from `modes` (`modesOf` the bones the timelines posed at the pose's time). */
+function frameOf(pose: WalkPose, modes: ReadonlyMap<string, string | null>): SteppedFrame {
   return {
     bones: pose.bones.map((b) => ({ name: b.name, a: b.a, b: b.b, c: b.c, d: b.d, worldX: b.worldX, worldY: b.worldY, inherit: modes.get(b.name) ?? null })),
     drawn: pose.drawn.map((d) => ({ slot: d.slot, attachment: d.attachment, vertices: d.vertices })),
@@ -80,11 +82,15 @@ export function modelSteppedPoses(read: ReadDocument): SteppedPoseFacts {
     },
     // The document's stated mode — asked only of a bone posing none, which the reader leaves this side no document to hold.
     statedInherit: (name) => `${JSON.stringify(read.doc.bones.find((b) => b.name === name)?.inheritMode)}`,
-    setup: () => frameOf(poseWalkSetup(viewOf()), viewOf().bones),
+    setup: () => frameOf(poseWalkSetup(viewOf()), modesOf(viewOf().bones)),
     walk: (animation, step, frames) => {
       const anim = animationOf(animation);
       const poses = poseLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
-      return poses.slice(1).map((pose) => frameOf(pose, posedBones(viewOf(), anim.timelines, pose.animationTime)));
+      // A bone's posed mode moves only by an `inherit` timeline: every other one `posedBones` reads leaves the setup's mode on its copy. So an animation
+      // keying none poses the setup's modes at every time, and they are read once rather than posed again at each of its frames (issue #1179).
+      const keysInherit = anim.timelines.bones.some((target) => target.timelines.some((tl) => tl.kind === 'inherit'));
+      const setupModes = keysInherit ? null : modesOf(viewOf().bones);
+      return poses.slice(1).map((pose) => frameOf(pose, setupModes ?? modesOf(posedBones(viewOf(), anim.timelines, pose.animationTime))));
     },
   };
 }

package/src/core/constraints.ts

@@ -1529,9 +1529,9 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
     if (inactiveWhy(state, c) !== null) skipped.add(i);
   });
   // A path constraint's offset reads its slot bone's world as the runtime last brought it up to date (`./constraints_path.ts`, *Which slot bone*).
-  const plan = records.some((c) => c.kind === 'path') ? slotBonePlan(bones, active, records, skipped) : new Map<number, SlotBoneEvent | null>();
+  const plan = records.some((c) => c.kind === 'path') ? keptPlan(slotBonePlans, state, records, skipped, () => slotBonePlan(bones, active, records, skipped)) : new Map<number, SlotBoneEvent | null>();
   // An ik over an inactive bone reads the frame above it as the pass left it (issue #979).
-  const updated = records.some((c) => c.kind === 'ik' && c.bones.some((b) => !active.has(b))) ? frameUpdatedBefore(bones, active, records, skipped) : new Map<number, boolean>();
+  const updated = records.some((c) => c.kind === 'ik' && c.bones.some((b) => !active.has(b))) ? keptPlan(frameUpdates, state, records, skipped, () => frameUpdatedBefore(bones, active, records, skipped)) : new Map<number, boolean>();
   const snapshots = new Map<number, CoreWorld>();
   // Issue #1049: under the step a slider's physics timelines write the pass's physics records, which a later physics constraint steps with.
   const physicsPose = physics === undefined ? undefined : sliderPhysicsTarget(records, active, physics, rules);
@@ -1578,24 +1578,111 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
   return state.world;
 }
 
-/** The last bone index each view's active set was asked for, with the names it was built over (`boneIndex`). */
-const indexOfView = new WeakMap<ReadonlySet<string>, { names: string[]; index: Map<string, number> }>();
+/**
+ * What `slotBonePlan` (`./constraints_path.ts`) and `frameUpdatedBefore` read
+ * of a record: its kind and the names it orders — a name by value, a list by
+ * identity. Every pass of a walk poses its records afresh (`posedRecords`,
+ * `pathDeformed`, `stepPhysicsRecords` spread each one), and a spread carries
+ * these lists over as the same arrays.
+ */
+function planShape(c: CoreConstraintRecord): readonly unknown[] {
+  switch (c.kind) {
+    case 'slider':
+      return [c.kind, c.timelines.bones];
+    case 'ik':
+      return [c.kind, c.target, c.bones];
+    case 'physics':
+      return [c.kind, c.bone];
+    case 'transform':
+      return [c.kind, c.source, c.bones];
+    case 'path':
+      return [c.kind, c.bones, c.slotDeps, c.slotBone];
+  }
+}
+
+/** A plan kept per solver index, with the record shapes (`planShape`) and the skipped records it was built over. */
+interface KeptPlan<T> {
+  shapes: ReadonlyArray<readonly unknown[]>;
+  skipped: readonly number[];
+  plan: T;
+}
+const slotBonePlans = new WeakMap<ReadonlyMap<string, number>, KeptPlan<Map<number, SlotBoneEvent | null>>>();
+const frameUpdates = new WeakMap<ReadonlyMap<string, number>, KeptPlan<Map<number, boolean>>>();
+
+/**
+ * A pass's ordering plan — `slotBonePlan` or `frameUpdatedBefore` — reused
+ * from the pass before when nothing it reads has changed (issue #1179): the
+ * bones' names and parents and the active set (one solver index stands for
+ * those, `boneIndex`), each record's shape, and which records are skipped.
+ * Otherwise built again. Both read names and nothing else, so a reused plan is
+ * the plan the pass would have built; neither is written once built.
+ */
+function keptPlan<T>(kept: WeakMap<ReadonlyMap<string, number>, KeptPlan<T>>, state: SolverState, records: readonly CoreConstraintRecord[], skipped: ReadonlySet<number>, build: () => T): T {
+  const shapes = records.map(planShape);
+  const skips = [...skipped];
+  const last = kept.get(state.index);
+  if (
+    last !== undefined &&
+    last.shapes.length === shapes.length &&
+    shapes.every((sh, i) => sh.length === last.shapes[i].length && sh.every((v, j) => v === last.shapes[i][j])) &&
+    last.skipped.length === skips.length &&
+    skips.every((k, i) => k === last.skipped[i])
+  ) {
+    return last.plan;
+  }
+  const plan = build();
+  kept.set(state.index, { shapes, skipped: skips, plan });
+  return plan;
+}
+
+/** The last bone index each view's active set was asked for, with the names and parents it was built over (`boneIndex`). */
+const indexOfView = new WeakMap<ReadonlySet<string>, { names: string[]; parents: Array<string | undefined>; index: Map<string, number> }>();
 
 /**
  * Each bone's position in `bones`, by name — the solver's index. Every pose of
  * a view lists the same bones in the same order (issue #1134: a walk built it
  * anew on each of its passes), so the index last built under the view's
  * active set (`activeBones`, one object per view) is reused when the names
- * agree position by position, and built again otherwise. Read, never written.
+ * and the parents agree position by position, and built again otherwise —
+ * the parents because `repose` keeps each bone's subtree beside the index
+ * (`subtreesOf`), and a subtree is a reading of them. Read, never written.
  */
 function boneIndex(bones: readonly ModelBone[], active: ReadonlySet<string>): Map<string, number> {
   const kept = indexOfView.get(active);
-  if (kept !== undefined && kept.names.length === bones.length && bones.every((b, i) => b.name === kept.names[i])) return kept.index;
+  if (kept !== undefined && kept.names.length === bones.length && bones.every((b, i) => b.name === kept.names[i] && b.parent === kept.parents[i])) return kept.index;
   const index = new Map(bones.map((b, i) => [b.name, i]));
-  indexOfView.set(active, { names: bones.map((b) => b.name), index });
+  indexOfView.set(active, { names: bones.map((b) => b.name), parents: bones.map((b) => b.parent), index });
   return index;
 }
 
+/** Each bone's subtree as `subtreesOf` built it, kept per solver index (one object per view's bones, `boneIndex`). */
+const subtreesOfIndex = new WeakMap<ReadonlyMap<string, number>, ReadonlyArray<readonly number[]>>();
+
+/**
+ * For the bone at each position of `state.bones`, the positions of the bone
+ * and of every bone below it, ascending (issue #1179). Bones are parents
+ * first, so each position is appended to its own list and its ancestors' in
+ * ascending order. Built from the bones' parents once per solver index —
+ * `boneIndex` hands back one index only while the names and the parents are
+ * the ones it was built over, and the other two solver states (`previousPassSlotBones`,
+ * `historyTaint`) build an index of their own.
+ */
+function subtreesOf(state: SolverState): ReadonlyArray<readonly number[]> {
+  const kept = subtreesOfIndex.get(state.index);
+  if (kept !== undefined) return kept;
+  const lists: number[][] = state.bones.map(() => []);
+  for (let k = 0; k < state.bones.length; k++) {
+    let at: number | undefined = k;
+    while (at !== undefined) {
+      lists[at].push(k);
+      const parent: string | undefined = state.bones[at].parent;
+      at = parent === undefined ? undefined : state.index.get(parent);
+    }
+  }
+  subtreesOfIndex.set(state.index, lists);
+  return lists;
+}
+
 /** After a constraint: the bones it moved in world space read back into local values, and every bone below one it moved posed again (the header's update order). */
 function repose(state: SolverState, changed: readonly string[], inWorld: readonly string[]): void {
   for (const name of inWorld) {
@@ -1606,13 +1693,17 @@ function repose(state: SolverState, changed: readonly string[], inWorld: readonl
   const moved = changed;
   const below = new Set(changed);
   const keep = inWorld;
-  // Bones are parents first (`readModel` refuses any other order) and a bone joins `below` only through its parent, so none before the first bone moved can: the walk starts there (issue #1134).
-  let from = state.bones.length;
+  // A bone joins `below` only through its parent, so the bones that can are the moved bones' subtrees: the walk visits those, in bone order (issue
+  // #1179), where it visited every bone from the first one moved (issue #1134) — the bones it no longer visits are the ones whose parent `below`
+  // could never hold, so each bone it does visit reads the same `below`, and is posed again in the same order.
+  const subtrees = subtreesOf(state);
+  const lists: Array<readonly number[]> = [];
   for (const name of changed) {
     const at = state.index.get(name);
-    if (at !== undefined && at < from) from = at;
+    if (at !== undefined) lists.push(subtrees[at]);
   }
-  for (let k = from; k < state.bones.length; k++) {
+  const visit = lists.length === 1 ? lists[0] : [...new Set(lists.flat())].sort((x, y) => x - y);
+  for (const k of visit) {
     const b = state.bones[k];
     // Not through an inactive bone the constraint did not move itself (issue #979): the bones below it keep what the constraints wrote into them.
     if (b.parent !== undefined && below.has(b.parent) && (!state.rules.inactiveHoldsItsWorld || state.active.has(b.parent) || moved.includes(b.parent))) below.add(b.name);

package/src/core/raw.ts

@@ -120,7 +120,7 @@ import { freshStepContext, steppedPreviousPassWhy } from './constraints_physics.
 import { attachmentStates } from './deform.ts';
 import { drawOrderAt } from './draw_order.ts';
 import { eventsFired } from './events.ts';
-import { REGION_TRIANGLES, REGION_UVS } from './clipping.ts';
+import { REGION_TRIANGLES, REGION_UVS, type ShapeClipper } from './clipping.ts';
 import { poseGeometry, type ShownGeometry } from './vertices.ts';
 import { RUNTIME_DEG, type CoreWorld } from './world.ts';
 import type { SliderApplication } from './constraints_slider.ts';
@@ -240,6 +240,16 @@ function numberOf(v: number | null, what: string, mode: WalkMode): number {
   return mode.keep ? (v === null ? Number.NaN : v) : finite(v, what);
 }
 
+/**
+ * What the looping walk cuts a drawn attachment through under a clip: nothing
+ * (issue #1179). Its one reader, A10, reads no clipped row — `./walk.ts`
+ * narrows them away with the events — so the walk does not cut them; what it
+ * still does is plan every clip it starts (`poseClipped`'s `clipShapeOf`), so
+ * a clip the core does not draw refuses the walk by name as before. Every
+ * number a looping pose carries is computed as it was.
+ */
+const NO_CLIPPED_ROWS: ShapeClipper = () => null;
+
 /** The bones of a pose from the world transforms (the header's `bones`). */
 function rawBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>): RawBone[] {
   const active = activeBones(doc);
@@ -266,7 +276,8 @@ function rawBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>):
 
 /** Every region and mesh the shown records draw, with what the renderer reads past the vertices (the header's `drawn`). */
 function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode = RAW_MODE): { drawn: RawDrawn[]; clips: RawClip[]; clipped: RawClipped[] } {
-  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, drawWalkOf(doc, order, plant));
+  const draw = drawWalkOf(doc, order, plant);
+  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, mode.loop && plant.through === undefined ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
   if (geometry.attachments === null) throw new CoreInputError(`the raw pose leaves the attachments out: ${geometry.attachmentsWhy}`);
   // The drawn rows (issue #964): the oracle's `clipped` rows where it is posed, and a concave or inverse clip cut through the core's own decomposition.
   if (geometry.drawnClipped === null) throw new CoreInputError(`the raw pose leaves the clipped triangles out: ${geometry.drawnClippedWhy}`);
@@ -339,6 +350,20 @@ export function poseRawAnimation(doc: CompiledDocument, animation: string, steps
   return walkIn(doc, animation, steps, plant, reset, RAW_MODE);
 }
 
+/**
+ * `poseRawAnimation`, each pose handed to `visit` as it is posed rather than
+ * collected (issue #1180): the same walk, the same poses in the same order,
+ * and the caller holds as many of them as it keeps. `src/render_core.ts`
+ * draws each and lets it go, so a render holds one pose and not an
+ * animation's series — on the production rig the core poser's render peaked
+ * highest on, the largest animation's series was 153 MiB of retained heap.
+ * A refusal is thrown from the pose it is met at, after `visit` has seen the
+ * poses before it.
+ */
+export function poseRawAnimationEach(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, visit: (pose: RawPose, index: number) => void): void {
+  walkEach(doc, animation, steps, plant, reset, RAW_MODE, visit);
+}
+
 /**
  * The animation time a looping track applies its animation at (`./walk.ts`,
  * *The time*): the track time wrapped by the duration, and 0 over a duration
@@ -355,6 +380,13 @@ export function loopedTime(trackTime: number, duration: number): number {
  * `mode` here, so the raw entry's walk is the one it was.
  */
 export function walkIn(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode): RawPose[] {
+  const poses: RawPose[] = [];
+  walkEach(doc, animation, steps, plant, reset, mode, (pose) => poses.push(pose));
+  return poses;
+}
+
+/** `walkIn`'s walk, each pose handed to `visit` in order as it is posed (`poseRawAnimationEach`). */
+function walkEach(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode, visit: (pose: RawPose, index: number) => void): void {
   const anim = doc.animations.find((a) => a.name === animation);
   if (anim === undefined) throw new CoreInputError(`animation "${animation}" is not one of this document's [${doc.animations.map((a) => a.name).join(', ')}]`);
   const bad = steps.findIndex((s) => !Number.isFinite(s) || s < 0);
@@ -366,7 +398,7 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
   const duration = anim.timelines.duration;
   const ctx = freshStepContext(plant.physicsStep);
   if (mode.loop && mode.wrapResets !== false) ctx.loop = true;
-  const poses: RawPose[] = [];
+  let visited = 0;
   let trackTime = 0;
   let last = -1;
   if (reset === 'setup') {
@@ -376,7 +408,7 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
     if (absent.length > 0) throw new CoreInputError(`the raw walk's reset pose leaves ${absent.map(([b, w]) => `${b} out (${w})`).join('; ')}`);
     if (setup.world === null || setup.shown === null || setup.setup.slots === null || setup.setup.drawOrder === null) throw new CoreInputError('the raw walk\'s reset pose was not posed');
     ctx.phase = 'update';
-    poses.push({ trackTime: 0, animationTime: 0, bones: rawBones(doc, setup.world), slots: setup.setup.slots, drawOrder: setup.setup.drawOrder, ...rawDrawn(doc, setup.shown, setup.world, setup.setup.drawOrder, plant, mode), events: [], shown: drawOrderOf(setup.shown, setup.setup.drawOrder) });
+    visit({ trackTime: 0, animationTime: 0, bones: rawBones(doc, setup.world), slots: setup.setup.slots, drawOrder: setup.setup.drawOrder, ...rawDrawn(doc, setup.shown, setup.world, setup.setup.drawOrder, plant, mode), events: [], shown: drawOrderOf(setup.shown, setup.setup.drawOrder) }, visited++);
   }
   for (let i = reset === 'setup' ? 1 : 0; i <= steps.length; i++) {
     const dt = i === 0 ? 0 : steps[i - 1];
@@ -399,12 +431,12 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
     const rank = new Map(drawOrder.map((n, r) => [n, r]));
     const shown = [...states.shown].sort((a, b) => (rank.get(a.slot) ?? 0) - (rank.get(b.slot) ?? 0));
     const drawn = rawDrawn(doc, shown, posed.world, drawOrder, plant, mode);
-    // A looping walk fires no event here: what fires across the wrap was not measured, and the walk's one reader (A10) reads none.
+    // A looping walk fires no event here: what fires across the wrap was not measured, and the walk's one reader (A10) reads none. Nor does it cut its
+    // drawn attachments through a clip (`NO_CLIPPED_ROWS`), so its `clipped` rows are empty.
     const events = mode.loop ? [] : (plant.events ?? eventsFired)(anim.timelines.events, last, t, rawNumber).map((e): RawEvent => [e[0], finite(e[1], 'event time'), e[2], finite(e[3], 'event float'), e[4]]);
     last = t;
-    poses.push({ trackTime, animationTime: t, bones: rawBones(doc, posed.world), slots: slots.rows, drawOrder, ...drawn, events, shown });
+    visit({ trackTime, animationTime: t, bones: rawBones(doc, posed.world), slots: slots.rows, drawOrder, ...drawn, events, shown }, visited++);
   }
-  return poses;
 }
 
 // --- #907 the setup-pose bounding box: begin ---

package/src/core/walk.ts

@@ -58,7 +58,9 @@
  *   NaN and Infinity stood where spine-core's did.
  *
  * Events are not carried: A10 reads none, and what a looping track fires
- * across the wrap was not measured.
+ * across the wrap was not measured. Nor are the clipped rows, and the walk
+ * does not cut them (issue #1179): every clip it starts is still planned, so
+ * a clip the core does not draw refuses the walk by name, as below.
  *
  * ⛔ **What is still refused** is the raw entry's other refusal: a construct
  * the core would leave out (a block the oracle's core dump names absent) is a

package/src/render.ts

@@ -560,7 +560,7 @@ export function candidatePosers(
   skeletonPath: string,
   atlasPath: string,
   forced: PoserName | undefined,
-  /** What builds the core poser: `corePoser` — the suite's `RC02` passes a planted copy, and nothing else passes any. */
+  /** What builds the core poser: `corePoser` — the suite's `RC02`, `RC43` and `RC44` pass planted or counted copies, and nothing else passes any. */
   make: MakeCorePoser = corePoser,
 ): PoserChoice {
   return refuseUnchosen(choosePosers(skeletonPath, atlasPath, readFileSync(atlasPath, 'utf8'), forced, () => data, make).choice);

package/src/render_core.ts

@@ -26,7 +26,9 @@
  *   `min(sum, duration)`, physics reset at pose 0 and stepped by `1/fps` after
  *   — the recipe `spinePoser` runs, measured bit-exact against it on every
  *   frame of the nineteen tree rows by the core suite's `CR03`. The setup pose
- *   is `poseRawSetup`.
+ *   is `poseRawSetup`. Since issue #1180 the walk is `poseRawAnimationEach`,
+ *   the same walk handing each pose over as it is posed (`CORE_RAW_WALK`), so
+ *   one pose is held at a time.
  * - **Vertices, triangles, bones, slot colours, draw order** are the raw
  *   pose's, unchanged: the same doubles `computeWorldVertices`,
  *   `getWorldRotationX` and the slot pose hold (`CR03`).
@@ -94,7 +96,8 @@ import { atlasRegionLookup, parseAtlasText } from './atlas.ts';
 import { pagesOfAtlas, spineFileSha256, type ModelPage } from './model.ts';
 import { clipThrough, type ClipShape, type ShapeClipper } from './core/clipping.ts';
 import { activeBones, CoreInputError, readModel, sourceOfDoc, underNoSkin, underSkin, type CompiledDocument, type CoreSlotRow } from './core/index.ts';
-import { poseRawAnimation, poseRawSetup, type RawDrawn, type RawPose } from './core/raw.ts';
+import { poseRawAnimationEach, poseRawSetup, type RawDrawn, type RawPose } from './core/raw.ts';
+import type { TimelinePlant } from './core/animation.ts';
 import { CORE_DEFAULT_SKIN, lookupSkins } from './core/skins.ts';
 import { documentPageLookup, drawnRegions, meshPageUvs, readUvSequences, regionPageUvs, type DrawnRegion, type UvRegion, type UvSource } from './core/uvs.ts';
 import { regionCorners, worldVertices } from './core/vertices.ts';
@@ -273,6 +276,98 @@ interface CoreInput {
   source: UvSource;
   /** The region a name draws — the document's `pages`, or for a `/1` document the atlas's — what an original-art UV reads its trim from. */
   region: (name: string) => TextureRegion | null;
+  /** The page UVs and triangle lists the pieces hold (`PieceArrays`), one table for every pose of this poser. */
+  arrays: PieceArrays;
+}
+
+/**
+ * The two arrays a drawn piece holds that are not a function of the pose
+ * (issue #1180): its page UVs — a function of the region it samples and,
+ * for a mesh, the attachment's own UVs — and a mesh's triangle list.
+ *
+ * ⭐ Why a table rather than an array per piece. A render holds its frames
+ * before it writes one (every animation at `PROTOCOL_FPS`), and the framing
+ * reads every animation at `FRAMING_FPS`; a fresh copy of both arrays in every
+ * piece of every frame was what made the core poser's render peak at 3.3x
+ * spine-core's resident size on a production rig (4,015 against 1,214 MiB,
+ * n = 5), where spine-core's pieces hold the attachment's own `uvs` and
+ * `triangles` and only the world vertices are per frame. Held here, the count
+ * of these arrays is bounded by what the rig draws — one per region and
+ * attachment UVs, one per distinct triangle list of a slot's attachment — and
+ * not by how many frames are posed (`RC43`).
+ *
+ * The values are the same doubles either way: the UVs are computed once by
+ * the same call from the same inputs, and a triangle list is reused only where
+ * it is equal, index for index, to the one the pose carries. No reader writes
+ * into a piece's arrays — spine-core's pieces have always shared theirs.
+ */
+export interface PieceArrays {
+  /** The page UVs `found` is drawn with: `regionPageUvs` for a region, `meshPageUvs` over the attachment's UVs for a mesh. */
+  uvs(found: DrawnRegion): number[];
+  /** A triangle list equal, index for index, to `drawn.triangles`. */
+  triangles(drawn: RawDrawn): number[];
+}
+
+/** `PieceArrays` kept for the poser's lifetime — what `corePoser` builds unless a plant passes another. */
+export function keptPieceArrays(): PieceArrays {
+  // Keyed on the placement's own object (one per region name, `documentPageLookup`/`atlasRegionLookup`) and the
+  // document's UV array (or `null` for a region): both live as long as the poser, so a key is never a copy.
+  const uvs = new WeakMap<object, Map<readonly number[] | null, number[]>>();
+  // Keyed by slot and attachment, and each list compared index for index before it is reused: a key names where
+  // a list was drawn, the comparison is what makes reusing it exact.
+  const triangles = new Map<string, number[][]>();
+  return {
+    uvs: (found) => {
+      let byArt = uvs.get(found.found);
+      if (byArt === undefined) {
+        byArt = new Map();
+        uvs.set(found.found, byArt);
+      }
+      let kept = byArt.get(found.art);
+      if (kept === undefined) {
+        kept = found.art === null ? regionPageUvs(found.found.region, found.found.page) : meshPageUvs(found.found.region, found.found.page, found.art);
+        byArt.set(found.art, kept);
+      }
+      return kept;
+    },
+    triangles: (drawn) => {
+      const key = `${drawn.slot}\u0000${drawn.attachment}`;
+      let lists = triangles.get(key);
+      if (lists === undefined) {
+        lists = [];
+        triangles.set(key, lists);
+      }
+      const wanted = drawn.triangles;
+      const equal = (list: readonly number[]): boolean => {
+        if (list.length !== wanted.length) return false;
+        for (let i = 0; i < list.length; i++) if (list[i] !== wanted[i]) return false;
+        return true;
+      };
+      let kept = lists.find(equal);
+      if (kept === undefined) {
+        kept = [...wanted];
+        lists.push(kept);
+      }
+      return kept;
+    },
+  };
+}
+
+/**
+ * The raw walk the core poser steps an animation with (issue #1180):
+ * `poseRawAnimationEach`, which hands each pose to `visit` as it is posed, so
+ * one pose is held at a time rather than the animation's whole series. A plant
+ * passes another (`RC44`).
+ */
+export type CoreRawWalk = (doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, visit: (pose: RawPose, index: number) => void) => void;
+
+/** The walk `corePoser` steps with unless a plant passes another: one pose posed, drawn and released before the next. */
+export const CORE_RAW_WALK: CoreRawWalk = (doc, animation, steps, plant, visit) => poseRawAnimationEach(doc, animation, steps, plant, 'animation', visit);
+
+/** What a suite passes `corePoser` in place of the poser's own parts — `PieceArrays` (`RC43`) and the raw walk (`RC44`). */
+export interface CorePoserPlants {
+  arrays?: () => PieceArrays;
+  walk?: CoreRawWalk;
 }
 
 /**
@@ -419,7 +514,7 @@ function pieces(
     if (!drawn) continue;
     const found = regions.get(d.slot);
     if (found === undefined) throw new CoreInputError(`slot "${d.slot}" drew "${d.attachment}", and no atlas region was resolved for it`);
-    const uvs = found.art === null ? regionPageUvs(found.found.region, found.found.page) : meshPageUvs(found.found.region, found.found.page, found.art);
+    const uvs = input.arrays.uvs(found);
     const atlasRegion = draw.texture ? input.region(found.region) : null;
     if (draw.texture && atlasRegion === null) throw new CoreInputError(`slot "${d.slot}": atlas region "${found.region}" is not in the atlas`);
     const texture = atlasRegion === null ? undefined : artUvsOf(d, atlasRegion);
@@ -427,7 +522,7 @@ function pieces(
     const world = [...d.vertices];
     const piece: Piece =
       d.kind === 'mesh'
-        ? { kind: 'mesh', ...common, texture, world, uvs, triangles: [...d.triangles] }
+        ? { kind: 'mesh', ...common, texture, world, uvs, triangles: input.arrays.triangles(d) }
         : { kind: 'region', ...common, texture, world, uvs };
     const shape = cover.get(d.slot);
     out.push(shape === undefined ? piece : clippedPiece(piece, d, shape, uvs, rows.get(d.slot), through));
@@ -592,7 +687,14 @@ function placementOf(doc: CompiledDocument, atlasText: string, where: string): {
  * `CoreInputError`, naming why, where the document or the atlas cannot be read; a pose the core leaves a block of out
  * is refused the same way when it is asked for (the header).
  */
-export function corePoser(modelText: string, atlasText: string, where = 'skeleton.model.json', skeleton?: { path: string; bytes: Uint8Array }, through: ShapeClipper = clipThrough): Poser {
+export function corePoser(
+  modelText: string,
+  atlasText: string,
+  where = 'skeleton.model.json',
+  skeleton?: { path: string; bytes: Uint8Array },
+  through: ShapeClipper = clipThrough,
+  plants: CorePoserPlants = {},
+): Poser {
   const doc = readModel(modelText, where);
   // The document poses the rig it was built with; the Spine file beside it must be that build's (issue #968).
   if (skeleton !== undefined) {
@@ -613,6 +715,8 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
   const sequences = readUvSequences(parsed);
   const { lookup, region } = placementOf(doc, atlasText, where);
   const views = new Map<string, CompiledDocument>();
+  const arrays = (plants.arrays ?? keptPieceArrays)();
+  const walk = plants.walk ?? CORE_RAW_WALK;
   const inputOf = (skin: string | undefined): CoreInput => {
     const key = skin === undefined ? '' : `=${skin}`;
     let view = views.get(key);
@@ -620,7 +724,7 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
       view = skin === undefined ? noSkinView(doc) : underSkin(doc, skin);
       views.set(key, view);
     }
-    return { doc: view, source: { lookup, sequences }, region };
+    return { doc: view, source: { lookup, sequences }, region, arrays };
   };
   const roster: SubsetRoster = {
     declared: doc.slots.map((s) => s.name),
@@ -639,8 +743,20 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
     animation: (name, skin, fps, count, visit) => {
       const input = inputOf(skin);
       const step = 1 / fps;
-      const poses = poseRawAnimation(input.doc, name, new Array<number>(count).fill(step), { through }, 'animation');
-      poses.forEach((pose, i) => visit(i, corePosed(input, pose, through)));
+      // Each pose is drawn as it is posed and released before the next (issue #1180), so the walk holds one pose and not
+      // the animation's series. What is thrown is what was thrown when the series was posed first and drawn after: a
+      // walk that refuses a later pose still refuses the call, and a draw that throws is re-thrown once the walk has
+      // finished without refusing — the first such throw, by frame — and no frame after it is drawn.
+      const drawFailed: unknown[] = [];
+      walk(input.doc, name, new Array<number>(count).fill(step), { through }, (pose, i) => {
+        if (drawFailed.length > 0) return;
+        try {
+          visit(i, corePosed(input, pose, through));
+        } catch (thrown) {
+          drawFailed.push(thrown);
+        }
+      });
+      if (drawFailed.length > 0) throw drawFailed[0];
     },
     rest: (skin, shown) => {
       const input = inputOf(skin);

package/src/render_shared.ts

@@ -2148,6 +2148,37 @@ export function unframeableSentence(
   );
 }
 
+/** A box being widened over vertices: `minX`…`maxY`, empty at ±Infinity. */
+interface FramingBox {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+
+/** `box` widened over the `[x, y, …]` pairs of `world` — `unionBounds`'s arithmetic, in its order of reading. */
+function extendBox(box: FramingBox, world: ArrayLike<number>): void {
+  for (let i = 0; i < world.length; i += 2) {
+    box.minX = Math.min(box.minX, world[i]);
+    box.maxX = Math.max(box.maxX, world[i]);
+    box.minY = Math.min(box.minY, world[i + 1]);
+    box.maxY = Math.max(box.maxY, world[i + 1]);
+  }
+}
+
+/**
+ * How `framingViewport` is handed its frame sets: `sample` called for each of
+ * `animations` (`null` the setup pose of a skeleton with none), the sets
+ * yielded in that order. The framing reads each set whole before it asks for
+ * the next.
+ */
+export type FramingSets = (sample: (animation: string | null) => Frame[], animations: ReadonlyArray<string | null>) => Iterable<Frame[]>;
+
+/** Each set sampled only when the framing asks for it, so the one before it is no longer held (issue #1180). */
+export const ONE_SET_AT_A_TIME: FramingSets = function* (sample, animations) {
+  for (const animation of animations) yield sample(animation);
+};
+
 /**
  * The viewport a skeleton is framed to: its union box at `FRAMING_FPS`, padded,
  * scaled so the long side is `maxSide` pixels.
@@ -2174,8 +2205,24 @@ export function unframeableSentence(
  * that pose one. Spine data as the source is its own. A bare `Poser` with no
  * roster cannot tell an unposed bone from a posed one, so every drawn slot
  * counts there; every CLI caller passes the roster, so both posers frame alike.
- */
-export function framingViewport(source: PoseSource, maxSide: number, opts?: PoseOptions, rosterGiven?: SkinRoster): Viewport | null {
+ *
+ * ⭐ One animation's frames at a time (issue #1180). The box is a minimum and
+ * a maximum per axis, which no order of reading changes, so each animation's
+ * frames are read into a box per slot and released before the next animation
+ * is sampled; the box over the slots that pose is the union of theirs. Held
+ * all at once — every animation at 60 fps — they were the largest single
+ * holder of a render's heap: on the production rig whose core-poser render
+ * peaked highest, 961 MiB retained at the framing's high-water under the core
+ * poser and 293 MiB under spine-core's. `RC42` reads that no animation's
+ * frames are read once the next one is sampled; `sets` is a plant's way in.
+ */
+export function framingViewport(
+  source: PoseSource,
+  maxSide: number,
+  opts?: PoseOptions,
+  rosterGiven?: SkinRoster,
+  sets: FramingSets = ONE_SET_AT_A_TIME,
+): Viewport | null {
   const poser = poserOf(source);
   // The skin belongs here as much as in the frames: the union box is over the
   // attachments that POSE, and two skins fill a slot with art of different sizes
@@ -2194,10 +2241,25 @@ export function framingViewport(source: PoseSource, maxSide: number, opts?: Pose
   // both would be taken at `FRAMING_FPS` for every animation only to be dropped.
   const { slots: _drawn, hidden: _hidden, bones: _bones, geometry: _geometry, ...whole } = opts ?? {};
   const framed: PoseOptions = { ...whole, unclipped: true };
-  const sets =
-    poser.animations.length === 0
-      ? [sampleSetupPose(poser, framed)]
-      : poser.animations.map((a) => sampleAnimation(poser, a.name, FRAMING_FPS, framed));
+  const sample = (animation: string | null): Frame[] =>
+    animation === null ? sampleSetupPose(poser, framed) : sampleAnimation(poser, animation, FRAMING_FPS, framed);
+  const animations: Array<string | null> = poser.animations.length === 0 ? [null] : poser.animations.map((a) => a.name);
+  // Per slot, in the order a slot first drew: the box over its vertices and whether it drew one. Min and max select, so the
+  // union over any grouping of the same vertices is the same four numbers — NaN and the sign of a zero included.
+  const bySlot = new Map<string, { box: FramingBox; drew: boolean }>();
+  for (const frames of sets(sample, animations)) {
+    for (const frame of frames) {
+      for (const piece of frame.pieces) {
+        let slot = bySlot.get(piece.slot);
+        if (slot === undefined) {
+          slot = { box: { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }, drew: false };
+          bySlot.set(piece.slot, slot);
+        }
+        if (piece.world.length > 0) slot.drew = true;
+        extendBox(slot.box, piece.world);
+      }
+    }
+  }
   // ⚠️ Two different reasons a box is not finite, told apart here and nowhere
   // else (issue #873). A skeleton that posed no vertex at all has nothing to
   // draw, and that is `null`. One that posed a vertex at Infinity or NaN has a
@@ -2206,20 +2268,23 @@ export function framingViewport(source: PoseSource, maxSide: number, opts?: Pose
   // this, the first case's `null` covered both, and a single overflowing bone
   // among finite ones reached neither: its box was finite on one side, and
   // `render` wrote a NaN-by-NaN frame set with exit 0.
-  const drewAny = (frameSets: ReadonlyArray<readonly Frame[]>): boolean =>
-    frameSets.some((frames) => frames.some((frame) => frame.pieces.some((piece) => piece.world.length > 0)));
-  if (!drewAny(sets)) return null;
+  if (![...bySlot.values()].some((slot) => slot.drew)) return null;
   // ⭐ The box is over the slots that pose (issue #1000). A drawn slot on a bone
   // the skin leaves unposed is taken off — it draws no pixel — unless nothing
-  // else drew, in which case every set is kept whole so the pose reaches #997's
+  // else drew, in which case every slot is kept so the pose reaches #997's
   // refusal below exactly as it did before this: the same inputs, the same
   // sentence, never an empty box framed to something.
   const roster = rosterBehind(source, rosterGiven);
   const offBox = slotsOnUnposedBones(poser.slots, framed.skin, roster);
-  const posedSets =
-    offBox.size === 0 ? sets : sets.map((frames) => frames.map((frame) => ({ ...frame, pieces: frame.pieces.filter((piece) => !offBox.has(piece.slot)) })));
-  const boxed = drewAny(posedSets) ? posedSets : sets;
-  const box = unionBounds(boxed);
+  const posed = [...bySlot].filter(([name]) => !offBox.has(name));
+  const posedOnly = posed.some(([, slot]) => slot.drew);
+  const box: FramingBox = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+  for (const [, slot] of posedOnly ? posed : [...bySlot]) {
+    box.minX = Math.min(box.minX, slot.box.minX);
+    box.maxX = Math.max(box.maxX, slot.box.maxX);
+    box.minY = Math.min(box.minY, slot.box.minY);
+    box.maxY = Math.max(box.maxY, slot.box.maxY);
+  }
   if (![box.minX, box.minY, box.maxX, box.maxY].every(Number.isFinite)) {
     const found = nonFinitePoseOf(
       poser,
@@ -2241,8 +2306,14 @@ export function framingViewport(source: PoseSource, maxSide: number, opts?: Pose
   // A finite box over one point (issue #997): every drawn slot on a bone the
   // skin leaves unposed, or every vertex collapsed. Framed, it is a scale of
   // Infinity and a frame of NaN by NaN pixels, written as 0x0 with exit 0.
-  const unframeable = unframeableSentence(boxed, poser.slots, framed.skin, roster);
-  if (unframeable !== null) throw new UnframeablePoseError(unframeable);
+  // Only a box with no extent can be refused, and only then are the frames
+  // sampled again to be read whole — by the sentence's one derivation.
+  if (box.maxX - box.minX === 0 && box.maxY - box.minY === 0) {
+    const whole = animations.map(sample);
+    const boxed = posedOnly ? whole.map((frames) => frames.map((frame) => ({ ...frame, pieces: frame.pieces.filter((piece) => !offBox.has(piece.slot)) }))) : whole;
+    const unframeable = unframeableSentence(boxed, poser.slots, framed.skin, roster);
+    if (unframeable !== null) throw new UnframeablePoseError(unframeable);
+  }
   const pad = Math.max(box.maxX - box.minX, box.maxY - box.minY) * PAD;
   return viewportFor(box.minX - pad, box.minY - pad, box.maxX + pad, box.maxY + pad, maxSide);
 }