spine-rigc 1.6.1 → 1.7.0

package/src/check.ts

@@ -69,7 +69,7 @@ import {
   BACKGROUND,
   frameGeometry,
   PROTOCOL_FPS,
-  posableFromText,
+  loadCandidate,
   renderFrame,
   sampleAnimation,
   sampleSetupPose,
@@ -83,11 +83,8 @@ import {
   nonFinitePoseOf,
   unframeableSentence,
   UnframeablePoseError,
-  skinRosterOf,
-  candidatePosers,
-  spinePoser,
+  refuseUnchosen,
   throughPoser,
-  PoserChoiceError,
   SHEET_COLUMNS,
   SHEET_FILE,
   SHEET_GAP,
@@ -95,9 +92,10 @@ import {
   type Frame,
   type FramesSidecar,
   type FrameSet,
+  type MakeCorePoser,
+  type Posable,
   type PoseOptions,
   type Poser,
-  type PoserChoice,
   type PoserName,
   type TextureSubstitution,
   type Viewport,
@@ -1062,22 +1060,11 @@ export interface CheckOptions {
    * What builds the core poser — `candidatePosers`' own `make`. The suite's
    * `CH01` passes a planted copy, and nothing else passes any.
    */
-  makeCorePoser?: Parameters<typeof candidatePosers>[4];
+  makeCorePoser?: MakeCorePoser;
 }
 
-/**
- * Both posers for the candidate `check` is handed, and which one it asked for:
- * `candidatePosers` over the candidate's files when the caller named them, and
- * spine-core alone when it handed texts only — there is then no directory to
- * find a model document in, and the reason says so.
- */
-function checkPoserChoice(data: Parameters<typeof spinePoser>[0], options: CheckOptions): PoserChoice {
-  const paths = options.candidatePaths;
-  if (paths !== undefined) return candidatePosers(data, paths.skeleton, paths.atlas, options.poser, options.makeCorePoser);
-  const why = 'the candidate was handed to check as text, with no path to find a skeleton.model.json beside';
-  if (options.poser === 'core') throw new PoserChoiceError(`--poser core: ${why}`);
-  return { forced: options.poser, core: null, why: options.poser === 'spine' ? '--poser spine' : why, spine: spinePoser(data) };
-}
+/** Why a candidate handed to `check` as text alone is posed through spine-core — there is no directory to find a model document in. */
+const UNPLACED_CANDIDATE = 'the candidate was handed to check as text, with no path to find a skeleton.model.json beside';
 
 // ---------------------------------------------------------------------------
 
@@ -1145,14 +1132,27 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
   }
   const notes: string[] = [];
 
-  const posable = posableFromText(options.skeletonText, options.atlasText, options.atlasDir);
+  // Which implementation poses the candidate (issue #968), chosen once for the
+  // whole run — every set, the setup pose and the non-finite sentence — so no
+  // two figures in one report can come from two posers: `candidatePaths` over
+  // the candidate's files, as `render` chooses, and spine-core alone when it
+  // was handed texts only. Chosen BEFORE anything is read off the candidate
+  // (issue #1014), so a rigc build the core poses reads its names, its stage,
+  // its bone tree and its pages without loading spine-core.
+  const { choice, facts, pages } = loadCandidate(
+    { skeletonText: options.skeletonText, atlasText: options.atlasText, atlasDir: options.atlasDir, label: options.labels?.skeleton ?? 'the candidate' },
+    options.candidatePaths ?? null,
+    options.poser,
+    { ...(options.makeCorePoser === undefined ? {} : { make: options.makeCorePoser }), unplaced: UNPLACED_CANDIDATE },
+  );
+  const posable: Pick<Posable, 'pages'> = { pages };
   // A candidate that declares no stage is framed exactly as one that does,
   // because no framing here reads a stage: the world box is fitted from what the
   // candidate draws. Said on the one candidate where a reader can ask what box
   // stood in for the absent one (issue #714) — `SkeletonJson` copies the header
   // fields across unconditionally (`SkeletonJson.js:70-73`), so an omitted
-  // extent is `undefined` here, not 0.
-  if (typeof posable.data.width !== 'number' || typeof posable.data.height !== 'number') {
+  // extent is `undefined` there, not 0, and the header says the same.
+  if (!facts.declaresStage) {
     notes.push(
       'the candidate declares no stage (no `skeleton.width`/`height`), and nothing stands in for one: its world ' +
         'box is fitted from the pixels it draws, as it is for every candidate, so the absence moves no figure below.',
@@ -1167,18 +1167,16 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
   // The skin is refused here rather than deeper in the sampler, for the reason
   // every miss in this project is refused where the names are: the skeleton is
   // open on this line and the alternatives can be listed.
-  if (options.skin !== undefined && !posable.data.skins.some((s) => s.name === options.skin)) {
+  if (options.skin !== undefined && !facts.skins.includes(options.skin)) {
     throw new CheckError(
       `the candidate declares no skin ${JSON.stringify(options.skin)}; it declares [${
-        posable.data.skins.map((s) => s.name).join(', ') || 'none'
+        facts.skins.join(', ') || 'none'
       }]`,
     );
   }
-  // Which implementation poses the candidate (issue #968), chosen once for the
-  // whole run — every set, the setup pose and the non-finite sentence — so no
-  // two figures in one report can come from two posers. `--poser core` on an
-  // input that cannot carry it is refused here, before anything is posed.
-  const choice = checkPoserChoice(posable.data, options);
+  // `--poser core` on an input that cannot carry it is refused here, before
+  // anything is posed.
+  refuseUnchosen(choice);
   const poseOptions: PoseOptions | undefined =
     substitution || options.skin !== undefined
       ? { ...(substitution ? { texture: true } : {}), ...(options.skin === undefined ? {} : { skin: options.skin }) }
@@ -1220,7 +1218,7 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
     sets = [
       {
         dir,
-        animation: posable.data.animations.length === 0 ? null : animation,
+        animation: facts.animations.length === 0 ? null : animation,
         fps,
         sampled: disk[disk.length - 1].index + 1,
         written: disk.length,
@@ -1292,8 +1290,8 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
   // poser runs — the model document lists the spec's order, and a refusal that
   // listed the names in another order would be a byte of the report that
   // depends on the poser.
-  const have = posable.data.animations.map((a) => a.name);
-  const posing = throughPoser(choice, (poser) => {
+  const have = [...facts.animations];
+  const posing = throughPoser(choice, (poser, roster) => {
     const sampled = sets.map((set) => prepareSet(located.root, set, poser, have, options.as, poseOptions));
     // 🔒 A pose that is not finite is refused before anything measures it (issue
     // #873), in the words `render` and the geometry export use for it. Measured
@@ -1325,7 +1323,7 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
       posedSets.map((p) => p.frames),
       poser.slots,
       options.skin,
-      skinRosterOf(posable.data),
+      roster,
     );
     if (unframeable !== null) throw new UnframeablePoseError(unframeable);
     return sampled;
@@ -1433,7 +1431,7 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
     throw new CheckError(
       `no reference frame could be compared, so there is nothing to frame against${nothingToFrameWhy(
         prepared,
-        posable.data.animations.map((a) => a.name),
+        [...facts.animations],
         options.as,
         located.sidecar !== null,
       )}`,
@@ -1574,8 +1572,8 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
   // `src/chains.ts`. Reading the CANDIDATE's tree is what keeps this on the right
   // side of the honesty rule: the reference is still nothing but pixels.
   const chains = chainsOf(
-    posable.data.bones.map((bone) => ({ name: bone.name, parent: bone.parent === null ? null : bone.parent.name })),
-    posable.data.slots.map((slot) => ({ name: slot.name, bone: slot.boneData.name })),
+    facts.bones.map(({ name, parent }) => ({ name, parent })),
+    facts.slots.map(({ name, bone }) => ({ name, bone })),
   );
   const chainOfSlot = new Map<string, number>();
   chains.forEach((chain, index) => {
@@ -2629,7 +2627,7 @@ function nothingToFrameWhy(
 function checkOneSet(
   root: string,
   prepared: PreparedSet,
-  posable: ReturnType<typeof posableFromText>,
+  posable: Pick<Posable, 'pages'>,
   framing: SetFraming,
   background: RGBA,
   chains: BoneChain[],
@@ -3310,7 +3308,7 @@ function labelBox(index: number): { width: number; height: number } {
 function checkAgainstSheet(
   root: string,
   prepared: PreparedSet,
-  posable: ReturnType<typeof posableFromText>,
+  posable: Pick<Posable, 'pages'>,
   viewport: Viewport,
   background: RGBA,
 ): { sheet: SheetCheck | null; notes: string[] } {

package/src/compile.ts

@@ -128,6 +128,8 @@ import {
   type BoneTransform,
 } from './transform.ts';
 import { emitSkeleton, PHYSICS_PARAMS, UNSTATED_REFERENCE_SCALE, type SkeletonHeader } from './emit_spine.ts';
+import { curveLengthTable } from './core/constraints_path.ts';
+import { frameRegionName } from './core/uvs.ts';
 import {
   isModelVertexAttachment,
   type CarriedFromCompileResult,
@@ -1979,8 +1981,9 @@ function resolveFromAtlas(
  * ⭐ *Either way* was not true for a pack that turns a region until issue #570:
  * `extractRegion` refused a `rotate: 90`, so how the art was delivered decided
  * whether a measurement could be taken at all — on a foreign pack, where turning
- * is the norm rather than the exception. It now transcribes the runtime's own
- * mapping for all four rotations, which is what makes the sentence above a
+ * is the norm rather than the exception. It now lifts every rotation, measured
+ * as `extractRegion` states (`PKR02` against the runtime's own sampling, `PK29`
+ * against the packer's fixture), which is what makes the sentence above a
  * description rather than an aspiration.
  */
 function partPlate(img: CompiledImage): Plate {
@@ -3802,10 +3805,12 @@ interface AttachmentContext {
    * Linked meshes whose `source` is still unresolved — `resolveLinkedMeshes`
    * empties it once every skin has been built.
    *
-   * ⭐ Deferred for the reason spine-core defers its own (`this.linkedMeshes`,
-   * `SkeletonJson.js:56` filled at `:581` and drained at `:427-449`): a link may
-   * name a source in a skin or a slot this loop has not reached yet, so resolving
-   * it in place would refuse a correct rig on nothing but declaration order.
+   * ⭐ Deferred because the format resolves a link only once every skin is
+   * read — the reader queues each one (`this.linkedMeshes`, `SkeletonJson.js:56`
+   * filled at `:581`) and resolves the queue after the skins (`:427-449`) — so
+   * a link may name a source in a skin or a slot this loop has not reached yet,
+   * and resolving it in place would refuse a correct rig on nothing but
+   * declaration order.
    */
   links: PendingLink[];
 }
@@ -4195,8 +4200,11 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
 }
 
 /**
- * Cumulative arc length at the end of each curve of the chain, in world units —
- * **the runtime's own measurement, restated line for line**.
+ * Cumulative length at the end of each curve of the chain, in world units —
+ * **the core's curve table** (`curveLengthTable` in
+ * [`src/core/constraints_path.ts`](core/constraints_path.ts), issue #1015), the
+ * one the core's path constraint walks at constant speed. This function only
+ * flattens the chain and counts its curves.
  *
  * One entry per curve, which is what `lengths[curve]` indexes: the parser walks
  * curves with `if (p > lengths[curve]) continue`, and reads `lengths[curveCount]`
@@ -4206,12 +4214,16 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  * fact about the Bezier, it is the number the consumer of the field computes for
  * itself when it is not given one. `PathConstraint.computeWorldPositions`
  * (`PathConstraint.js:289-324` in `@esotericsoftware/spine-core` 4.3.13) measures
- * a `constantSpeed` path with a cubic **forward difference** taken at `t = 1/4`
- * — `0.1875 = 3t²`, `0.09375 = 6t³`, `0.75 = 3t`, `0.16666667` standing in for
- * 1/6 — accumulating four `Math.sqrt` terms per curve into a running
- * `pathLength`, and writing the running value into `curves[i]` at each curve's
- * end. The Spine editor's exported `lengths` are that same computation, and the
- * loop below is a transcription of it, not a sampler that happens to agree.
+ * a `constantSpeed` path for itself, and the Spine editor's exported `lengths`
+ * are the same number. What that number is was measured, not read: the core's
+ * table — four forward-difference steps per curve at `t = 1/4` (`0.1875`,
+ * `0.09375`, `0.75`, `0.16666667`), four `Math.sqrt` terms accumulated into a
+ * running total carried across curves — is the rule its header states with the
+ * readings that missed beside it, and `PS67`, `PS68` and `PS186` in
+ * `selftest.ts` hold this function to `PathConstraint`'s own `curves` array read
+ * off a posed skeleton, **bit for bit**. Since issue #1015 the core suite also
+ * holds the swap: 100,000 seeded chains through this function and through the
+ * arithmetic it replaced, 0 differing.
  *
  * 🚨 **What that computation is fed decides the number, and this comment once
  * claimed more than was measured** (issue #804). It said the loop matched the
@@ -4223,8 +4235,8 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  *     vertices. rigc blends weighted vertices through its own setup transforms,
  *     which until #804 ignored bone scale, shear and `inherit` — 2.35× the
  *     runtime's own `curves` on a production rig's weighted path, 0.752× on a
- *     50/50 probe over a bone at scale 2. `computeWorldTransforms` is now the
- *     runtime's, and the gap is gone on both.
+ *     50/50 probe over a bone at scale 2. `computeWorldTransforms` honours all
+ *     three now, and the gap is gone on both.
  *   - **Constraints.** The runtime measures the pose its update order hands the
  *     path constraint at the first `updateWorldTransform`: a transform
  *     constraint on the path's slot bone ordered BEFORE the path constraint
@@ -4232,11 +4244,11 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  *     not. A production 4.2 export's four numbers are the constrained pose's to
  *     the digit, and its unconstrained setup measures 76.08 against 76.65 on the
  *     first curve. Reproducing that means solving every constraint type in
- *     update order, which is posing — and `src/compile.ts` does not link the
- *     runtime. ⇒ **An omitted `lengths` is measured on the unconstrained setup
- *     pose**, and a path whose bones a constraint moves at rest gets that
- *     figure. What closes the gap for an editor export is not measuring at all:
- *     a stated `lengths` is carried (`buildRigPath`).
+ *     update order, which is posing — and `src/compile.ts` does not pose. ⇒
+ *     **An omitted `lengths` is measured on the unconstrained setup pose**, and
+ *     a path whose bones a constraint moves at rest gets that figure. What
+ *     closes the gap for an editor export is not measuring at all: a stated
+ *     `lengths` is carried (`buildRigPath`).
  *
  * ⚠️ rigc measured this with a 64-chord sum until issue #560, and the comment
  * that stood here argued the difference was inside anything's tolerance. It was
@@ -4247,46 +4259,17 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  * two apart and since issue #716 rigc's own file can only where the two land on
  * either side of a float's boundary. Under the six-decimal rounding that stood
  * until then it could: on both measured rigs the two spellings differed on the
- * LAST curve, where the accumulated difference is largest. `PS67`, `PS68` and `PS186` in `selftest.ts` compare
- * this against `PathConstraint`'s own `curves` array read off a posed skeleton,
- * which is the only oracle that can see that gap.
- *
- * 🔒 The transcription is deliberate down to the spelling: `Math.sqrt(dx * dx +
- * dy * dy)` rather than `Math.hypot`, `0.16666667` rather than `1 / 6`, and the
- * running total carried across curves rather than restarted. Each of those is a
- * place where a more accurate line would emit a different file.
+ * LAST curve, where the accumulated difference is largest.
+ *
+ * 🔒 The spelling is load-bearing: `Math.sqrt(dx * dx + dy * dy)` rather than
+ * `Math.hypot`, `0.16666667` rather than `1 / 6`, and the running total carried
+ * across curves rather than restarted. Each of those is a place where a more
+ * accurate line would emit a different file.
  */
 export function pathCurveLengths(chain: Array<[number, number]>): number[] {
-  const out: number[] = [];
-  let total = 0;
-  for (let c = 0; c + 3 < chain.length; c += 3) {
-    const [x1, y1] = chain[c];
-    const [cx1, cy1] = chain[c + 1];
-    const [cx2, cy2] = chain[c + 2];
-    const [x2, y2] = chain[c + 3];
-    const tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
-    const tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
-    const dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-    const dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-    let ddfx = tmpx * 2 + dddfx;
-    let ddfy = tmpy * 2 + dddfy;
-    let dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
-    let dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx;
-    dfy += ddfy;
-    ddfx += dddfx;
-    ddfy += dddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx;
-    dfy += ddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx + dddfx;
-    dfy += ddfy + dddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    out.push(total);
-  }
-  return out;
+  const flat: number[] = [];
+  for (const [x, y] of chain) flat.push(x, y);
+  return curveLengthTable(flat, Math.max(0, Math.floor((chain.length - 1) / 3)));
 }
 
 /**
@@ -4516,20 +4499,22 @@ function meshTextureKeys(att: { name?: string; path?: string; image?: string; co
 }
 
 /**
- * The atlas region frame `i` of a sequence resolves to — `Sequence.getPath`
- * (`Sequence.js:124-132`) transcribed: the stem, then `start + i` left-padded
- * with zeros to `digits`. `start` and `digits` take the parser's own defaults
- * (`readSequence`: 1 and 0), which are the format's, not a guess.
- *
- * ⚠️ A second transcription of the rule exists in `validate.ts`
- * (`attachmentRegionLookups`, the walk `A08` joins the atlas with), and that is
- * deliberate: this module links no runtime, and the two are held to the loader
- * independently — the one by `A08`, both by `A00`'s round trip, which asks the
- * runtime's own `getPath` for every frame.
+ * The atlas region frame `i` of a sequence resolves to — the core's
+ * `frameRegionName` (`src/core/uvs.ts`, issue #1015): the stem, then `start + i`
+ * left-padded with zeros to `digits`. `start` and `digits` take the parser's
+ * defaults when the spec leaves them out (`readSequence`: 1 and 0).
+ *
+ * ⚠️ The same name is derived in `validate.ts` (`attachmentRegionLookups`, the
+ * walk `A08` joins the atlas with) through the same function. What holds it to
+ * the loader is a measurement, not this sentence: the core suite reads
+ * `Sequence.getPath` and the parser's defaults off spine-core over 7,680 cases
+ * and compares this function, the core's and A08's walk with them, and `A00`'s
+ * round trip asks the runtime's own `getPath` for every frame a build emits.
+ *
+ * Exported for the selftest alone.
  */
-function sequenceFrameRegion(stem: string, seq: RigSequence, i: number): string {
-  const frame = String((seq.start ?? 1) + i);
-  return `${stem}${'0'.repeat(Math.max(0, (seq.digits ?? 0) - frame.length))}${frame}`;
+export function sequenceFrameRegion(stem: string, seq: RigSequence, i: number): string {
+  return frameRegionName(stem, { count: seq.count, start: seq.start ?? 1, digits: seq.digits ?? 0, setup: seq.setup ?? 0 }, i);
 }
 
 /** The model's `sequence` record: the four fields exactly as the spec stated them. */
@@ -4796,8 +4781,8 @@ function bindNamedWeights(weights: RigMeshBinding[][], where: string, ctx: Attac
  * an `image` under `--atlas-in` ENDED the build, by a refusal raised inside a
  * measurement, on 36 of 42 atlases of the pack the card was filed from. The
  * repair was to make the refusal unnecessary rather than to catch it: reading a
- * turned region is a transcription of `MeshAttachment.computeUVs` and is now
- * what `extractRegion` does, so there is no unmeasurable case left for this
+ * turned region is now what `extractRegion` does, measured against
+ * `MeshAttachment.computeUVs` (`PKR02`), so there is no unmeasurable case left for this
  * function to report and no catch here to keep reachable.
  */
 function measureAuthoredFit(

package/src/core/constraints_path.ts

@@ -44,8 +44,9 @@
  *
  * 1. **A table of the curves' lengths**, each curve four forward-difference
  *    steps (`0.1875`, `0.09375`, `0.75` and `0.16666667`, the running total
- *    carried across curves) — `pathCurveLengths` in `src/compile.ts`, the
- *    same arithmetic. A ten-step table missed 460 of the grid's 976. The
+ *    carried across curves) — `curveLengthTable`, which `src/compile.ts`'s
+ *    `pathCurveLengths` also calls (issue #1015). A ten-step table missed
+ *    460 of the grid's 976. The
  *    last entry is the path's length; `percent` multiplies the position by
  *    it. The stated `lengths` are not read: the stated total in their place
  *    missed 680 of 1,000.
@@ -217,6 +218,60 @@ import type { CoreCurve, CoreKey } from './animation.ts';
 import type { CoreConstraintRecord } from './constraints.ts';
 
 const RAD = RUNTIME_PI / 180;
+
+/**
+ * The constant-speed walk's table of the curves' lengths — the header's *The
+ * walk*, step 1: each curve four forward-difference steps (`0.1875`,
+ * `0.09375`, `0.75`, `0.16666667`), the running total carried across curves,
+ * one cumulative entry per curve. `chain` is flat, `x, y` per point, knot
+ * handle handle knot …; `curveCount` curves are read off it.
+ *
+ * Exported because it has a second caller: an omitted `lengths` on a path
+ * attachment is measured by `src/compile.ts` through this function (issue
+ * #1015), so the number rigc writes into a file and the number the core walks
+ * are one computation. Measured as the header states it on the grid (a
+ * ten-step table missed 460 of 976) and held there by the core suite's `CP`
+ * controls.
+ */
+export function curveLengthTable(chain: readonly number[], curveCount: number): number[] {
+  const curveEnds: number[] = [];
+  let total = 0;
+  let x1 = chain[0];
+  let y1 = chain[1];
+  for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
+    const cx1 = chain[w];
+    const cy1 = chain[w + 1];
+    const cx2 = chain[w + 2];
+    const cy2 = chain[w + 3];
+    const x2 = chain[w + 4];
+    const y2 = chain[w + 5];
+    const h2x = (x1 - cx1 * 2 + cx2) * 0.1875;
+    const h2y = (y1 - cy1 * 2 + cy2) * 0.1875;
+    const d3x = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+    const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+    let d2x = h2x * 2 + d3x;
+    let d2y = h2y * 2 + d3y;
+    let d1x = (cx1 - x1) * 0.75 + h2x + d3x * 0.16666667;
+    let d1y = (cy1 - y1) * 0.75 + h2y + d3y * 0.16666667;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x;
+    d1y += d2y;
+    d2x += d3x;
+    d2y += d3y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x;
+    d1y += d2y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x + d3x;
+    d1y += d2y + d3y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    curveEnds.push(total);
+    x1 = x2;
+    y1 = y2;
+  }
+  return curveEnds;
+}
+
 const EPSILON = 0.00001;
 
 /** The three modes a path constraint names, each as the model spells it once its first letter is lower-cased. */
@@ -556,47 +611,14 @@ function positionsOf(state: PathSolverState, c: CorePathRecord, g: CorePathGeome
     chain.push(...P(0), ...P(1));
   } else for (let k = 1; k < n - 1; k++) chain.push(...P(k));
   const curveCount = closed ? n / 3 : n / 3 - 1;
-  const curveEnds: number[] = [];
-  let total = 0;
-  let x1 = chain[0];
-  let y1 = chain[1];
-  for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
-    const cx1 = chain[w];
-    const cy1 = chain[w + 1];
-    const cx2 = chain[w + 2];
-    const cy2 = chain[w + 3];
-    const x2 = chain[w + 4];
-    const y2 = chain[w + 5];
-    const h2x = (x1 - cx1 * 2 + cx2) * 0.1875;
-    const h2y = (y1 - cy1 * 2 + cy2) * 0.1875;
-    const d3x = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-    const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-    let d2x = h2x * 2 + d3x;
-    let d2y = h2y * 2 + d3y;
-    let d1x = (cx1 - x1) * 0.75 + h2x + d3x * 0.16666667;
-    let d1y = (cy1 - y1) * 0.75 + h2y + d3y * 0.16666667;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x;
-    d1y += d2y;
-    d2x += d3x;
-    d2y += d3y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x;
-    d1y += d2y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x + d3x;
-    d1y += d2y + d3y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    curveEnds.push(total);
-    x1 = x2;
-    y1 = y2;
-  }
+  const curveEnds = curveLengthTable(chain, curveCount);
+  const total = curveEnds.length > 0 ? curveEnds[curveEnds.length - 1] : 0;
   if (c.positionMode === 'percent') position *= total;
   const spaceScale = c.spacingMode === 'percent' ? total : c.spacingMode === 'proportional' ? total / spaceCount : 1;
   const segmentEnds: number[] = new Array(10).fill(0);
   let curveTotal = 0;
   let lastCurve = -1;
-  let cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
+  let x1 = 0, y1 = 0, cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
   for (let i = 0, o = 0, curve = 0, segment = 0; i < spaceCount; i++, o += 3) {
     const space = spaces[i] * spaceScale;
     position += space;

package/src/core/constraints_physics.ts

@@ -561,6 +561,27 @@ export function physicsState(ctx: PhysicsStepContext, name: string): PhysicsStat
 const PI2 = RUNTIME_PI * 2;
 const INV_PI2 = 1 / PI2;
 
+/** What a physics constraint's step moves, by its five component fields. */
+export interface PhysicsDrives {
+  x: boolean;
+  y: boolean;
+  /** `rotate` or `shearX` above 0: the two share the angular part of the step. */
+  rotateOrShearX: boolean;
+  scaleX: boolean;
+}
+
+/**
+ * Which parts of the step a constraint drives: a component above 0 drives its
+ * part and nothing else does — the test `stepPhysics` takes before each part
+ * of *The step* above, posed against the runtime with the rest of it. Exported
+ * because `src/ingest.ts` asks the same question of a raw file (a
+ * constraint that drives none of the four moves no bone, issue #731) and
+ * answers it through this function (issue #1015).
+ */
+export function physicsDrives(r: { x: number; y: number; rotate: number; shearX: number; scaleX: number }): PhysicsDrives {
+  return { x: r.x > 0, y: r.y > 0, rotateOrShearX: r.rotate > 0 || r.shearX > 0, scaleX: r.scaleX > 0 };
+}
+
 /**
  * One physics constraint updated on its bone's world transform `w`
  * (mutated), `length` the bone's length — the header's *The step*, every
@@ -572,10 +593,7 @@ export function stepPhysics(r: CorePhysicsRecord, w: CoreWorld, length: number,
   const mix = r.mix;
   if (mix === 0) return false;
   const s = physicsState(ctx, r.name);
-  const x = r.x > 0;
-  const y = r.y > 0;
-  const rotateOrShearX = r.rotate > 0 || r.shearX > 0;
-  const scaleX = r.scaleX > 0;
+  const { x, y, rotateOrShearX, scaleX } = physicsDrives(r);
   const l = length;
   if (ctx.phase === 'reset') resetPhysicsState(s, ctx.time);
   const delta = Math.max(ctx.time - s.lastTime, 0);