spine-rigc 1.9.2 → 1.9.3

package/src/core/walk.ts

@@ -65,22 +65,17 @@
  * `CoreInputError` naming why, as there — a pose with a block missing is not
  * a pose whose values can be judged finite.
  *
- * ⛔ **And one construct this walk refuses that the raw entry does not**
- * (`sliderPhysicsWhy`): a slider whose animation keys a physics timeline.
- * Issue #1049. Of the selftest's builds of that class (a dial, or two
- * sliders, keying a physics constraint's `wind` or `gravity`), five walked off spine-core from the third
- * step on — `tip` at worldX 14.87 against 12.09 on the first, at 0.025 s —
- * while others of the same class walked exact. The raw entry's own non-looping walk reads the same
- * gap (and with the slider made non-additive, 14.78 against 12.09), so it is
- * the stepped walk's reading of a slider's physics keys, not the loop's.
- * Which of the class it reaches is not measured, so the walk refuses the
- * class by name rather than return a pose it cannot vouch for. On the same
- * five inputs, `./additive.ts` and spine-core's probe agree that each slider's
- * `wind` or `gravity` timeline accumulates when applied twice with `add` — so
- * the gap is downstream of that rule, in the stepped bones, not in it.
+ * 🔁 **A slider whose animation keys a physics timeline** was refused here
+ * by name until issue #1049 (`sliderPhysicsWhy`): six of the path-slider
+ * suite's distinct builds walked off spine-core from the third step, and the
+ * raw entry read the same gap. The core had not applied a slider's physics keys at all;
+ * it now does, under the step, by the rule `./constraints_slider.ts` *Its
+ * physics timelines* states and the core suite's `CO31` holds — so this walk
+ * poses the class as the raw entry does, and refuses nothing the raw entry
+ * does not.
  */
 import { setupPoseIn, walkIn, type RawBone, type RawDrawn, type WalkMode } from './raw.ts';
-import { activeBones, CoreInputError, constraintRecords, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
+import { activeBones, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
 import { historyTaint } from './constraints.ts';
 import type { TimelinePlant } from './animation.ts';
 
@@ -100,20 +95,6 @@ export interface WalkPose {
   drawn: RawDrawn[];
 }
 
-/**
- * Why the looping walk refuses this document, or `null` (the header's last
- * ⛔, issue #1049): every slider whose animation keys a physics timeline,
- * named with it.
- */
-export function sliderPhysicsWhy(doc: CompiledDocument): string | null {
-  const keyed = constraintRecords(doc).flatMap((r) => {
-    if (r.kind !== 'slider') return [];
-    const anim = doc.animations.find((a) => a.name === r.animation);
-    return anim !== undefined && anim.constraints.physics > 0 ? [`slider "${r.name}" applies animation "${r.animation}", which keys physics timelines`] : [];
-  });
-  return keyed.length === 0 ? null : `${keyed.join('; ')} — under the stepped walk spine-core's bones leave the core's from the third step, on the raw entry's walk as on this one, and that reading is not measured (issue #1049)`;
-}
-
 /**
  * The bones and slots whose numbers the walk does not vouch for, because the
  * runtime's own value there is HISTORY (issue #979): a bone the view leaves
@@ -142,12 +123,6 @@ export function walkHistory(view: CompiledDocument): { bones: Map<string, string
   return { bones, slots: new Map(view.slots.filter((s) => bones.has(s.bone)).map((s) => [s.name, s.bone])) };
 }
 
-/** Refuse, by name, a document the looping walk cannot vouch for (`sliderPhysicsWhy`). */
-function refuseUnmeasured(doc: CompiledDocument): void {
-  const why = sliderPhysicsWhy(doc);
-  if (why !== null) throw new CoreInputError(`the looping walk leaves the bones out: ${why}`);
-}
-
 /** The looping walk's mode: the track loops, and a non-finite value stays in the pose. */
 const LOOPING: WalkMode = { loop: true, keep: true };
 
@@ -184,7 +159,6 @@ function narrow(p: { trackTime: number; animationTime: number; bones: RawBone[];
  * what A10 reads before any animation is set.
  */
 export function poseWalkSetup(doc: CompiledDocument, plant: CorePlant = {}, walkPlant: WalkPlant = {}): WalkPose {
-  refuseUnmeasured(doc);
   return narrow(setupPoseIn(doc, plant, LOOPING), walkPlant.number);
 }
 
@@ -196,7 +170,6 @@ export function poseWalkSetup(doc: CompiledDocument, plant: CorePlant = {}, walk
  * refuses the call by name; a value that is not finite does not.
  */
 export function poseLoopingWalk(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant = {}, walkPlant: WalkPlant = {}): WalkPose[] {
-  refuseUnmeasured(doc);
   const mode: WalkMode = { ...LOOPING, ...(walkPlant.time === undefined ? {} : { time: walkPlant.time }), ...(walkPlant.clock === undefined ? {} : { clock: walkPlant.clock }), ...(walkPlant.wrapResets === undefined ? {} : { wrapResets: walkPlant.wrapResets }) };
   return walkIn(doc, animation, steps, plant, 'setup', mode).map((p) => narrow(p, walkPlant.number));
 }

package/src/correspondence.ts

@@ -0,0 +1,15 @@
+/**
+ * The two spellings of a bone correspondence — what `rigc bonedist --bones`
+ * and `rigc bench --bones` take — moved here unchanged from `./bonedist.ts`
+ * (issue #1052), which re-exports both.
+ *
+ * Their own module because the CLI's help states them (`--bones`'s flag row)
+ * and an entry that links nothing of the runtime prints that help, while
+ * `./bonedist.ts` poses both skeletons through spine-core by design.
+ */
+
+/** The sidecar spec a correspondence file declares, and the report's own. */
+export const BONEDIST_SPEC = 'rigc-bonedist/1';
+
+/** What `--bones identity` is spelled as, where a file path would go. */
+export const IDENTITY_CORRESPONDENCE = 'identity';

package/src/deformbuild.ts

@@ -0,0 +1,60 @@
+/**
+ * The deform survey of a build, through the reader and poser asked for —
+ * `explain`'s `DEFORM` block and `tools/survey_hashes.ts` (issues #969,
+ * #1019).
+ *
+ * Moved here unchanged from `./deformmeasure.ts` (issue #1052, step 4e of
+ * #380), which re-exports both names: the choice between the model document
+ * posed by the core and the Spine skeleton posed by spine-core names no
+ * runtime class, and `explain` makes it on a rigc build without touching the
+ * runtime — so an entry that links nothing of spine-core has to be able to
+ * load it. The spine-core half (`throughSpine`) is `./deformmeasure.ts`'s,
+ * reached through the seam (`./spine_side.ts`); where nothing registered it,
+ * a survey that needs it is refused by name (`SpineRuntimeError`).
+ */
+import { CoreInputError, readModel } from './core/index.ts';
+import { surveyOfModel, type DeformSurvey, type DeformSurveySource } from './deformsurvey.ts';
+import { spineFileSha256 } from './model.ts';
+import { spineSurveyFor } from './spine_side.ts';
+
+/** A build's three texts, as `explain` and `tools/survey_hashes.ts` hold them. */
+export interface DeformSurveyInput {
+  skeletonText: string;
+  atlasText: string;
+  /** The model document (`skeleton.model.json`), or `null` when the input carries none (a Spine export). */
+  modelText: string | null;
+  /** What a refusal names the survey's input as; `the deform survey` unstated. */
+  label?: string;
+}
+
+/**
+ * The survey of a build, through the reader and poser asked for (issues #969,
+ * #1019): `model` — the model document's structure posed by the core,
+ * refused when there is none or when the Spine file beside it is not the one
+ * it records; `spine-core` — the Spine skeleton read and posed by the runtime;
+ * `auto` — the model document when the input carries one and the core poses
+ * it, spine-core otherwise, the reason named in `source.why`. On the model
+ * path spine-core is not touched: the Spine text is hashed, never parsed.
+ */
+export function surveyOfBuild(input: DeformSurveyInput, exempt: ReadonlySet<string>, asked: 'auto' | DeformSurveySource): DeformSurvey {
+  const label = input.label ?? 'the deform survey';
+  // `./deformmeasure.ts`'s reader and poser, through the seam: it touches the runtime first and refuses by name where it cannot be used.
+  const throughSpine = (why: string | null): DeformSurvey => spineSurveyFor(label, why ?? '--poser spine').throughSpine(label, why, input, exempt);
+  if (asked === 'spine-core') return throughSpine(null);
+  if (input.modelText === null) {
+    if (asked === 'model') throw new CoreInputError('the survey was asked to pose the model document, and the input carries none');
+    return throughSpine('the input carries no model document (skeleton.model.json), so the survey posed the Spine skeleton through spine-core');
+  }
+  try {
+    const doc = readModel(input.modelText);
+    // The document reads the rig it was built with; the Spine file beside it must be that build's (issue #968's rule).
+    const found = spineFileSha256(input.skeletonText);
+    if (found !== doc.spine.sha256) {
+      throw new CoreInputError(`the skeleton is not the one the model document was written beside: its sha256 is ${found}, the document records ${doc.spine.sha256 || 'none'}`);
+    }
+    return surveyOfModel(doc, exempt);
+  } catch (err) {
+    if (!(err instanceof CoreInputError) || asked === 'model') throw err;
+    return throughSpine(`the core refused to pose the model document — ${err.message}`);
+  }
+}

package/src/deformmeasure.ts

@@ -124,7 +124,7 @@ import {
   type Timeline,
 } from '@esotericsoftware/spine-core';
 // #969: the core's side of the seam — the model document read.
-import { CoreInputError, readModel } from './core/index.ts';
+import { readModel } from './core/index.ts';
 // #1019: what the survey reads of the skeleton's structure, and the model document's reading of it.
 import {
   modelStructure,
@@ -137,11 +137,15 @@ import {
   type SurveyStructure,
 } from './deformstructure.ts';
 // Issue #1025 (cut 4c-3): the half of the survey that names no runtime class.
-import { BEZIER_POINTS, corePoser, surveyOfModel, surveyWith, type DeformSurvey, type DeformSurveySource, type DialField, type ShownReading, type SurveyPose, type SurveyPoser } from './deformsurvey.ts';
-import { spineFileSha256 } from './model.ts';
-import { SpineRuntimeError } from './render.ts';
+import { BEZIER_POINTS, corePoser, surveyWith, type DeformSurvey, type DialField, type ShownReading, type SurveyPose, type SurveyPoser } from './deformsurvey.ts';
+// Issue #1052: the choice of reader and poser over a build is `./deformbuild.ts`'s, where an entry that links nothing of
+// the runtime can load it; this file's half of it — the survey through spine-core — is registered into the seam below.
+import type { DeformSurveyInput } from './deformbuild.ts';
+import { registerSpineSurvey, SpineRuntimeError, spineRuntimeSentence, SURVEY_RUNTIME_TAIL } from './spine_side.ts';
 
 export { BEZIER_POINTS, DEFORM_AREA_EPSILON, float32AreaNoise, stretchSingularValues, surveyOfModel, triangleAreas, unreachableWhy } from './deformsurvey.ts';
+export { surveyOfBuild } from './deformbuild.ts';
+export type { DeformSurveyInput } from './deformbuild.ts';
 export type {
   DeformDial,
   DeformDialDispute,
@@ -694,16 +698,6 @@ export function deformPosers(input: DeformSurveyInput & { modelText: string }):
   return { data, structure: side.structure, model: modelStructure(doc), spine: side.poser, core: corePoser(side.structure, doc) };
 }
 
-/** A build's three texts, as `explain` and `tools/survey_hashes.ts` hold them. */
-export interface DeformSurveyInput {
-  skeletonText: string;
-  atlasText: string;
-  /** The model document (`skeleton.model.json`), or `null` when the input carries none (a Spine export). */
-  modelText: string | null;
-  /** What a refusal names the survey's input as; `the deform survey` unstated. */
-  label?: string;
-}
-
 /**
  * Touch the runtime once, before the skeleton is parsed through it, and refuse
  * by name when it cannot be used (issue #1019) — the sentence `render` and
@@ -716,45 +710,23 @@ function requireSpineRuntime(label: string, why: string): void {
     // A property read on the class the parse starts from: no runtime code runs, and a runtime that cannot be used throws here.
     void TextureAtlas.prototype;
   } catch (err) {
-    throw new SpineRuntimeError(
-      `${label} is posed through spine-core (${why}), and the runtime could not be used: ${(err as Error).message}. ` +
-        'spine-core is what reads and poses a Spine export, --poser spine and a fallback the survey names; ' +
-        'a rigc build the core poses reads nothing through it',
-    );
+    // The sentence an entry that registered no Spine side is refused in too (`./spine_side.ts`), with the runtime's own words as the reason.
+    throw new SpineRuntimeError(spineRuntimeSentence(label, why, (err as Error).message, SURVEY_RUNTIME_TAIL));
   }
 }
 
 /**
- * The survey of a build, through the reader and poser asked for (issues #969,
- * #1019): `model` — the model document's structure posed by the core,
- * refused when there is none or when the Spine file beside it is not the one
- * it records; `spine-core` — the Spine skeleton read and posed by the runtime;
- * `auto` — the model document when the input carries one and the core poses
- * it, spine-core otherwise, the reason named in `source.why`. On the model
- * path spine-core is not touched: the Spine text is hashed, never parsed.
+ * The survey through spine-core — the half of `surveyOfBuild`
+ * (`./deformbuild.ts`, moved there unchanged in issue #1052) that names the
+ * runtime, registered into the seam when this file is loaded: it touches the
+ * runtime once (`requireSpineRuntime`), then reads and poses the Spine
+ * skeleton and names `why` as the survey's source. Every program that imports
+ * this file surveys as before; one that does not refuses this half by name.
  */
-export function surveyOfBuild(input: DeformSurveyInput, exempt: ReadonlySet<string>, asked: 'auto' | DeformSurveySource): DeformSurvey {
-  const label = input.label ?? 'the deform survey';
-  const throughSpine = (why: string | null): DeformSurvey => {
+registerSpineSurvey({
+  throughSpine: (label, why, input, exempt) => {
     requireSpineRuntime(label, why ?? '--poser spine');
     const side = runtimeSide(skeletonDataFromText(input.skeletonText, input.atlasText));
     return { ...surveyWith(side.structure, exempt, side.poser), source: { used: 'spine-core', why } };
-  };
-  if (asked === 'spine-core') return throughSpine(null);
-  if (input.modelText === null) {
-    if (asked === 'model') throw new CoreInputError('the survey was asked to pose the model document, and the input carries none');
-    return throughSpine('the input carries no model document (skeleton.model.json), so the survey posed the Spine skeleton through spine-core');
-  }
-  try {
-    const doc = readModel(input.modelText);
-    // The document reads the rig it was built with; the Spine file beside it must be that build's (issue #968's rule).
-    const found = spineFileSha256(input.skeletonText);
-    if (found !== doc.spine.sha256) {
-      throw new CoreInputError(`the skeleton is not the one the model document was written beside: its sha256 is ${found}, the document records ${doc.spine.sha256 || 'none'}`);
-    }
-    return surveyOfModel(doc, exempt);
-  } catch (err) {
-    if (!(err instanceof CoreInputError) || asked === 'model') throw err;
-    return throughSpine(`the core refused to pose the model document — ${err.message}`);
-  }
-}
+  },
+});

package/src/deformreport.ts

@@ -7,8 +7,8 @@
  * block is a report and not an assertion, and what it deliberately leaves out.
  */
 import type { CompileResult } from './types.ts';
-import type { DeformExtreme, DeformKeyMeasure, DeformSpan, DeformSurvey } from './deformmeasure.ts';
-import { unreachableWhy } from './deformmeasure.ts';
+import type { DeformExtreme, DeformKeyMeasure, DeformSpan, DeformSurvey } from './deformsurvey.ts';
+import { unreachableWhy } from './deformsurvey.ts';
 import { float32Step } from './timelines.ts';
 
 /**

package/src/framing.ts

@@ -55,7 +55,7 @@ import {
   viewportOfSize,
   type Frame,
   type Viewport,
-} from './render.ts';
+} from './render_shared.ts';
 
 /** How far a channel must move for a pixel to count as "not background". */
 export const BACKGROUND_TOLERANCE = 8;

package/src/pose.ts

@@ -80,7 +80,7 @@ import { Plate, readPlate } from '../tools/plate.ts';
 // straddles an edge. #301 deliberately left this call on the old arithmetic to
 // hold the fitting numbers still while the from-zero run 2 was in flight; #306
 // moved it, with the re-baseline of every figure that quoted a residual.
-import { bilinear } from './render.ts';
+import { bilinear } from './render_shared.ts';
 
 export class PoseError extends Error {}
 

package/src/preview.ts

@@ -45,7 +45,7 @@
  * loud when the script does not arrive.
  */
 import { SPINE_VERSION } from './compile.ts';
-import { BACKGROUND } from './render.ts';
+import { BACKGROUND } from './render_shared.ts';
 
 /**
  * The Spine Web Player line the generated page loads.

package/src/region_joins.ts

@@ -0,0 +1,54 @@
+/**
+ * Every atlas-region lookup a skeleton's attachments ask for, read off its raw
+ * JSON (issue #589) — moved here unchanged from `./validate.ts` (issue #1052),
+ * which re-exports it.
+ *
+ * Its own module because two readers need it and only one of them links the
+ * runtime: `A08`'s runtime supplier in `./validate.ts`, and `explain`, which
+ * refuses art it cannot pose (`refuseUnposableArt`) and runs in an entry that
+ * links nothing of spine-core. The walk names no runtime class — it reads the
+ * file, and is measured against the runtime's loader by `PS127`.
+ */
+import { attachmentRegionLookups, type AttachmentRegionJoin } from './assertions/region_lookups.ts';
+import { isObj } from './assertions/values.ts';
+
+/**
+ * Every atlas-region lookup `AtlasAttachmentLoader` will perform, read off the
+ * RAW skeleton JSON — before the loader is asked, which is the whole point.
+ *
+ * 🚨 This is a SECOND implementation of a join `spine-core` already performs,
+ * and the tree's standing judgment about a second opinion on somebody else's
+ * format is that it is measured rather than asserted: `PS127` runs the loader
+ * with its `findRegion` recording what it asked for, and compares. A wrong walk
+ * here would refuse correct foreign data by name, which is the one failure that
+ * would be worse than the silence #589 removed.
+ *
+ * Which entries resolve a region is the parser's list, not a guess:
+ * `SkeletonJson.readAttachment` (`dist/SkeletonJson.js:524-575`) calls the
+ * loader with a path for `region`, `mesh` and `linkedmesh` — a linked mesh
+ * resolves its own region before the `source` branch — and for nothing else.
+ * `type` defaults to `region` (`:527`), `name` to the placeholder (`:526`) and
+ * `path` to the name (`:529`, `:560`): three names that default into one
+ * another, which is why a report printing only the last of them cannot say
+ * what to change.
+ */
+export function attachmentRegionJoins(raw: unknown): AttachmentRegionJoin[] {
+  const joins: AttachmentRegionJoin[] = [];
+  if (!isObj(raw) || !Array.isArray(raw.skins)) return joins;
+  for (const skin of raw.skins as unknown[]) {
+    if (!isObj(skin) || !isObj(skin.attachments)) continue;
+    const skinName = typeof skin.name === 'string' ? skin.name : '(unnamed)';
+    for (const [slot, entries] of Object.entries(skin.attachments)) {
+      if (!isObj(entries)) continue;
+      for (const [placeholder, entry] of Object.entries(entries)) {
+        if (!isObj(entry)) continue;
+        const type = entry.type === undefined ? 'region' : entry.type;
+        if (type !== 'region' && type !== 'mesh' && type !== 'linkedmesh') continue;
+        const name = typeof entry.name === 'string' ? entry.name : placeholder;
+        const path = typeof entry.path === 'string' ? entry.path : name;
+        joins.push({ skin: skinName, slot, placeholder, name, lookups: attachmentRegionLookups(entry.sequence, path) });
+      }
+    }
+  }
+  return joins;
+}