spine-rigc 2.13.1 → 2.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.13.1",
+  "version": "2.13.3",
   "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/core/raw.ts

@@ -350,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
@@ -366,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);
@@ -377,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') {
@@ -387,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];
@@ -414,9 +435,8 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
     // 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/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);
 }