spine-rigc 0.33.1 → 0.35.0

package/README.md

@@ -578,11 +578,11 @@ is in no field of the skeleton.
 **And over twelve skeletons nobody here wrote.** The same run ingests every editor
 export in the fetched example corpus, rebuilds it through the pack beside it and
 `diff`s the result against the source: **12 of 12, no blockers, 1.000 on every measure
-the report carries.** Byte identity is not the claim there and the reason is the input
-rather than the round trip — an editor header carries `hash` and `audio`, which the rig
-spec has no field for — so the contract is the structural one `diff` measures.
-[INGEST.md §2.3](docs/INGEST.md) has the three kinds of difference that remain, with
-what each is worth.
+the report carries** — and each rebuild is its export's own text in canonical form,
+apart from the header's `hash` and `spine`: the editor's project hash and the runtime
+version rigc stamps, the two keys the rig spec has no field for by design (`IG83`,
+12 of 12). [INGEST.md §2.3](docs/INGEST.md) states that pass line and why those two
+are the exceptions.
 
 **What it reads is skeleton JSON and nothing else** — no `.spine` project, no binary
 `.skel`, no atlas, no art. So it never invents, and the things it cannot get out of

package/cli.ts

@@ -86,7 +86,8 @@ import {
   type AtlasRegion,
 } from './src/atlas.ts';
 import { parseJsonWithPosition } from './src/json-position.ts';
-import { KEY_TIME_EPSILON } from './src/timelines.ts';
+import { PARSER_DEFAULTS, parserReading } from './src/keyorder.ts';
+import { float32Step } from './src/timelines.ts';
 import { findRung, RUNG_IDS, type RungSkeleton } from './src/ladder.ts';
 import {
   DEFAULT_MAX_RESIDUAL,
@@ -623,8 +624,30 @@ function meshFit(m: CompileResult['meshes'][number]): string {
   // why, in the place the figures stood, and prints no figure.
   if (m.fitWithheld !== undefined) return `  fit not measured: ${m.fitWithheld}. ${PAGE_GRID_UNLOCATED}`;
   if (m.coverage === undefined) return '';
-  const hole = m.holePixels ? `, enclosing ${m.holePixels}px of hole` : '';
-  return `  covers ${(m.coverage * 100).toFixed(2)}% of the art, reaching ${m.overshoot?.toFixed(2) ?? '?'}px past it${hole}`;
+  // A count of the plate's own cells, so on a `scale:` page it is texels and
+  // says so rather than borrowing the overshoot's unit beside it (issue #762).
+  const hole = m.holePixels ? `, enclosing ${m.holePixels}${m.pageScale === undefined ? 'px' : ' texel(s)'} of hole` : '';
+  return `  covers ${(m.coverage * 100).toFixed(2)}% of the art, reaching ${m.overshoot?.toFixed(2) ?? '?'}px past it${meshFitGrid(m)}${hole}`;
+}
+
+/**
+ * The grid a fit was taken on, when it is not the drawing's own (issue #762).
+ *
+ * The overshoot is stated in the drawing's pixels on every route — the unit an
+ * attachment's size is in — and on a page that declares a `scale:` other than
+ * 1 it was measured on the page's texels and divided by that scale. So it
+ * carries the coarser grid's step: on `scale: 0.5` a figure moves in steps of
+ * 2.00px of the drawing, and it need not equal the figure the page it was
+ * packed from reads except where the distance falls on whole texels. Said
+ * beside the figure, and nothing at all on a loose part or a page at scale 1,
+ * where the line is the one it always was.
+ */
+function meshFitGrid(m: CompileResult['meshes'][number]): string {
+  if (m.pageScale === undefined) return '';
+  return (
+    ` (the drawing's pixels, measured on the page's texels at scale: ${m.pageScale} — a texel is ` +
+    `${(1 / m.pageScale).toFixed(2)}px of the drawing)`
+  );
 }
 
 /**
@@ -739,12 +762,14 @@ function deformKeyName(key: DeformKeyMeasure): string {
  * The report's is the spec's own `t`; the survey's came back through
  * `Float32Array`, because that is what `spine-core` reads a timeline's frames
  * into — a key written `0.62` arrives as `0.6200000047683716`. So the tolerance
- * is the compiler's own key-time grid plus one float32 ulp at this magnitude,
- * which is narrower than any key spacing the format can hold and wide enough for
- * both roundings.
+ * is one float32 step at this magnitude (`float32Step`): the compiler emits a
+ * key time as a float's name — the spec's own time when it names one, the float
+ * below it when it does not (issue #716) — so the loaded float is within one
+ * step of the spec's `t` either way, which is narrower than any key spacing the
+ * format can hold.
  */
 function sameKeyTime(specTime: number, loaded: number): boolean {
-  return Math.abs(specTime - loaded) <= KEY_TIME_EPSILON + Math.abs(loaded) * 2 ** -23;
+  return Math.abs(specTime - loaded) <= float32Step(loaded);
 }
 
 /**
@@ -1159,6 +1184,30 @@ const SCALE_PRODUCT_NOTE =
  * foreign data. There is no honest SKIP either: an absent declaration is not
  * "nothing to measure", it is "no way to know what was meant".
  */
+/**
+ * An emitted key as the 4.3 parser reads it: every field its kind's
+ * `PARSER_DEFAULTS` row lists and the key leaves out, at the row's value, then
+ * the key's own fields. The emitter leaves a field at its parser default out
+ * (issue #716), so a report that reads the file needs the row to say what the
+ * runtime reads there — and reads it from the one table the emitter used.
+ */
+function asParsed(kind: string, key: Record<string, unknown>): Record<string, unknown> {
+  const row = PARSER_DEFAULTS[kind];
+  if (row === undefined) return key;
+  const site = { object: key, previous: () => null };
+  const filled: Record<string, unknown> = {};
+  for (const field of Object.keys(row)) {
+    const value = parserReading(row, site, field);
+    if (value !== undefined) filled[field] = value;
+  }
+  return { ...filled, ...key };
+}
+
+/** An emitted key's time as the parser reads it — `0` where the key leaves it out. */
+function keyTimeOf(kind: string, key: Record<string, unknown>): unknown {
+  return asParsed(kind, key).time;
+}
+
 function scaleProduct(timelineName: string, key: Record<string, unknown>): string {
   if (timelineName !== 'scale') return '';
   const x = key.x;
@@ -2806,7 +2855,11 @@ function cmdExplain(flags: Record<string, string>): void {
       for (const [timelineName, keys] of Object.entries(timelines)) {
         console.log(`    ${boneName}.${timelineName}  ${keys.length} key(s)${drives}`);
         if (timelineName === 'scale') console.log(`      ${SCALE_PRODUCT_NOTE}`);
-        for (const key of keys) {
+        for (const emitted of keys) {
+          // Every channel, as the parser reads it: a channel at its parser
+          // default is not in the file (issue #716), and this list shows the
+          // value a reader has to reason about rather than the bytes.
+          const key = asParsed(`bone ${timelineName} key`, emitted);
           const fields = Object.entries(key)
             .filter(([k]) => k !== 'time' && k !== 'curve')
             .map(([k, v]) => `${k}=${String(v)}`)
@@ -2823,7 +2876,8 @@ function cmdExplain(flags: Record<string, string>): void {
     for (const [slotName, timelines] of Object.entries(anim.slots ?? {})) {
       for (const [timelineName, keys] of Object.entries(timelines)) {
         console.log(`    ${slotName}.${timelineName}  ${keys.length} key(s)`);
-        for (const key of keys) {
+        for (const emitted of keys) {
+          const key = asParsed(`slot ${timelineName} key`, emitted);
           const curve = key.curve;
           const shape = Array.isArray(curve)
             ? `bezier[${curve.length}] ${curve.slice(12).join(', ')}  <- alpha channel, absolute (t,v)`
@@ -2851,7 +2905,7 @@ function cmdExplain(flags: Record<string, string>): void {
             .map(([k, v]) => `${k}=${String(v)}`)
             .join(' ');
           const curve = Array.isArray(key.curve) ? `bezier[${key.curve.length}]` : key.curve === 'stepped' ? 'stepped' : 'linear';
-          console.log(`      t=${String(key.time).padEnd(7)} ${(fields || '(all defaults)').padEnd(46)} ${curve}`);
+          console.log(`      t=${String(keyTimeOf(`${group} key`, key)).padEnd(7)} ${(fields || '(all defaults)').padEnd(46)} ${curve}`);
         }
       }
     }
@@ -2868,7 +2922,7 @@ function cmdExplain(flags: Record<string, string>): void {
               .map(([k, v]) => `${k}=${String(v)}`)
               .join(' ');
             const curve = Array.isArray(key.curve) ? `bezier[${key.curve.length}]` : key.curve === 'stepped' ? 'stepped' : 'linear';
-            console.log(`      t=${String(key.time).padEnd(7)} ${(fields || '(all defaults)').padEnd(46)} ${curve}`);
+            console.log(`      t=${String(keyTimeOf(`${group} ${timelineName} key`, key)).padEnd(7)} ${(fields || '(all defaults)').padEnd(46)} ${curve}`);
           }
         }
       }
@@ -2882,7 +2936,8 @@ function cmdExplain(flags: Record<string, string>): void {
         for (const [attName, timelines] of Object.entries(attMap)) {
           for (const [timelineName, keys] of Object.entries(timelines)) {
             console.log(`    ${skinName}/${slotName}/${attName}.${timelineName}  ${keys.length} key(s)`);
-            for (const key of keys) {
+            for (const emitted of keys) {
+              const key = asParsed(`attachment ${timelineName} key`, emitted);
               const run = Array.isArray(key.vertices) ? (key.vertices as number[]) : null;
               const offset = typeof key.offset === 'number' ? key.offset : 0;
               const span = run
@@ -2948,7 +3003,7 @@ function cmdExplain(flags: Record<string, string>): void {
               .map((o) => `${o.slot}${o.offset >= 0 ? '+' : ''}${o.offset}`)
               .join(' ')
           : 'back to the setup order';
-        console.log(`      t=${String(key.time).padEnd(7)} ${offsets}`);
+        console.log(`      t=${String(keyTimeOf('drawOrder key', key)).padEnd(7)} ${offsets}`);
       }
     }
   }