spine-rigc 1.5.3 → 1.6.2

package/src/render.ts

@@ -78,7 +78,10 @@
  *
  * ⚠️ Two notes on where this sits. It imports `spine-core`, which `src/` is
  * otherwise careful about: posing a skeleton *is* running the runtime, and there
- * is no honest way to render one without it. The rule that matters is unchanged
+ * is no honest way to render one without it. (Since issue #968 that holds for a
+ * Spine export: a rigc build is posed by rigc's own core through
+ * `./render_core.ts`, and this file keeps the runtime for the export's poser,
+ * the atlas pages and texture substitution — see *which poser* below.) The rule that matters is unchanged
  * — `src/compile.ts` must stay independent of the runtime so the compiler and
  * the gate are not checking each other's assumptions — and this file is neither.
  * It also imports `tools/plate.ts` for the PNG codec, which is dependency-free.
@@ -96,13 +99,16 @@ import {
   SkeletonJson,
   TextureAtlas,
   TextureAtlasRegion,
-  type SkeletonData,
+  SkeletonData,
   type Slot,
 } from '@esotericsoftware/spine-core';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { Plate, readPlate, type RGBA } from '../tools/plate.ts';
 import { pageFootprint } from './atlas.ts';
+import { CoreInputError } from './core/index.ts';
+import { MODEL_DOCUMENT_FILE } from './model.ts';
+import { clipSourceOf, corePoser, inactiveBoneSnapshot, SlotSubsetError, subsetOver, unposedBones } from './render_core.ts';
 
 /** Opaque, and light: both of rung 3's parts are dark slate, so is every ground. */
 export const BACKGROUND: RGBA = [232, 232, 232, 255];
@@ -316,6 +322,12 @@ export interface PieceTexture {
   region: string;
   /** Original-art coordinates, `u, v` per vertex, parallel to `uvs`. */
   artUvs: number[];
+  /**
+   * A clipped piece only (`Mesh.source`): the original-art UVs of each drawn
+   * triangle's SOURCE triangle, six numbers per drawn triangle, parallel to
+   * `Mesh.source.uvs` — what `substituteTexture` re-seats the source map with.
+   */
+  sourceArtUvs?: number[];
 }
 
 /** A page-UV rectangle outside which a piece samples nothing. */
@@ -398,16 +410,10 @@ export interface PoseOptions {
 }
 
 /**
- * Why a slot subset cannot be drawn — a `--slot`/`--hide` naming no slot, a slot
- * whose art only another skin carries, or both flags at once (issue #835).
- *
- * A class of its own so `cli.ts` can turn it into a usage refusal (exit 2,
- * nothing written) without reading a message to decide what kind it is.
+ * Why a slot subset cannot be drawn — `./render_core.ts` declares it, so the
+ * spine-core poser and the core poser throw one class (issue #968).
  */
-export class SlotSubsetError extends Error {}
-
-/** The flag spelling each half of a subset is refused under — the UI's, since that is who reads it. */
-const SUBSET_FLAG = { slots: '--slot', hidden: '--hide' } as const;
+export { SlotSubsetError };
 
 /**
  * A slot subset resolved against a skeleton: which half was asked for, and the
@@ -449,45 +455,20 @@ export function slotSubsetOf(
   opts: Pick<PoseOptions, 'slots' | 'hidden'> | undefined,
   skin: string | undefined,
 ): SlotSubset | undefined {
-  if (opts?.slots !== undefined && opts.hidden !== undefined) {
-    throw new SlotSubsetError(
-      '--slot and --hide are one statement two ways; name the slots to draw or the slots to hide, not both',
-    );
-  }
-  const mode = opts?.slots !== undefined ? 'slots' : opts?.hidden !== undefined ? 'hidden' : undefined;
-  if (mode === undefined) return undefined;
-  const asked = (mode === 'slots' ? opts?.slots : opts?.hidden) ?? [];
-  const flag = SUBSET_FLAG[mode];
-  const declared = data.slots.map((slot) => slot.name);
-
-  const unknown = asked.filter((name) => data.findSlot(name) === null);
-  if (unknown.length > 0 || asked.length === 0) {
-    const named =
-      unknown.length === 0
-        ? 'was given no slot name'
-        : `${unknown.map((name) => JSON.stringify(name)).join(', ')} ${unknown.length === 1 ? 'names' : 'name'} no slot`;
-    throw new SlotSubsetError(
-      `${flag} ${named}; this skeleton declares, in draw order: ${declared.join(', ') || 'none'} (${declared.length})`,
-    );
-  }
-
-  const resolving = new Set([skin ?? null, data.defaultSkin?.name ?? null]);
-  const underThisPose =
-    skin === undefined ? 'under no skin (the default skin alone)' : `under skin ${JSON.stringify(skin)}`;
-  for (const name of asked) {
-    const index = data.findSlot(name)?.index ?? -1;
-    const carriers = data.skins.filter((s) => s.getAttachments().some((entry) => entry.slotIndex === index));
-    if (carriers.length === 0 || carriers.some((s) => resolving.has(s.name))) continue;
-    const skins = carriers.map((s) => JSON.stringify(s.name));
-    throw new SlotSubsetError(
-      `${flag} ${JSON.stringify(name)} draws nothing ${underThisPose}: its attachments are declared only under ` +
-        `${skins.length === 1 ? 'skin' : 'skins'} ${skins.join(', ')} — pass --skin ${
-          skins.length === 1 ? skins[0] : 'with one of them'
-        }`,
-    );
-  }
-  const chosen = new Set(asked);
-  return { mode, names: declared.filter((name) => chosen.has(name)) };
+  // The rule is `subsetOver`'s (`./render_core.ts`), shared with the core
+  // poser; this is the roster a parsed Spine skeleton gives it.
+  return subsetOver(
+    {
+      declared: data.slots.map((slot) => slot.name),
+      carriers: (name) => {
+        const index = data.findSlot(name)?.index ?? -1;
+        return data.skins.filter((s) => s.getAttachments().some((entry) => entry.slotIndex === index)).map((s) => s.name);
+      },
+      defaultSkin: data.defaultSkin?.name ?? null,
+    },
+    opts,
+    skin,
+  );
 }
 
 /**
@@ -527,18 +508,6 @@ function skeletonUnderSkin(data: SkeletonData, skin: string | undefined): Skelet
   return skeleton;
 }
 
-/**
- * The same options with the skin taken off — what the samplers hand `piecesOf`.
- *
- * Spelled once, so the one function that must not see a `skin` cannot come to
- * see one because a second call site forgot.
- */
-function piecesOptions(opts: PoseOptions | undefined): PoseOptions | undefined {
-  if (opts === undefined || opts.skin === undefined) return opts;
-  const { skin: _applied, ...rest } = opts;
-  return rest;
-}
-
 /**
  * One bone's world transform in one posed frame.
  *
@@ -571,9 +540,17 @@ export interface BoneSnapshot {
   scaleY: number;
 }
 
-/** Every bone's world transform in the skeleton's own declaration order. */
+/**
+ * Every bone's world transform in the skeleton's own declaration order — a bone
+ * the posed skin leaves unposed (inactive, or below an inactive bone) written as the zero transform
+ * (`inactiveBoneSnapshot` in `./render_core.ts`: it is not posed, and what a
+ * constraint left in its matrix is not a pose — issue #968).
+ */
 export function boneSnapshots(skeleton: Skeleton): BoneSnapshot[] {
+  const unposed = unposedBones(skeleton.bones.map((bone) => ({ name: bone.data.name, parent: bone.parent?.data.name ?? null, active: bone.active })));
   return skeleton.bones.map((bone) => {
+    // Not posed under this skin: the seam's zero snapshot (`inactiveBoneSnapshot`, issue #968).
+    if (unposed.has(bone.data.name)) return inactiveBoneSnapshot(bone.data.name);
     const pose = bone.appliedPose;
     return {
       name: bone.data.name,
@@ -614,6 +591,23 @@ export interface Mesh extends PieceCommon {
   uvs: ArrayLike<number>;
   /** Vertex index triplets. */
   triangles: ArrayLike<number>;
+  /**
+   * A piece a clip cut only: for each drawn triangle, in triangle order, the
+   * SOURCE triangle it was cut from — its three world corners and their page
+   * UVs, six numbers each per drawn triangle (`ClipSource`). The rasteriser
+   * samples such a triangle's pixels at the source triangle's affine UV map,
+   * so the picture does not depend on which convex pieces the clipper cut
+   * (issue #964). Absent on every piece no clip cut, whose path is unchanged.
+   */
+  source?: ClipSource;
+}
+
+/** The source triangles of a clipped piece's drawn triangles — see `Mesh.source`. */
+export interface ClipSource {
+  /** Three world corners (`x, y` each) per drawn triangle. */
+  world: number[];
+  /** The page UVs of those corners, parallel to `world`. */
+  uvs: number[];
 }
 
 /** One drawable in a posed frame. */
@@ -740,50 +734,134 @@ export function posableFromText(skeletonText: string, atlasText: string, atlasDi
   return { data, pages };
 }
 
+// ---------------------------------------------------------------------------
+// the posing seam (issue #965, step 3a of #380)
+// ---------------------------------------------------------------------------
+//
+// ⭐ Everything this file reads off a posed skeleton goes through one
+// interface, `Poser`, and the samplers below are written against it alone. The
+// implementation behind it today is spine-core's (`spinePoser`, further down);
+// the core-backed poser of issue #968 is a SECOND implementation of the same
+// interface, handed to the same samplers, rather than a rewrite of them. What
+// the interface fixes is exactly what a consumer of a posed frame reads:
+//
+// - the setup pose, under a skin or under none;
+// - an animation's frames at `i/fps` for `i = 0..count`, one continuous
+//   trajectory stepped once per frame (the stepping recipe is the
+//   implementation's; the schedule — which `i`, what `count`, what time a
+//   frame is filed under — is the sampler's, and stays here);
+// - per posed frame: the pieces in draw order (world vertices, page UVs,
+//   triangles, tint, dark, page, clip output), the bone snapshots, and every
+//   slot's whole attachment geometry;
+// - the rest table, and the names a geometry file and a slot subset read.
+//
+// The framing samples are not a fourth entry: `framingViewport` is the same
+// animation entry at `FRAMING_FPS` with the clip off.
+//
+// 🔒 What stays spine-core's and outside the seam, deliberately: the atlas
+// (`posableFromText`'s pages, `substituteTexture`'s region lookup — step 3c of
+// #380) and `nonFiniteOfPosed`, which `validate.ts` calls on a spine-core
+// skeleton it stepped itself (A10), so the round trip keeps its spine-core
+// entry whatever poses the renders.
+
+/** What a sampler hands a posed frame's draw walk — `PoseOptions` with the subset already resolved. */
+export interface DrawOptions {
+  /** The slots drawn, resolved against the posed skeleton (`slotSubsetOf`); `undefined` draws every slot. */
+  subset: SlotSubset | undefined;
+  /** Every attachment whole, no clip applied — the framing box's reading. */
+  unclipped: boolean;
+  /** Also record each piece's original-art UVs — see `PieceTexture`. */
+  texture: boolean;
+}
+
+/**
+ * One posed moment, readable only while the `Poser` call that produced it is
+ * running: an implementation may step one skeleton in place, so a reader takes
+ * what it needs before the next frame is posed.
+ */
+export interface Posed {
+  /** The drawables in draw order — see `piecesOf` for the walk and the clip. */
+  pieces(draw: DrawOptions): Piece[];
+  /** Every bone's world transform, in the skeleton's declaration order. */
+  bones(): BoneSnapshot[];
+  /** Every slot's region or mesh attachment, whole, in the posed draw order. */
+  attachments(): AttachmentPose[];
+}
+
+/**
+ * The posing seam: one skeleton, posed on demand.
+ *
+ * Named for what it does rather than for the runtime behind it, because the
+ * point of the name is that there are two: `spinePoser` today, the core's at
+ * #968. Every sampler, the framing, the geometry export and the non-finite
+ * sentence take one (or a `SkeletonData`, which they wrap in `spinePoser`).
+ */
+export interface Poser {
+  /** Every animation, in declaration order, with its duration in seconds. */
+  readonly animations: ReadonlyArray<{ name: string; duration: number }>;
+  /** Every bone in declaration order, and its parent's name. */
+  readonly bones: ReadonlyArray<{ name: string; parent: string | null }>;
+  /** Every slot in declaration order, and the bone it hangs from. */
+  readonly slots: ReadonlyArray<{ name: string; bone: string }>;
+  /** `slotSubsetOf` against this skeleton posed under `skin` — refused by `SlotSubsetError`. */
+  subset(opts: Pick<PoseOptions, 'slots' | 'hidden'> | undefined, skin: string | undefined): SlotSubset | undefined;
+  /** The setup pose under `skin` (absent: no skin set at all). */
+  setup(skin: string | undefined): Posed;
+  /**
+   * Animation `name` under `skin`, not looping: `visit(i, posed)` for every
+   * `i` from 0 to `count`, the pose at `i/fps`. The caller has checked `name`.
+   */
+  animation(name: string, skin: string | undefined, fps: number, count: number, visit: (index: number, posed: Posed) => void): void;
+  /** The rest table for the (slot, attachment) pairs `shown` holds — see `AttachmentRest`. */
+  rest(skin: string | undefined, shown: readonly AttachmentPose[][]): AttachmentRest[];
+}
+
+/** What every sampler takes: a poser, or spine-core's parsed skeleton, which is posed through `spinePoser`. */
+export type PoseSource = Poser | SkeletonData;
+
+function poserOf(source: PoseSource): Poser {
+  return source instanceof SkeletonData ? spinePoser(source) : source;
+}
+
+/** A sampler's `PoseOptions` as a draw walk reads them, the subset resolved once, on the first frame posed. */
+function drawResolver(poser: Poser, opts: PoseOptions | undefined): () => DrawOptions {
+  let draw: DrawOptions | undefined;
+  return () => {
+    draw ??= { subset: poser.subset(opts, opts?.skin), unclipped: opts?.unclipped === true, texture: opts?.texture === true };
+    return draw;
+  };
+}
+
+/** One frame off one posed moment, with what `opts` asked to record beside the pieces. */
+function frameOf(index: number, time: number, posed: Posed, draw: DrawOptions, opts: PoseOptions | undefined): Frame {
+  return {
+    index,
+    time,
+    pieces: posed.pieces(draw),
+    ...(opts?.bones ? { bones: posed.bones() } : {}),
+    ...(opts?.geometry ? { attachments: posed.attachments() } : {}),
+  };
+}
+
 /**
  * Sample one animation at a fixed rate and collect the posed pieces per frame.
  *
- * The pose is driven through `AnimationState` rather than `Animation.apply`
- * because that is the path a runtime actually takes, and 4.3's `Animation.apply`
- * takes a `MixFrom` that only the state machine has any business choosing.
+ * Frame `i` is the pose at `i/fps`, for `i = 0..round(duration·fps)` — the
+ * schedule is this function's; how a pose reaches `i/fps` is the poser's.
  */
-export function sampleAnimation(data: SkeletonData, name: string, fps: number, opts?: PoseOptions): Frame[] {
-  const animation = data.findAnimation(name);
+export function sampleAnimation(source: PoseSource, name: string, fps: number, opts?: PoseOptions): Frame[] {
+  const poser = poserOf(source);
+  const animation = poser.animations.find((a) => a.name === name);
   if (!animation) {
     throw new Error(
-      `no animation "${name}" in this skeleton; it has [${data.animations.map((a) => a.name).join(', ') || 'none'}]`,
+      `no animation "${name}" in this skeleton; it has [${poser.animations.map((a) => a.name).join(', ') || 'none'}]`,
     );
   }
-  const skeleton = skeletonUnderSkin(data, opts?.skin);
-  const pieceOpts = piecesOptions(opts);
-  const state = new AnimationState(new AnimationStateData(data));
-  // Not looping: the last frame sits at the animation's duration, and a looping
-  // entry would wrap it back onto the first pose.
-  state.setAnimation(0, name, false);
-  skeleton.setupPose();
-
   const step = 1 / fps;
   const count = Math.round(animation.duration * fps);
+  const draw = drawResolver(poser, opts);
   const frames: Frame[] = [];
-  for (let i = 0; i <= count; i++) {
-    if (i > 0) {
-      state.update(step);
-      state.apply(skeleton);
-      skeleton.update(step);
-      skeleton.updateWorldTransform(Physics.update);
-    } else {
-      state.apply(skeleton);
-      skeleton.update(0);
-      skeleton.updateWorldTransform(Physics.reset);
-    }
-    frames.push({
-      index: i,
-      time: i * step,
-      pieces: piecesOf(skeleton, pieceOpts),
-      ...(opts?.bones ? { bones: boneSnapshots(skeleton) } : {}),
-      ...(opts?.geometry ? { attachments: attachmentsOf(skeleton) } : {}),
-    });
-  }
+  poser.animation(name, opts?.skin, fps, count, (i, posed) => frames.push(frameOf(i, i * step, posed, draw(), opts)));
   return frames;
 }
 
@@ -795,17 +873,69 @@ export function sampleAnimation(data: SkeletonData, name: string, fps: number, o
  * ladder's first rung ships one (`1-weight-and-mass`'s second export), and its
  * whole content is the setup pose.
  */
-export function sampleSetupPose(data: SkeletonData, opts?: PoseOptions): Frame[] {
-  const skeleton = setupPosed(data, opts?.skin);
-  return [
-    {
-      index: 0,
-      time: 0,
-      pieces: piecesOf(skeleton, piecesOptions(opts)),
-      ...(opts?.bones ? { bones: boneSnapshots(skeleton) } : {}),
-      ...(opts?.geometry ? { attachments: attachmentsOf(skeleton) } : {}),
+export function sampleSetupPose(source: PoseSource, opts?: PoseOptions): Frame[] {
+  const poser = poserOf(source);
+  const posed = poser.setup(opts?.skin);
+  return [frameOf(0, 0, posed, drawResolver(poser, opts)(), opts)];
+}
+
+// ---------------------------------------------------------------------------
+// the spine-core implementation of the seam
+// ---------------------------------------------------------------------------
+
+/**
+ * `Poser` over spine-core: the runtime's own `Skeleton`, `AnimationState` and
+ * `SkeletonClipping`, stepped the way a runtime steps them.
+ *
+ * The pose is driven through `AnimationState` rather than `Animation.apply`
+ * because that is the path a runtime actually takes, and 4.3's
+ * `Animation.apply` takes a `MixFrom` that only the state machine has any
+ * business choosing. Frame 0 applies, updates by 0 and resets physics; every
+ * later frame is one `state.update(1/fps)`, apply, `skeleton.update(1/fps)` and
+ * `Physics.update` — one continuous trajectory, so the track time of frame `i`
+ * is the sum of `i` steps.
+ */
+export function spinePoser(data: SkeletonData): Poser {
+  return {
+    animations: data.animations.map((a) => ({ name: a.name, duration: a.duration })),
+    bones: data.bones.map((bone) => ({ name: bone.name, parent: bone.parent?.name ?? null })),
+    slots: data.slots.map((slot) => ({ name: slot.name, bone: slot.boneData.name })),
+    subset: (opts, skin) => slotSubsetOf(data, opts, skin),
+    setup: (skin) => spinePosed(setupPosed(data, skin)),
+    animation: (name, skin, fps, count, visit) => {
+      const skeleton = skeletonUnderSkin(data, skin);
+      const state = new AnimationState(new AnimationStateData(data));
+      // Not looping: the last frame sits at the animation's duration, and a looping
+      // entry would wrap it back onto the first pose.
+      state.setAnimation(0, name, false);
+      skeleton.setupPose();
+      const step = 1 / fps;
+      const posed = spinePosed(skeleton);
+      for (let i = 0; i <= count; i++) {
+        if (i > 0) {
+          state.update(step);
+          state.apply(skeleton);
+          skeleton.update(step);
+          skeleton.updateWorldTransform(Physics.update);
+        } else {
+          state.apply(skeleton);
+          skeleton.update(0);
+          skeleton.updateWorldTransform(Physics.reset);
+        }
+        visit(i, posed);
+      }
     },
-  ];
+    rest: (skin, shown) => restOf(data, skin, shown),
+  };
+}
+
+/** A spine-core skeleton as it stands posed, read through the seam's `Posed`. */
+function spinePosed(skeleton: Skeleton): Posed {
+  return {
+    pieces: (draw) => drawPieces(skeleton, draw),
+    bones: () => boneSnapshots(skeleton),
+    attachments: () => attachmentsOf(skeleton),
+  };
 }
 
 /**
@@ -826,13 +956,135 @@ function setupPosed(data: SkeletonData, skin: string | undefined): Skeleton {
  * filed under. A skeleton with no animation at all contributes its setup pose
  * under `SETUP_POSE_DIR`.
  */
-export function sampleAll(data: SkeletonData, fps: number, opts?: PoseOptions): Map<string, Frame[]> {
+export function sampleAll(source: PoseSource, fps: number, opts?: PoseOptions): Map<string, Frame[]> {
+  const poser = poserOf(source);
   const out = new Map<string, Frame[]>();
-  if (data.animations.length === 0) out.set(SETUP_POSE_DIR, sampleSetupPose(data, opts));
-  else for (const animation of data.animations) out.set(animation.name, sampleAnimation(data, animation.name, fps, opts));
+  if (poser.animations.length === 0) out.set(SETUP_POSE_DIR, sampleSetupPose(poser, opts));
+  else for (const animation of poser.animations) out.set(animation.name, sampleAnimation(poser, animation.name, fps, opts));
   return out;
 }
 
+// ---------------------------------------------------------------------------
+// which poser a render poses through (issue #968, step 3d of #380)
+// ---------------------------------------------------------------------------
+//
+// ⭐ Two implementations of the seam, chosen by what the input carries and
+// never guessed: a rigc build writes `skeleton.model.json` beside the Spine
+// pair, and that document is what the core poses (`./render_core.ts`); a
+// Spine export (`bench/reference/*`, `examples/*/export/*`) has none and
+// poses through spine-core. The choice, and the reason for it, is returned
+// beside the result so the caller can say it (`render` prints it as its
+// `poser` line) — a render that fell back without saying so would be a
+// second opinion about the pose that nobody could see.
+
+/** Which implementation of the seam posed a render: rigc's own core, or spine-core. */
+export type PoserName = 'core' | 'spine';
+
+/** The `--poser` spellings, in the order the usage lists them. */
+export const POSER_NAMES: readonly PoserName[] = ['core', 'spine'];
+
+/**
+ * A `--poser` the input cannot carry — `--poser core` on a Spine export, or on
+ * a build whose document the core refuses. A class of its own so `cli.ts`
+ * refuses it as a usage error (exit 2, nothing written).
+ */
+export class PoserChoiceError extends Error {}
+
+/** Both posers for one input, and why the core one is or is not there. */
+export interface PoserChoice {
+  /** What `--poser` asked for, or `undefined` for the input's own choice. */
+  forced: PoserName | undefined;
+  /** The core poser, or `null` when the input cannot carry it (`why`). */
+  core: Poser | null;
+  /** For a core poser, the document it poses; otherwise why there is none. */
+  why: string;
+  spine: Poser;
+}
+
+/**
+ * The first way a model document's rosters differ from the Spine skeleton they
+ * sit beside, or `null` — a document from another build would pose another
+ * rig in the same files' name, so it is refused rather than drawn.
+ */
+function rosterDifference(core: Poser, data: SkeletonData): string | null {
+  const bones = (list: ReadonlyArray<{ name: string; parent: string | null }>): string => list.map((b) => `${b.name}<${b.parent ?? ''}`).join('|');
+  const slots = (list: ReadonlyArray<{ name: string; bone: string }>): string => list.map((x) => `${x.name}@${x.bone}`).join('|');
+  const spine = spinePoser(data);
+  if (bones(core.bones) !== bones(spine.bones)) return 'the bones (names, parents or order) differ';
+  if (slots(core.slots) !== slots(spine.slots)) return 'the slots (names, bones or draw order) differ';
+  const animations = (list: ReadonlyArray<{ name: string; duration: number }>): string =>
+    list.map((a) => `${a.name}=${a.duration}`).sort().join('|');
+  if (animations(core.animations) !== animations(spine.animations)) return 'the animations (names or durations) differ';
+  return null;
+}
+
+/**
+ * Both posers for the skeleton at `skeletonPath` drawn through the atlas at
+ * `atlasPath` — the core one when `skeleton.model.json` sits beside the
+ * skeleton, the skeleton's bytes hash to the digest the document records
+ * (`spine.sha256`: it is the file that build wrote, not one edited after it),
+ * the atlas is the one beside it too, the core reads both and the document's
+ * rosters are the skeleton's. `forced` is `--poser`; `core` on an
+ * input that cannot carry it is refused by name (`PoserChoiceError`).
+ */
+export function candidatePosers(
+  data: SkeletonData,
+  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. */
+  make: (modelText: string, atlasText: string, where: string, skeleton: { path: string; bytes: Uint8Array }) => Poser = corePoser,
+): PoserChoice {
+  const spine = spinePoser(data);
+  const dir = dirname(resolve(skeletonPath));
+  const modelPath = join(dir, MODEL_DOCUMENT_FILE);
+  let core: Poser | null = null;
+  let why: string;
+  if (forced === 'spine') why = '--poser spine';
+  else if (!existsSync(modelPath)) why = `no ${MODEL_DOCUMENT_FILE} beside ${resolve(skeletonPath)} — a Spine export, not a rigc build`;
+  else if (dirname(resolve(atlasPath)) !== dir) {
+    why =
+      `the atlas ${resolve(atlasPath)} is not beside ${modelPath}: the document's region trims are its own build's ` +
+      "atlas's, and the core would pose them against another one's pages";
+  } else {
+    try {
+      const candidate = make(readFileSync(modelPath, 'utf8'), readFileSync(atlasPath, 'utf8'), modelPath, { path: resolve(skeletonPath), bytes: readFileSync(skeletonPath) });
+      const differs = rosterDifference(candidate, data);
+      if (differs === null) {
+        core = candidate;
+        why = modelPath;
+      } else why = `${modelPath} does not describe ${resolve(skeletonPath)}: ${differs}`;
+    } catch (err) {
+      if (!(err instanceof CoreInputError)) throw err;
+      // The reader names the document itself (`readModel`'s `where`), so a message that already starts with its path is not given it twice.
+      why = `the core refused ${err.message.startsWith(`${modelPath}: `) ? err.message : `${modelPath}: ${err.message}`}`;
+    }
+  }
+  if (forced === 'core' && core === null) throw new PoserChoiceError(`--poser core: ${why}`);
+  return { forced, core, why, spine };
+}
+
+/**
+ * `run` through the chosen poser: the core one when there is one, and
+ * spine-core otherwise — or when the core refuses the input partway
+ * (`CoreInputError`, e.g. a clip polygon that is not simple), in
+ * which case `run` starts again from nothing on spine-core and `note` names the
+ * refusal. Under `--poser core` that refusal is a `PoserChoiceError` instead.
+ * `run` must write nothing: a fallback re-runs it whole.
+ */
+export function throughPoser<T>(choice: PoserChoice, run: (poser: Poser) => T): { value: T; poser: PoserName; note: string } {
+  if (choice.core !== null) {
+    try {
+      return { value: run(choice.core), poser: 'core', note: `rigc core — ${choice.why}` };
+    } catch (err) {
+      if (!(err instanceof CoreInputError)) throw err;
+      if (choice.forced === 'core') throw new PoserChoiceError(`--poser core: the core refused this input: ${err.message}`);
+      return { value: run(choice.spine), poser: 'spine', note: `spine-core — the core refused this input: ${err.message}` };
+    }
+  }
+  return { value: run(choice.spine), poser: 'spine', note: `spine-core — ${choice.why}` };
+}
+
 /**
  * The posed drawables of one frame, in draw order.
  *
@@ -868,6 +1120,17 @@ export function sampleAll(data: SkeletonData, fps: number, opts?: PoseOptions):
  * list — and one wholly outside becomes a mesh with no triangle, which keeps the
  * slot in the frame, undrawn, rather than absent.
  *
+ * ⭐ A cut piece's pixels are sampled at each drawn triangle's SOURCE triangle's
+ * affine UV (`Mesh.source`), not at its own float32 corner UVs (issue #964):
+ * which convex pieces a clipper cuts a concave polygon into is the clipper's —
+ * spine-core's, the core's, or spine-core's under another spelling of the same
+ * polygon — and only this keeps the picture from depending on it. Measured: the
+ * same notched square spelled from four start vertices moved up to 18 pixels one
+ * level against itself through spine-core before, 0 after; the 19 tree rows'
+ * renders did not move (spineboy-pro's portal, the one clipped row, included).
+ * An unclipped piece carries no `source` and is rasterised as before, byte for
+ * byte.
+ *
  * The clip is applied whatever `slots`/`hidden` draw: a hidden clip still masks
  * what is shown, so a subset frame is the whole frame's pixels for those slots.
  * `unclipped` turns it off for the framing box alone — see its note.
@@ -888,8 +1151,14 @@ export function piecesOf(skeleton: Skeleton, opts?: PoseOptions): Piece[] {
   // it was set to — so a name that draws nothing is refused here, where the one
   // application point is, rather than matching no piece in silence.
   const subset = slotSubsetOf(skeleton.data, opts, skeleton.skin?.name);
+  return drawPieces(skeleton, { subset, unclipped: opts?.unclipped === true, texture: opts?.texture === true });
+}
+
+/** `piecesOf`'s walk over a posed spine-core skeleton, the subset already resolved — the spine poser's `Posed.pieces`. */
+function drawPieces(skeleton: Skeleton, draw: DrawOptions): Piece[] {
+  const { subset } = draw;
   const named = subset === undefined ? undefined : new Set(subset.names);
-  const clipper = opts?.unclipped === true ? null : new SkeletonClipping();
+  const clipper = draw.unclipped ? null : new SkeletonClipping();
   const pieces: Piece[] = [];
   for (const slot of skeleton.drawOrder.appliedPose) {
     const attachment = slot.appliedPose.attachment;
@@ -903,7 +1172,7 @@ export function piecesOf(skeleton: Skeleton, opts?: PoseOptions): Piece[] {
       continue;
     }
     const drawn = subset === undefined || named === undefined || named.has(slot.data.name) === (subset.mode === 'slots');
-    const piece = drawn ? pieceOf(skeleton, slot, opts, clipper) : null;
+    const piece = drawn ? pieceOf(skeleton, slot, draw.texture, clipper) : null;
     if (piece !== null) pieces.push(piece);
     clipper?.clipEnd(slot);
   }
@@ -921,7 +1190,7 @@ const QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
 function pieceOf(
   skeleton: Skeleton,
   slot: Slot,
-  opts: PoseOptions | undefined,
+  withTexture: boolean,
   clipper: SkeletonClipping | null,
 ): Piece | null {
   const pose = slot.appliedPose;
@@ -946,7 +1215,7 @@ function pieceOf(
   const dark: [number, number, number] | undefined =
     darkPose === null ? undefined : [darkPose.r, darkPose.g, darkPose.b];
   const common = { tint, dark, slot: slot.data.name, page: region.page.name };
-  const texture = opts?.texture !== true ? undefined : artUvsOf(attachment, region);
+  const texture = withTexture ? artUvsOf(attachment, region) : undefined;
   const uvs = attachment.sequence.getUVs(index);
 
   let piece: Piece;
@@ -1032,7 +1301,20 @@ function clippedPiece(piece: Piece, triangles: number[], uvs: Float32Array, clip
   const world = Array.from(clipper.clippedVerticesTyped);
   const clippedUvs = Array.from(clipper.clippedUVsTyped);
   const clipped = Array.from(clipper.clippedTrianglesTyped);
+  // Which source triangle each drawn triangle was cut from (`Mesh.source`): the clipper cuts triangle by triangle, so each source
+  // triangle is clipped alone and its drawn triangles counted; the concatenation is held to the whole call's output, vertex for vertex.
+  const sources: number[] = [];
+  const again: number[] = [];
+  for (let t = 0; t + 2 < triangles.length; t += 3) {
+    clipper.clipTrianglesUnpacked(piece.world, 0, triangles.slice(t, t + 3), 3, uvs, 2);
+    for (let k = 0; k < clipper.clippedTrianglesTyped.length; k += 3) sources.push(t / 3);
+    again.push(...clipper.clippedVerticesTyped);
+  }
+  if (sources.length !== clipped.length / 3 || again.length !== world.length || again.some((v, i) => v !== world[i])) {
+    throw new Error(`slot "${piece.slot}": the clipper cut ${clipped.length / 3} triangle(s) in one call and ${sources.length} triangle by triangle, over other vertices — the source of each drawn triangle cannot be named`);
+  }
   let texture = piece.texture;
+  const source = clipSourceOf(piece.world, Array.from(uvs), triangles, sources, texture?.artUvs);
   if (texture !== undefined) {
     clipper.clipTrianglesUnpacked(piece.world, 0, triangles, triangles.length, texture.artUvs, 2);
     const artUvs = Array.from(clipper.clippedUVsTyped);
@@ -1042,10 +1324,10 @@ function clippedPiece(piece: Piece, triangles: number[], uvs: Float32Array, clip
           `${artUvs.length / 2} for the original-art UVs over the same geometry`,
       );
     }
-    texture = { region: texture.region, artUvs };
+    texture = { region: texture.region, artUvs, sourceArtUvs: source.artUvs };
   }
   const { tint, dark, slot, page } = piece;
-  return { kind: 'mesh', tint, dark, slot, page, texture, world, uvs: clippedUvs, triangles: clipped };
+  return { kind: 'mesh', tint, dark, slot, page, texture, world, uvs: clippedUvs, triangles: clipped, source: { world: source.world, uvs: source.uvs } };
 }
 
 // ---------------------------------------------------------------------------
@@ -1166,7 +1448,7 @@ export function sidecarViewport(v: Viewport): FramesSidecar['viewport'] {
  * vertex (or the bone), when any number in it is not finite.
  */
 export function geometryFileOf(
-  data: SkeletonData,
+  source: PoseSource,
   animation: string | null,
   fps: number,
   frames: Frame[],
@@ -1187,7 +1469,8 @@ export function geometryFileOf(
     time: frame.time,
     ...geometryFrame(frame, `frame ${frame.index}`),
   }));
-  const setupFrame = sampleSetupPose(data, { ...(skin === undefined ? {} : { skin }), bones: true, geometry: true })[0];
+  const poser = poserOf(source);
+  const setupFrame = sampleSetupPose(poser, { ...(skin === undefined ? {} : { skin }), bones: true, geometry: true })[0];
   const setup = geometryFrame(setupFrame, 'the setup pose');
   const file: GeometryFile = {
     spec: GEOMETRY_SPEC,
@@ -1196,9 +1479,9 @@ export function geometryFileOf(
     ...(skin === undefined ? {} : { skin }),
     fps,
     viewport: sidecarViewport(viewport),
-    bones: data.bones.map((bone) => ({ name: bone.name, parent: bone.parent?.name ?? null })),
-    slots: data.slots.map((slot) => ({ name: slot.name, bone: slot.boneData.name })),
-    rest: restOf(data, skin, [setup.attachments, ...posed.map((frame) => frame.attachments)]),
+    bones: poser.bones.map(({ name, parent }) => ({ name, parent })),
+    slots: poser.slots.map(({ name, bone }) => ({ name, bone })),
+    rest: poser.rest(skin, [setup.attachments, ...posed.map((frame) => frame.attachments)]),
     setup,
     frames: posed,
   };
@@ -1215,7 +1498,7 @@ export function geometryFileOf(
  * frames drew. A region's rest corners are read for the sequence frame the setup
  * pose resolves, which is the frame its setup pose draws.
  */
-function restOf(data: SkeletonData, skin: string | undefined, shown: AttachmentPose[][]): AttachmentRest[] {
+function restOf(data: SkeletonData, skin: string | undefined, shown: readonly AttachmentPose[][]): AttachmentRest[] {
   const skeleton = setupPosed(data, skin);
   // Slot, then attachment: two maps rather than one joined key, so no pair of
   // names can fold into another's entry whatever characters they carry.
@@ -1384,10 +1667,11 @@ function refuseNonFinite(file: GeometryFile): void {
  * pays for it.
  */
 export function nonFinitePoseOf(
-  data: SkeletonData,
+  source: PoseSource,
   skin: string | undefined,
   sets: ReadonlyArray<{ animation: string | null; fps: number }>,
 ): string | null {
+  const poser = poserOf(source);
   const opts: PoseOptions = { ...(skin === undefined ? {} : { skin }), bones: true, geometry: true };
   // Every attachment list the frames showed, for the rest table's roster.
   const shown: AttachmentPose[][] = [];
@@ -1398,11 +1682,11 @@ export function nonFinitePoseOf(
     shown.push(frame.attachments);
     return { where, attachments: frame.attachments, bones: frame.bones };
   };
-  const setup = named(sampleSetupPose(data, opts)[0], 'the setup pose');
+  const setup = named(sampleSetupPose(poser, opts)[0], 'the setup pose');
   const frames = sets.flatMap(({ animation, fps }) =>
     animation === null
       ? []
-      : sampleAnimation(data, animation, fps, opts).map((frame) =>
+      : sampleAnimation(poser, animation, fps, opts).map((frame) =>
           named(frame, frameWhere(animation, frame.index, frame.time, fps)),
         ),
   );
@@ -1410,7 +1694,7 @@ export function nonFinitePoseOf(
   // what they show, and would be posing the same overflow a third time.
   const found = nonFiniteSentence(setup, frames, []);
   if (found !== null) return found;
-  return nonFiniteSentence({ attachments: [], bones: [] }, [], restOf(data, skin, shown));
+  return nonFiniteSentence({ attachments: [], bones: [] }, [], poser.rest(skin, shown));
 }
 
 /**
@@ -1640,6 +1924,14 @@ export function substituteTexture(
     // handled. Calling it rather than repeating it is what keeps this from being
     // a second opinion about the atlas format.
     MeshAttachment.computeUVs(region, texture.artUvs, uvs);
+    // A clipped piece's source map is re-seated the same way, through the drawing's own coordinates (`Mesh.source`).
+    if (piece.kind === 'mesh' && piece.source !== undefined) {
+      if (texture.sourceArtUvs === undefined) throw new Error(`slot "${piece.slot}": a clipped piece carries no original-art UVs for its source triangles`);
+      const sourceUvs = new Array<number>(texture.sourceArtUvs.length).fill(0);
+      MeshAttachment.computeUVs(region, texture.sourceArtUvs, sourceUvs);
+      pieces.push({ ...piece, page: SUBSTITUTE_PAGE + region.page.name, uvs, uvWindow: windowOf(region), source: { world: piece.source.world, uvs: sourceUvs } });
+      continue;
+    }
     pieces.push({ ...piece, page: SUBSTITUTE_PAGE + region.page.name, uvs, uvWindow: windowOf(region) });
   }
   return { frame: { ...frame, pieces }, unmatched };
@@ -1818,6 +2110,157 @@ export function trimmedUnionBounds(
   return { minX, minY, maxX, maxY };
 }
 
+/**
+ * A pose that drew vertices and cannot be framed, because every one of them sits
+ * at one point (issue #997) — refused by the slots that drew, the bone each hangs
+ * from and, where those bones are unposed, the skins that would pose them.
+ *
+ * A `GeometryError`, because it is the same family as the non-finite pose of
+ * #873: a picture that has no size is as unwritable as a vertex at Infinity. It
+ * is a class of its own because the reader's next step is different — there the
+ * rig posed a number no picture can hold, here the invocation posed the rig under
+ * a skin that leaves every drawn bone without a world transform, and `--skin` is
+ * usually the whole fix — so `cli.ts` exits 2 on it, as it does on the other
+ * framing refusal, *nothing to draw*.
+ *
+ * Before it the framing answered a viewport over the one point: `maxSide / 0` is
+ * Infinity, `0 · Infinity` is NaN, and `render` wrote a 0×0 frame set with exit
+ * 0, its summary saying `NaNxNaNpx` and `frames.json` a viewport of width 0 and
+ * scale `null`.
+ */
+export class UnframeablePoseError extends GeometryError {}
+
+/**
+ * Which bones a skin leaves unposed, and which skins there are — the rig
+ * structure the unframeable sentence names a skin from (issue #997). Not a
+ * poser's: the `Poser` seam carries no skin roster, and both posers pose the one
+ * Spine file this is read from (the core's document is bound to it by hash).
+ */
+export interface SkinRoster {
+  /** Every skin, in declaration order. */
+  readonly skins: readonly string[];
+  /** The bones left unposed under `skin` (absent: no skin set) — inactive, or below an inactive bone. */
+  unposedUnder(skin: string | undefined): Set<string>;
+}
+
+/**
+ * The skin roster of a parsed Spine file, as the runtime flags it —
+ * `unposedBones` over a fresh skeleton's `active` under each skin, so Spine's
+ * activation rule is the runtime's and is not restated here. Nothing is posed
+ * until a question is asked: the framing asks one (the skin it frames under,
+ * `slotsOnUnposedBones`) and the refusal asks one per skin.
+ */
+export function skinRosterOf(data: SkeletonData): SkinRoster {
+  return {
+    skins: data.skins.map((k) => k.name),
+    unposedUnder: (skin) => {
+      const skeleton = skeletonUnderSkin(data, skin);
+      return unposedBones(skeleton.bones.map((bone) => ({ name: bone.data.name, parent: bone.parent?.data.name ?? null, active: bone.active })));
+    },
+  };
+}
+
+/** The roster behind a pose source: its own when it is Spine data, else the one the caller passed. */
+function rosterBehind(source: PoseSource, roster: SkinRoster | undefined): SkinRoster | undefined {
+  return source instanceof SkeletonData ? skinRosterOf(source) : roster;
+}
+
+/**
+ * ⭐ **The one derivation of "a drawn slot on an unposed bone"** (issues #997,
+ * #1000): the names of the slots of `slots` whose bone `roster` says `skin`
+ * leaves unposed — inactive itself, or below an inactive bone. Both posers draw
+ * such a slot through the zero matrix, so it draws no pixel and every vertex of
+ * it sits at the origin. `framingViewport` takes these slots off the box
+ * (#1000) and `unframeableSentence` refuses a pose that drew nothing else
+ * (#997), from this one set.
+ *
+ * Empty without a roster: a bare `Poser` carries no skin structure, and what
+ * cannot be read is not guessed — every slot then counts, as it did before.
+ */
+export function slotsOnUnposedBones(
+  slots: ReadonlyArray<{ name: string; bone: string }>,
+  skin: string | undefined,
+  roster: SkinRoster | undefined,
+): Set<string> {
+  if (roster === undefined) return new Set();
+  const unposed = roster.unposedUnder(skin);
+  return new Set(slots.filter((slot) => unposed.has(slot.bone)).map((slot) => slot.name));
+}
+
+/** How many drawn slots a refusal names before it says how many more there are. */
+const UNFRAMEABLE_NAMED = 3;
+
+/**
+ * ⭐ **The one derivation of the unframeable sentence** (issue #997): `null`
+ * when the vertices of `frameSets` span a box with extent, and otherwise the
+ * sentence `UnframeablePoseError` carries. `framingViewport` and `check` both
+ * reach it, so `render`, `render --geometry`, `check` and a library caller
+ * refuse one rig in the same words.
+ *
+ * Two sentences, told apart by what the reader must change:
+ *
+ * - **every drawn slot hangs from a bone the skin leaves unposed** — inactive
+ *   itself or below an inactive bone (`unposedBones`). Both posers draw such a
+ *   slot through the zero matrix, so every vertex lands on the origin. Each
+ *   bone is named with the skins that pose it, read off the runtime's own
+ *   `active` flag under each skin rather than restating Spine's rule here.
+ * - otherwise **every drawn vertex sits at one point** — the bones posed, and
+ *   collapsed their attachments (a world scale of 0 does).
+ *
+ * `roster` is the skin structure of the Spine file the poser poses
+ * (`skinRosterOf`), which is what says whether a bone is unposed
+ * (`slotsOnUnposedBones`, the set the framing box leaves out) and which skins
+ * pose it. Without it the first sentence cannot be told from the second, and
+ * the second is what is said.
+ *
+ * Distinct from *nothing to draw*: that is a skeleton that posed no vertex at
+ * all, and its fix is art; this one posed vertices, and they have no place.
+ */
+export function unframeableSentence(
+  frameSets: ReadonlyArray<readonly Frame[]>,
+  slots: ReadonlyArray<{ name: string; bone: string }>,
+  skin: string | undefined,
+  roster: SkinRoster | undefined,
+): string | null {
+  const box = unionBounds(frameSets.map((frames) => [...frames]));
+  if (![box.minX, box.minY, box.maxX, box.maxY].every(Number.isFinite)) return null;
+  if (box.maxX - box.minX !== 0 || box.maxY - box.minY !== 0) return null;
+  const drew = new Set<string>();
+  for (const frames of frameSets) {
+    for (const frame of frames) for (const piece of frame.pieces) if (piece.world.length > 0) drew.add(piece.slot);
+  }
+  // Declaration order, so the sentence does not depend on which frame drew first.
+  const drawn = slots.filter((slot) => drew.has(slot.name));
+  const under = skin === undefined ? 'under no skin' : `under skin ${JSON.stringify(skin)}`;
+  const counted = `${drawn.length} drawn slot${drawn.length === 1 ? '' : 's'}`;
+  const more = drawn.length > UNFRAMEABLE_NAMED ? `; and ${drawn.length - UNFRAMEABLE_NAMED} more` : '';
+  const named = (describe: (slot: { name: string; bone: string }) => string): string =>
+    drawn.slice(0, UNFRAMEABLE_NAMED).map(describe).join('; ') + more;
+  if (roster !== undefined) {
+    const offBox = slotsOnUnposedBones(slots, skin, roster);
+    if (drawn.length > 0 && drawn.every((slot) => offBox.has(slot.name))) {
+      const bySkin = roster.skins.map((name) => ({ name, unposed: roster.unposedUnder(name) }));
+      const posers = (bone: string): string => {
+        const names = bySkin.filter((k) => !k.unposed.has(bone)).map((k) => JSON.stringify(k.name));
+        if (names.length === 0) return 'which no skin poses';
+        return `which skin${names.length === 1 ? '' : 's'} ${names.join(', ')} pose${names.length === 1 ? 's' : ''}`;
+      };
+      return (
+        `${under}, every drawn slot hangs from a bone that skin leaves unposed — ${counted}: ` +
+        named((slot) => `slot ${JSON.stringify(slot.name)} on bone ${JSON.stringify(slot.bone)}, ${posers(slot.bone)}`) +
+        ' — so no drawn vertex has a world transform and the frame would be 0x0: pose it under a skin that poses ' +
+        'those bones (`--skin`), or name the bones in the skin it is posed under'
+      );
+    }
+  }
+  return (
+    `${under}, every drawn vertex sits at the one point (${box.minX}, ${box.minY}) — ${counted}: ` +
+    named((slot) => `slot ${JSON.stringify(slot.name)} on bone ${JSON.stringify(slot.bone)}`) +
+    ' — so the posed box has no extent and the frame would be 0x0: the bones those slots hang from collapse ' +
+    'every vertex onto it (a world scale of 0 does)'
+  );
+}
+
 /**
  * The viewport a skeleton is framed to: its union box at `FRAMING_FPS`, padded,
  * scaled so the long side is `maxSide` pixels.
@@ -1827,9 +2270,26 @@ export function trimmedUnionBounds(
  *
  * `null` means the skeleton posed no vertex at all — nothing to draw. A pose
  * holding a vertex at Infinity or NaN is refused by a `GeometryError` naming the
- * bone or vertex and its value (issue #873), never answered `null`.
+ * bone or vertex and its value (issue #873), never answered `null`. A pose whose
+ * every vertex sits at one point is refused by an `UnframeablePoseError`
+ * (`unframeableSentence`, issue #997), never framed at a scale of Infinity.
+ *
+ * The box is over the slots that POSE (issue #1000): a drawn slot whose bone
+ * the skin leaves unposed (`slotsOnUnposedBones`) draws no pixel — both posers
+ * put it through the zero matrix — so its vertices at the origin are not part
+ * of the shot, and counting them framed every frame of a rig that carries one
+ * to a point nothing is drawn at (256x94 where the posed slot alone gives
+ * 256x55). When every drawn slot is such a slot there is no posed box at all,
+ * and that is #997's refusal, never an empty or invented one.
+ *
+ * `roster` is the skin roster behind a `Poser` source (`skinRosterOf`) — what
+ * says which bones the skin leaves unposed, and lets the refusal name the skins
+ * 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(data: SkeletonData, maxSide: number, opts?: PoseOptions): Viewport | null {
+export function framingViewport(source: PoseSource, maxSide: number, opts?: PoseOptions, rosterGiven?: SkinRoster): 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
   // in different places. Framing one skin's shot with another skin's box would
@@ -1848,9 +2308,9 @@ export function framingViewport(data: SkeletonData, maxSide: number, opts?: Pose
   const { slots: _drawn, hidden: _hidden, bones: _bones, geometry: _geometry, ...whole } = opts ?? {};
   const framed: PoseOptions = { ...whole, unclipped: true };
   const sets =
-    data.animations.length === 0
-      ? [sampleSetupPose(data, framed)]
-      : data.animations.map((a) => sampleAnimation(data, a.name, FRAMING_FPS, framed));
+    poser.animations.length === 0
+      ? [sampleSetupPose(poser, framed)]
+      : poser.animations.map((a) => sampleAnimation(poser, a.name, FRAMING_FPS, framed));
   // ⚠️ 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
@@ -1859,16 +2319,27 @@ export function framingViewport(data: SkeletonData, 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 posedAny = sets.some((frames) => frames.some((frame) => frame.pieces.some((piece) => piece.world.length > 0)));
-  if (!posedAny) return null;
-  const box = unionBounds(sets);
+  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;
+  // ⭐ 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
+  // 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);
   if (![box.minX, box.minY, box.maxX, box.maxY].every(Number.isFinite)) {
     const found = nonFinitePoseOf(
-      data,
+      poser,
       framed.skin,
-      data.animations.length === 0
+      poser.animations.length === 0
         ? [{ animation: null, fps: FRAMING_FPS }]
-        : data.animations.map((a) => ({ animation: a.name, fps: FRAMING_FPS })),
+        : poser.animations.map((a) => ({ animation: a.name, fps: FRAMING_FPS })),
     );
     // Reaching here with nothing found would mean the pieces and the whole
     // attachments disagree about one pose — a defect here, said as one.
@@ -1880,6 +2351,11 @@ export function framingViewport(data: SkeletonData, maxSide: number, opts?: Pose
     }
     throw new GeometryError(found);
   }
+  // 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);
   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);
 }
@@ -2146,6 +2622,10 @@ export function rasteriseMesh(
     const u2 = mesh.uvs[i2 * 2];
     const v2 = mesh.uvs[i2 * 2 + 1];
 
+    // A clipped piece (`Mesh.source`, issue #964): the UV of a pixel is the SOURCE triangle's affine map, in doubles from its own
+    // projected corners and page UVs, so which convex pieces the clipper cut changes no pixel. Coverage is still this triangle's.
+    const src = mesh.source === undefined ? null : sourceMap(mesh.source, t / 3, project);
+
     for (let y = minY; y <= maxY; y++) {
       const sy = y + 0.5;
       for (let x = minX; x <= maxX; x++) {
@@ -2157,11 +2637,15 @@ export function rasteriseMesh(
         const w2 = (x1 - x0) * (sy - y0) - (y1 - y0) * (sx - x0);
         if (topLeft2 ? w2 < 0 : w2 <= 0) continue;
 
-        const b0 = w0 / area;
-        const b1 = w1 / area;
-        const b2 = w2 / area;
-        const u = b0 * u0 + b1 * u1 + b2 * u2;
-        const v = b0 * v0 + b1 * v1 + b2 * v2;
+        let u: number;
+        let v: number;
+        if (src === null) {
+          const b0 = w0 / area;
+          const b1 = w1 / area;
+          const b2 = w2 / area;
+          u = b0 * u0 + b1 * u1 + b2 * u2;
+          v = b0 * v0 + b1 * v1 + b2 * v2;
+        } else [u, v] = src(sx, sy);
         if (outsideWindow(mesh.uvWindow, u, v)) continue;
         const sample = bilinear(page, u * page.width - 0.5, v * page.height - 0.5);
         const alpha = sample[3] * mesh.tint[3];
@@ -2179,6 +2663,28 @@ export function rasteriseMesh(
   }
 }
 
+/**
+ * The UV map of a clipped piece's drawn triangle `t`: its source triangle's
+ * affine map (`Mesh.source`), from the three projected source corners and their
+ * page UVs, in doubles — the barycentric weights of the pixel centre in the
+ * projected source triangle times the corners' UVs. The same for every
+ * decomposition of the source triangle, which is the point (issue #964).
+ */
+function sourceMap(source: ClipSource, t: number, project: (wx: number, wy: number) => [number, number]): (sx: number, sy: number) => [number, number] {
+  const o = t * 6;
+  const [ax, ay] = project(source.world[o], source.world[o + 1]);
+  const [bx, by] = project(source.world[o + 2], source.world[o + 3]);
+  const [cx, cy] = project(source.world[o + 4], source.world[o + 5]);
+  const uv = source.uvs;
+  const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+  return (sx, sy) => {
+    const wa = ((cx - bx) * (sy - by) - (cy - by) * (sx - bx)) / area;
+    const wb = ((ax - cx) * (sy - cy) - (ay - cy) * (sx - cx)) / area;
+    const wc = ((bx - ax) * (sy - ay) - (by - ay) * (sx - ax)) / area;
+    return [wa * uv[o] + wb * uv[o + 2] + wc * uv[o + 4], wa * uv[o + 1] + wb * uv[o + 3] + wc * uv[o + 5]];
+  };
+}
+
 /**
  * Rasterise whichever shape this piece is.
  *