spine-rigc 2.1.3 → 2.3.0

package/src/cli/shared.ts

@@ -22,11 +22,11 @@ import { MAX_CANDIDATES, MIN_CANDIDATES } from '../ballot.ts';
 import { BONEDIST_SPEC, IDENTITY_CORRESPONDENCE } from '../correspondence.ts';
 import { ANCHOR_MAX_RESIDUAL, ANCHOR_MAX_UNEXPLAINED, DEFAULT_HINGE_MAX, DEFAULT_HINGE_MIN, DEFAULT_MIN_LEVER_PX, DEFAULT_MIN_VISIBLE, DEFAULT_PASSES } from '../chainfit.ts';
 import { checkAgainstFrames, type CheckOptions, CheckPlates, type CheckReport } from '../check.ts';
-import { compile, CompileError, droppedStateReason, type CompileOptions } from '../compile.ts';
+import { compile, CompileError, droppedStateReason, headerBoundsOf, type CompileOptions } from '../compile.ts';
 import { depthStepLevels, type FoldLimit, type TurnCeiling } from '../depth.ts';
 import { parseJsonWithPosition } from '../json-position.ts';
 import { RUNG_IDS } from '../ladder.ts';
-import { MODEL_DOCUMENT_FILE, modelDocument } from '../model.ts';
+import { MODEL_DOCUMENT_FILE, MODEL_DOCUMENT_SPEC, modelDocument, spineFileSha256 } from '../model.ts';
 import { DEFAULT_MAX_RESIDUAL, DEFAULT_SCALE_MAX, DEFAULT_SCALE_MIN } from '../pose.ts';
 import {
   CandidateAtlasError,
@@ -42,7 +42,7 @@ import {
 import { BallotError } from '../ballot.ts';
 import { ChainFitError } from '../chainfit.ts';
 import { CheckError } from '../check.ts';
-import { IngestError } from '../ingest.ts';
+import { IngestError, type IngestStage } from '../ingest.ts';
 import { NotAPngError } from '../png.ts';
 import { PoseError } from '../pose.ts';
 import { SpineRuntimeError, SPINE_SIDE_ABSENT } from '../spine_side.ts';
@@ -2082,6 +2082,72 @@ function runGate(
   });
 }
 
+/**
+ * The model document `build` wrote beside a skeleton, when the one beside it
+ * is that build's: a `skeleton.model.json` in the skeleton's directory whose
+ * `spine.sha256` is the digest of exactly this skeleton text (the digest the
+ * core poser checks before it poses a build, issue #968). Since issue #907 a
+ * rigc build's header carries the setup-pose bounding box and its stage is the
+ * document's, so a gate run over a directory reads A14's and A19's stage from
+ * this document, as `build`'s own gate did, and `ingest` reads the rebuild's
+ * stage from it (`documentStageBeside`); a skeleton with no such document
+ * beside it — an export, or a document of another skeleton — is read off its
+ * header, as before.
+ */
+export function modelTextBeside(skeletonPath: string, skeletonText: string): string | undefined {
+  const path = join(dirname(skeletonPath), MODEL_DOCUMENT_FILE);
+  if (!existsSync(path)) return undefined;
+  const text = readFileSync(path, 'utf8');
+  let digest: unknown;
+  try {
+    const doc: unknown = JSON.parse(text);
+    digest = typeof doc === 'object' && doc !== null ? (doc as { spine?: { sha256?: unknown } }).spine?.sha256 : undefined;
+  } catch {
+    return undefined;
+  }
+  return digest === spineFileSha256(skeletonText) ? text : undefined;
+}
+
+/**
+ * The stage a rigc build's model document states, for `ingest` (issue #907):
+ * the `rigc-compiled/3` document beside the skeleton whose digest is that
+ * skeleton's (`modelTextBeside`) — its `stage`, four numbers or `null` for a
+ * rig that declared none. `undefined` — read the header, as before — for an
+ * export or a bare file (no document), a document of another skeleton, a
+ * `/2` or `/1` document (written when the header still was the stage), or a
+ * `stage` that is not one of those two shapes.
+ *
+ * ⭐ Why `ingest` needs it: since #907 a rigc build's header carries the
+ * setup-pose bounding box, and the stage is only in the document. Reading the
+ * header as the stage would rebuild a rig whose stage is its own bounding box
+ * — gallery/nod's 640x700 stage came back 640x725 — so `A14` and `A19` on the
+ * rebuild would measure against a box the author never stated.
+ */
+export function documentStageBeside(skeletonPath: string, skeletonText: string): IngestStage | null | undefined {
+  const text = modelTextBeside(skeletonPath, skeletonText);
+  if (text === undefined) return undefined;
+  const doc = JSON.parse(text) as { spec?: unknown; stage?: unknown };
+  if (doc.spec !== MODEL_DOCUMENT_SPEC || !('stage' in doc)) return undefined;
+  const stage = doc.stage;
+  if (stage === null) return null;
+  if (typeof stage !== 'object') return undefined;
+  const { x, y, width, height } = stage as Record<string, unknown>;
+  return typeof x === 'number' && typeof y === 'number' && typeof width === 'number' && typeof height === 'number' ? { x, y, width, height } : undefined;
+}
+
+/**
+ * The line `build` prints when the rig declares a stage and the header carries
+ * no setup-pose bounding box (issue #907): why — nothing drawn, a region with
+ * no atlas rectangle, or a setup pose rigc's core leaves out
+ * (`headerBoundsOf`). Silent where the box is written, or where the rig
+ * declares no stage, which asked for no box.
+ */
+function printHeaderBox(result: CompileResult): void {
+  if (result.model.stage === null || typeof result.skeleton.skeleton.width === 'number') return;
+  const { why } = headerBoundsOf(result.model, result.atlasText);
+  if (why !== null) console.log(`  ..    header  no setup-pose bounding box — ${why}`);
+}
+
 /**
  * build — moved here unchanged from `./spine_commands.ts` (issue #1060) but
  * for its gate, which the entry hands in (`BuildGate`): both entries write
@@ -2092,6 +2158,7 @@ export function runBuild(flags: Record<string, string>, gate: BuildGate): void {
   printBuildHeader(label, opts);
   const result = compile(opts);
   printCompiled(opts, result);
+  printHeaderBox(result);
 
   // The model's document is spelled before the gate, so the text A18 compares
   // is the text written, and a model the document cannot carry is refused

package/src/cli/spine_commands.ts

@@ -19,7 +19,7 @@ import { buildPreview, buildPreviewPanes, PLAYER_LINE, type PreviewGate, type Pr
 import { atlasPageNames } from '../render.ts';
 import { BoneDistError } from '../bonedist.ts';
 import { assertionCountForProfile, CLI_DEFAULT_PROFILE, reportLines, validate, type ValidateProfile } from '../validate.ts';
-import { type CliRefusal, type CommandRun, DEFAULT_BALLOT, PACKAGE_ROOT, DEFAULT_LEDGER, parseJsonNamed, readAnimationFlag, readJsonFile, readPackageMeta, readSkeletonText, readVersion, resolveBuild, resolveCut, resolveViewable, runCheck, spinePairOf, type BuildGate, runBuild, readProfile, STAGELESS_FRAMING, UsageError, writeJson } from './shared.ts';
+import { type CliRefusal, type CommandRun, DEFAULT_BALLOT, PACKAGE_ROOT, DEFAULT_LEDGER, parseJsonNamed, readAnimationFlag, readJsonFile, readPackageMeta, readSkeletonText, readVersion, resolveBuild, resolveCut, resolveViewable, runCheck, spinePairOf, type BuildGate, runBuild, readProfile, STAGELESS_FRAMING, UsageError, writeJson, modelTextBeside } from './shared.ts';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 
@@ -83,12 +83,14 @@ export function cmdValidate(flags: Record<string, string>, positional: string[])
   const atlasText = readFileSync(atlasPath, 'utf8');
   const derived = derivedOpts ? compile(derivedOpts) : null;
 
+  const modelText = modelTextBeside(skeletonPath, skeletonText);
   const report = validate({
     skeletonText,
     atlasText,
     atlasDir: dirname(atlasPath),
     declaredDurations: derived?.declaredDurations,
     rig: derived?.rig,
+    ...(modelText === undefined ? {} : { modelText }),
     profile,
   });
   for (const line of reportLines(report)) console.log(line);
@@ -136,15 +138,18 @@ function skeletonAnimationNames(skeletonText: string, path: string): string[] {
  * takes it (issue #837).
  *
  * ⭐ The same call `cmdValidate` makes on a bare directory: the two texts, the
- * atlas's own directory, the default profile, and nothing a directory cannot
- * supply — no rig spec, no declared durations, no second compile. So `A09` and
+ * atlas's own directory, the default profile, the build's model document
+ * where the one beside the skeleton is its own (`modelTextBeside`, issue #907
+ * — the stage A14 and A19 read), and nothing a directory cannot supply — no
+ * rig spec, no declared durations, no second compile. So `A09` and
  * `A18` report SKIP here exactly as they do there, and the line is the line
  * that command prints for these files, not the one `build` printed for the
  * compile that wrote them. Measured on every run, because the page must not
  * carry a figure this run did not measure.
  */
-function previewGate(skeletonText: string, atlasText: string, atlasDir: string): PreviewGate {
-  const lines = reportLines(validate({ skeletonText, atlasText, atlasDir, profile: CLI_DEFAULT_PROFILE }));
+function previewGate(skeletonPath: string, skeletonText: string, atlasText: string, atlasDir: string): PreviewGate {
+  const modelText = modelTextBeside(skeletonPath, skeletonText);
+  const lines = reportLines(validate({ skeletonText, atlasText, atlasDir, ...(modelText === undefined ? {} : { modelText }), profile: CLI_DEFAULT_PROFILE }));
   const refusal = lines.find((line) => line.startsWith('  FAIL  '));
   return {
     // `reportLines` ends on the summary by construction; the gutter is the
@@ -253,7 +258,7 @@ export function cmdPreview(flags: Record<string, string>, candidates: string[]):
       console.log(`  ..    page     ${page.name.padEnd(28)} ${(page.bytes.length / 1024).toFixed(1)} KiB`);
     }
     if (!declaresSetupStage(skeletonHeaderOf(skeletonText))) console.log(`  ..    ${STAGELESS_FRAMING.preview}`);
-    const gate = previewGate(skeletonText, atlasText, atlasDir);
+    const gate = previewGate(skeletonPath, skeletonText, atlasText, atlasDir);
     console.log(`  ..    gate     ${gate.summary}`);
     if (gate.refusal !== null) {
       console.log(
@@ -540,7 +545,8 @@ export function cmdBench(flags: Record<string, string>, positional: string[]): v
   console.log('');
 
   console.log(`  ── validate (profile ${profile}) ──`);
-  const report = validate({ skeletonText, atlasText, atlasDir: dirname(atlasPath), profile });
+  const benchModel = modelTextBeside(skeletonPath, skeletonText);
+  const report = validate({ skeletonText, atlasText, atlasDir: dirname(atlasPath), ...(benchModel === undefined ? {} : { modelText: benchModel }), profile });
   for (const line of reportLines(report)) console.log(`  ${line}`);
   console.log('');
 

package/src/compile.ts

@@ -132,8 +132,11 @@ import { emitSkeleton, type SkeletonHeader } from './emit_spine.ts';
 import { PHYSICS_PARAMS, UNSTATED_REFERENCE_SCALE } from './keyorder.ts';
 import { curveLengthTable } from './core/constraints_path.ts';
 import { frameRegionName } from './core/uvs.ts';
+import { setupBounds, type CoreBounds } from './core/raw.ts';
+import { CoreInputError, readModel } from './core/index.ts';
 import {
   isModelVertexAttachment,
+  modelDocument,
   type CarriedFromCompileResult,
   type CompiledAnimation,
   type CompiledModel,
@@ -990,6 +993,30 @@ function onModelGrid(n: number): number {
   return f32(Math.round(n * 1e6) / 1e6);
 }
 
+/**
+ * One number of the header's setup-pose bounding box as `build` writes it
+ * (issue #907): the double rigc's core computed — equal to spine-core's
+ * `getBounds` at tolerance 0 (`tools/core_gate.ts`'s bounds rows) — on the
+ * model's 1e-6 grid at float32 (`onModelGrid`).
+ *
+ * ⭐ **Why the grid and not the bare float32.** A box edge that sits at the
+ * setup pose's origin lands on the residue of a cancellation: gallery/flex's
+ * and gallery/ride's lower edge is 1.1368683772161603e-13 — one ulp of 720 —
+ * in rigc's core and in `getBounds` alike. A float32 keeps that residue (it is
+ * a float in its own right), so the written header followed the platform's
+ * libm to the last bit: with every libm-backed `Math` function nudged one ulp,
+ * the header of those two rows moved, and with it their documents'
+ * `spine.sha256` (`TB02`, which the gallery bases on two machines stand on).
+ * On the grid the residue is the 0 it is, and the box is otherwise the box to
+ * within half a millionth of a unit — three orders below the 0.0071 by which
+ * the editor's own header differs from `getBounds` on the twelve example
+ * exports. Exported for the two readers that hold a header to `getBounds`:
+ * `tools/core_gate.ts` and the corpus suite (`withRuntimeBox`).
+ */
+export function headerBoxNumber(n: number): number {
+  return onModelGrid(n);
+}
+
 /**
  * Of the decimals `a·10^scale` and `b·10^scale` (`a < b`), the one closer to
  * the positive float `f`, compared exactly; a tie goes to the even digit.
@@ -2133,8 +2160,10 @@ export function compile(opts: CompileOptions): CompileResult {
     // does not hold — the rest of the header — and the editor's orders, the
     // same functions `compileModel` stated the model's `editorOrder` with: the
     // sorts are applied at emission, so the model's `skins` and `animations`
-    // keep the spec's own order.
-    const skeleton = emitSkeleton(model, header, EDITOR_ORDERS);
+    // keep the spec's own order. The header's box is the setup-pose bounding
+    // box rigc's core computes over the model (issue #907, `headerBoundsOf`),
+    // never the stage.
+    const skeleton = emitSkeleton(model, { ...header, bounds: headerBoundsOf(model, atlasText).box }, EDITOR_ORDERS);
     return {
       skeleton,
       skeletonText: `${JSON.stringify(skeleton, null, 2)}\n`,
@@ -2146,6 +2175,73 @@ export function compile(opts: CompileOptions): CompileResult {
   });
 }
 
+/**
+ * The box the Spine header carries (issue #907): the setup-pose bounding box
+ * — what the format says `skeleton.x`, `y`, `width`, `height` are — computed
+ * by rigc's own core over the model (`setupBounds` in `src/core/raw.ts`,
+ * whose header states each measured rule), each of the four on the model's
+ * 1e-6 grid at float32 (`headerBoxNumber`).
+ *
+ * ⭐ **The stage is not this value and does not move.** `model.stage` — the
+ * rig spec's `skeleton.width`/`height` or the manifest's crop, the working
+ * area the coordinate transform reads (`src/transform.ts`) — stays the
+ * model's and the document's; until issue #907 the emitter copied it into the
+ * header, which is the defect the issue names: a reader who takes the header
+ * for what the format says it is got the crop.
+ *
+ * `null` — no box in the header — in two cases, each a statement rather than
+ * a number nobody measured:
+ *
+ *   - the rig declares no stage (`"width": null, "height": null`, issue
+ *     #578): the header carried no box before, and the input that asked for
+ *     none keeps getting none;
+ *   - nothing is drawn at the setup pose: a box around no vertex does not
+ *     exist (`getBounds` returns an infinite offset and a negative-infinite
+ *     size for it);
+ *   - a region the build has no atlas rectangle for (`atlas: null`,
+ *     `ModelRegionAttachment.atlas`): its corners read the trim and original
+ *     size, which nobody measured, and the build is refused by name anyway —
+ *     the emitted atlas has no such region, and
+ *     `A08_REGION_NAMES_MATCH_ATTACHMENTS` names it. Refusing the compile
+ *     here instead would replace that named failure with a different one;
+ *   - a setup pose rigc's core leaves out (`CoreInputError` — measured on the
+ *     tree: a slider whose animation keys an ik constraint's timelines, which
+ *     the core's constraint cut does not pose). The entry without spine-core
+ *     has no other poser, and both entries must write the same bytes, so the
+ *     box is absent on both rather than present on one; refusing the compile
+ *     would refuse a rig the gate passes. `tools/core_gate.ts` reports such a
+ *     row SKIP naming the reason, never IDENTICAL.
+ *
+ * Every case but the first comes back with `why`, the sentence `build` prints
+ * beside its output (`printHeaderBox` in `src/cli/shared.ts`), so an absent
+ * box is never silent.
+ *
+ * The core poses the model through its document — the text `build` writes
+ * beside the pair, read back by `readModel` — so the box is of the document a
+ * reader holds, not of an object only this process saw. The document's
+ * `spine.sha256` names the skeleton written beside it, which does not exist
+ * yet; the digest of an empty text stands in for it here, and nothing the box
+ * depends on reads it.
+ */
+export function headerBoundsOf(model: CompiledModel, atlasText: string): { box: ModelStage | null; why: string | null } {
+  if (model.stage === null) return { box: null, why: null };
+  const unplaced = model.skins.flatMap((skin) =>
+    Object.entries(skin.attachments).flatMap(([slot, table]) =>
+      Object.entries(table).flatMap(([placeholder, entry]) => (entry.kind === 'region' && entry.atlas === null ? [`skin "${skin.name}" slot "${slot}" region "${placeholder}"`] : [])),
+    ),
+  );
+  if (unplaced.length > 0) return { box: null, why: `${unplaced[0]} has no atlas rectangle, so its corners are not known — A08_REGION_NAMES_MATCH_ATTACHMENTS names it` };
+  let box: CoreBounds | null;
+  try {
+    box = setupBounds(readModel(modelDocument(model, '', atlasText), 'the compiled model'));
+  } catch (err) {
+    if (err instanceof CoreInputError) return { box: null, why: `rigc's core does not pose this setup pose — ${err.message}` };
+    throw err;
+  }
+  if (box === null) return { box: null, why: 'the setup pose draws nothing, and a box around no vertex does not exist' };
+  return { box: { x: headerBoxNumber(box.x), y: headerBoxNumber(box.y), width: headerBoxNumber(box.width), height: headerBoxNumber(box.height) }, why: null };
+}
+
 /**
  * What `compileModel` returns: the compiled model, and what a caller needs
  * beside it to gate it, write its document and — if it asks — emit it.
@@ -2154,7 +2250,7 @@ export interface CompiledBuild {
   /** The compiled model (`src/model.ts`), `stage` and `editorOrder` included (issue #1026). */
   model: CompiledModel;
   /** The rest of the Spine header the model does not hold (`SkeletonHeader`): what `compile` hands the emitter beside the model. */
-  header: SkeletonHeader;
+  header: Omit<SkeletonHeader, 'bounds'>;
   /** The atlas text the compile measured its art against — `CompileResult.atlasText`. */
   atlasText: string;
   /** Declared durations, carried into the validator (rule 4) — `CompileResult.declaredDurations`. */
@@ -3532,7 +3628,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
       ? { x: rig.skeleton?.x ?? 0, y: rig.skeleton?.y ?? 0, width: stageWidth, height: stageHeight }
       : null;
   // What the skeleton carries that the model does not hold: the rest of the header.
-  const header: SkeletonHeader = {
+  const header: Omit<SkeletonHeader, 'bounds'> = {
     spine: SPINE_VERSION,
     fps: rig.skeleton?.fps,
     images: skeletonImagesPath(rig.skeleton?.images, opts, outDir, partDirs),

package/src/core/raw.ts

@@ -113,7 +113,7 @@
  * naming why (`CoreInputError`): a renderer handed a pose with a block
  * missing would draw a different picture in silence.
  */
-import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, readColour, shownAttachment, sourceOfDoc, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
+import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, readColour, shownAttachment, sourceOfDoc, underNoSkin, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
 import { posedBoneWorld, posedSlots, type TimelinePlant } from './animation.ts';
 import { constraintsAbsentWhy, pathAnimationsWhy } from './constraints.ts';
 import { freshStepContext, steppedPreviousPassWhy } from './constraints_physics.ts';
@@ -406,3 +406,103 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
   }
   return poses;
 }
+
+// --- #907 the setup-pose bounding box: begin ---
+/**
+ * The setup-pose bounding box (issue #907) — `setupBounds` below: the axis-aligned box around every
+ * region and mesh a skeleton draws at its setup pose, as spine-core's
+ * `Skeleton.getBounds(offset, size, temp)` returns it on a fresh skeleton —
+ * no skin set, `updateWorldTransform(Physics.none)` — which is what the Spine
+ * format says the header's `x`, `y`, `width` and `height` are.
+ *
+ * Every rule below was measured by running spine-core 4.3.13 through the
+ * tree's own loader, not read off its source:
+ *
+ * - **The view is "no skin set"** (`underNoSkin`, issue #1051): a skeleton
+ *   `build` writes is loaded and bounded before anyone calls `setSkin`, so
+ *   the slots resolve through the default skin alone and no skin's bones or
+ *   constraint lists apply.
+ * - **Constraints applied.** The box is of the pose `updateWorldTransform`
+ *   leaves, every ik, transform, path and slider constraint applied in the
+ *   document's order — the pose `poseSetup` computes. The editor's own
+ *   header is of that pose too: on `examples/spineboy/export/spineboy-pro.json`
+ *   (seven ik and seven transform constraints) `getBounds` with the
+ *   constraints applied is within 0.0035 of the header the editor wrote, and
+ *   with them stripped it is 0.31 off in `y` and `height`.
+ * - **Physics.none.** A physics constraint applies nothing at the setup pose
+ *   (the oracle's setup reading). Under `Physics.reset` spine-core's box was
+ *   the same, to the bit, on all nineteen tree rows (two declare a physics constraint).
+ * - **What is counted.** A region's four corners and a mesh's (a linked
+ *   mesh's) world vertices — the rows of the oracle's `setup.attachments`
+ *   block, in full doubles. A clipping polygon, a bounding box, a path and a
+ *   point are not counted (measured: each placed 5000 units out moved
+ *   `getBounds` by nothing), and the box is not clipped: `getBounds` called
+ *   without its optional clipper.
+ * - **A slot on an inactive bone is not counted** — measured: a skin-required
+ *   bone 1000 units out, which only a named skin activates, carrying a region
+ *   left `getBounds` at the other region's 20 units with no skin set, and 1020
+ *   with the bone not skin-required. A bone that is not skin-required under an
+ *   inactive parent is active and unposed, and its slot is counted at the
+ *   vertices that pose gives; the core poses the same vertices (the oracle's
+ *   `setup.attachments`, held at tolerance 0), and a probe of that shape read
+ *   the same box both ways.
+ * - **The box.** `x`, `y` are the least `x` and `y` over every counted
+ *   vertex and `width`, `height` the greatest less the least — the
+ *   bottom-left corner in Spine's y-up world, not the top-left. In full
+ *   doubles; `build` writes each on the model's 1e-6 grid at float32
+ *   (`headerBoxNumber` in `src/compile.ts`, whose comment says why).
+ * - **Nothing drawn is no box.** `getBounds` over no vertex returns an offset
+ *   of `+Infinity` and a size of `-Infinity`, which is not a box; this
+ *   returns `null` for it, and the emitter writes no box rather than a number
+ *   nobody measured.
+ *
+ * Pure, like the rest of `src/core/`: it links nothing from the runtime, and
+ * `tools/core_gate.ts` holds it to `getBounds` at tolerance 0 over the corpus
+ * (its `BOUNDS` rows).
+ */
+
+/** The setup-pose box: its bottom-left corner and its extent, in Spine world units, in full doubles. */
+export interface CoreBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * The setup-pose bounding box of a model document (the header's rules), or
+ * `null` where nothing is drawn. Refused by name — `CoreInputError` — where
+ * the core leaves the setup attachments out, since a box over the rest would
+ * be a box of a different pose.
+ */
+export function setupBounds(doc: CompiledDocument, plant: CorePlant = {}): CoreBounds | null {
+  const view = underNoSkin(doc);
+  const posed = poseSetup(view, { ...plant, round: rawNumber });
+  const rows = posed.setup.attachments;
+  if (rows === null) {
+    const why = posed.absent.find(([block]) => block === 'setup.attachments')?.[1] ?? 'the setup attachments were not posed';
+    throw new CoreInputError(`the setup-pose bounding box cannot be computed: ${why}`);
+  }
+  const active = activeBones(view);
+  const boneOf = new Map(view.slots.map((s) => [s.name, s.bone]));
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [slot, attachment, , vertices] of rows) {
+    const bone = boneOf.get(slot);
+    if (bone === undefined || !active.has(bone)) continue;
+    for (let i = 0; i + 1 < vertices.length; i += 2) {
+      const x = vertices[i];
+      const y = vertices[i + 1];
+      if (x === null || y === null) throw new CoreInputError(`the setup-pose bounding box cannot be computed: slot "${slot}" attachment "${attachment}" vertex ${i / 2} is not finite`);
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  if (minX === Infinity) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+// --- #907 the setup-pose bounding box: end ---