spine-rigc 2.45.0 → 2.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.45.0",
+  "version": "2.45.1",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/assertions/footprints.ts

@@ -59,6 +59,7 @@ import { FOOTPRINT_SLACK, pageFootprint } from '../atlas.ts';
 import type { AtlasRegionEntry, AtlasRegionFacts } from './facts/atlas_regions.ts';
 import type { MeshEntry, MeshFacts } from './facts/mesh_attachments.ts';
 import type { RegionJoinFacts } from './facts/region_joins.ts';
+import { hypot2 } from '../numeric.ts';
 
 /** A point in page texels, x right and y down from the page's top-left. */
 export type PagePoint = readonly [number, number];
@@ -266,7 +267,7 @@ export function piecesOverlap(a: readonly PagePoint[], b: readonly PagePoint[]):
       const q = poly[(i + 1) % poly.length];
       const nx = q[1] - p[1];
       const ny = p[0] - q[0];
-      const len = Math.hypot(nx, ny);
+      const len = hypot2(nx, ny);
       if (len === 0) continue;
       let minA = Infinity;
       let maxA = -Infinity;

package/src/bonedist.ts

@@ -85,6 +85,7 @@ import {
   type Posable,
 } from './render.ts';
 import { BONEDIST_SPEC, IDENTITY_CORRESPONDENCE } from './correspondence.ts';
+import { hypot2 } from './numeric.ts';
 
 export class BoneDistError extends Error {}
 
@@ -193,7 +194,7 @@ function skeletonSize(posable: Pick<Posable, 'data'>): SkeletonSize {
   let size = 0;
   let farthest: string | null = null;
   for (const bone of bones) {
-    const distance = Math.hypot(bone.worldX - root.worldX, bone.worldY - root.worldY);
+    const distance = hypot2(bone.worldX - root.worldX, bone.worldY - root.worldY);
     if (distance > size) {
       size = distance;
       farthest = bone.name;
@@ -244,7 +245,7 @@ function deltaOf(
   const rx = (reference.worldX - referenceRoot.worldX) / rScale;
   const ry = (reference.worldY - referenceRoot.worldY) / rScale;
   return {
-    position: Math.hypot(cx - rx, cy - ry),
+    position: hypot2(cx - rx, cy - ry),
     rotation: Math.abs(wrapDegrees(candidate.rotationX - reference.rotationX)),
     scale: Math.max(Math.abs(candidate.scaleX - reference.scaleX), Math.abs(candidate.scaleY - reference.scaleY)),
     linear: Math.max(

package/src/chainfit.ts

@@ -106,6 +106,7 @@ import {
   type Samples,
 } from './pose.ts';
 import type { SpineBone, SpineRegionAttachment, SpineSkeletonJson } from './types.ts';
+import { hypot2 } from './numeric.ts';
 
 export class ChainFitError extends Error {}
 
@@ -844,7 +845,7 @@ function solveFromDescendants(points: InwardPoint[]): BonePlace | null {
   if (!(spread > 1e-12)) return null;
   const p = dotp / spread;
   const q = dotq / spread;
-  const unit = Math.hypot(p, q);
+  const unit = hypot2(p, q);
   if (!(unit > 1e-9)) return null;
   return {
     x: mX - p * ma + q * mb,
@@ -991,7 +992,7 @@ function stampCover(into: Uint8Array, width: number, height: number, part: Plate
   const sin = Math.sin(pl.rotDeg * DEG);
   const halfW = part.width / 2;
   const halfH = part.height / 2;
-  const reach = Math.hypot(halfW, halfH) * pl.scale + 1;
+  const reach = hypot2(halfW, halfH) * pl.scale + 1;
   const x0 = Math.max(0, Math.floor(pl.cx - reach));
   const x1 = Math.min(width - 1, Math.ceil(pl.cx + reach));
   const y0 = Math.max(0, Math.floor(pl.cy - reach));
@@ -1665,7 +1666,7 @@ export function estimateChainFit(options: ChainFitOptions): ChainFitReport {
         anchoredTo.set(name, name);
         carried.set(name, []);
         if (chainPlace !== null) {
-          pivotDisagreement.set(name, Math.hypot(chainPlace.x - place.x, chainPlace.y - place.y));
+          pivotDisagreement.set(name, hypot2(chainPlace.x - place.x, chainPlace.y - place.y));
         }
         continue;
       }
@@ -1757,7 +1758,7 @@ export function estimateChainFit(options: ChainFitOptions): ChainFitReport {
       let lever = 0;
       for (let i = 0; i < usable.length; i++) {
         for (let j = i + 1; j < usable.length; j++) {
-          lever = Math.max(lever, Math.hypot(usable[i].place.x - usable[j].place.x, usable[i].place.y - usable[j].place.y));
+          lever = Math.max(lever, hypot2(usable[i].place.x - usable[j].place.x, usable[i].place.y - usable[j].place.y));
         }
       }
       if (solved === null) {
@@ -1790,8 +1791,8 @@ export function estimateChainFit(options: ChainFitOptions): ChainFitReport {
         return {
           bone: u.bone,
           part: u.part,
-          leverPx: roundTo(Math.hypot(u.place.x - solved.x, u.place.y - solved.y), 3),
-          offsetPx: roundTo(Math.hypot(px - u.place.x, py - u.place.y), 4),
+          leverPx: roundTo(hypot2(u.place.x - solved.x, u.place.y - solved.y), 3),
+          offsetPx: roundTo(hypot2(px - u.place.x, py - u.place.y), 4),
           carried: u.carried,
         };
       });

package/src/check.ts

@@ -98,6 +98,7 @@ import {
   type TextureSubstitution,
   type Viewport,
 } from './render_shared.ts';
+import { hypot2 } from './numeric.ts';
 // The one name here that is the runtime's: a candidate's pages, read off the shape spine-core's loader returns.
 import type { Posable } from './render.ts';
 import {
@@ -3699,7 +3700,7 @@ export function checkLines(report: CheckReport, opts?: { allFrames?: boolean }):
   lines.push('  `⤷ bounded by` line under a drift is what that figure could have reached: for a');
   lines.push(`  template match, its whole-pixel winner plus ${SUBPIXEL_CLAMP} px on each axis — so a winner at`);
   lines.push(
-    `  the offset you drew bounds the whole figure at ${Math.hypot(SUBPIXEL_CLAMP, SUBPIXEL_CLAMP).toFixed(2)} px ` +
+    `  the offset you drew bounds the whole figure at ${hypot2(SUBPIXEL_CLAMP, SUBPIXEL_CLAMP).toFixed(2)} px ` +
       'and says the drift is the',
   );
   lines.push('  instrument, not the rig. Read every drift against its own line and not against a page.');

package/src/compile.ts

@@ -35,6 +35,7 @@ import {
 } from './depth.ts';
 import { CompileError, NotImplementedError } from './errors.ts';
 import { parseJsonWithPosition } from './json-position.ts';
+import { hypot2 } from './numeric.ts';
 // The "did you mean" list on a missing atlas region, from the one implementation
 // of it — the same search serves `refuseUnknownKeys`, and a second copy here with
 // a threshold edited is how such a pair drifts apart.
@@ -7581,7 +7582,7 @@ function checkAxisSelfConsistency(manifest: FaceManifest): void {
   }
   const ex = Math.cos((deg * Math.PI) / 180);
   const ey = Math.sin((deg * Math.PI) / 180);
-  if (Math.hypot(unit[0] - ex, unit[1] - ey) > 1e-3) {
+  if (hypot2(unit[0] - ex, unit[1] - ey) > 1e-3) {
     throw new CompileError(
       `manifest axis.unit [${unit[0]}, ${unit[1]}] does not match axis.deg ${deg} (expected [${f32(ex)}, ${f32(ey)}])`,
     );

package/src/deformgen.ts

@@ -56,6 +56,7 @@
  */
 
 import { CompileError } from './errors.ts';
+import { hypot2 } from './numeric.ts';
 
 /** Which coordinate a bend or a wave reads, and which one it displaces. */
 export type DeformAxis = 'x' | 'y';
@@ -569,7 +570,7 @@ export function evaluateDeformTransform(
   let maxOffset = 0;
   let maxOffsetVertex = 0;
   for (let v = 0; v < count; v++) {
-    const m = Math.hypot(offsets[2 * v], offsets[2 * v + 1]);
+    const m = hypot2(offsets[2 * v], offsets[2 * v + 1]);
     if (m > maxOffset) {
       maxOffset = m;
       maxOffsetVertex = v;

package/src/deformsurvey.ts

@@ -26,6 +26,7 @@ import { CoreInputError, underSkin, type CompiledDocument } from './core/index.t
 import { float32Rows, meshWorld, poseDial as corePoseDial, poseJump, recordIdentity, sliderRecordOf, slotDraw, type CoreSurveyPose } from './core/hooks.ts';
 import { modelStructure, type SurveyAnimation, type SurveyDeformTimeline, type SurveyMesh, type SurveySkin, type SurveySlider, type SurveyStructure } from './deformstructure.ts';
 import { areaBand, DEFORM_AREA_EPSILON, float32AreaNoise, stretchSingularValues, triangleAreas } from './areaband.ts';
+import { hypot2 } from './numeric.ts';
 
 // The area band lives in `src/areaband.ts` (moved unchanged, issue #1224) so the
 // geometry entry can read it without reaching the compiler, and
@@ -1433,7 +1434,7 @@ function measurePosed(
     const dy = deformed[v * 2 + 1] - plain[v * 2 + 1];
     if (dx === 0 && dy === 0) continue;
     moved++;
-    const distance = Math.hypot(dx, dy);
+    const distance = hypot2(dx, dy);
     if (distance > maxDisplacement) {
       maxDisplacement = distance;
       maxDisplacementVertex = v;

package/src/framing.ts

@@ -56,6 +56,7 @@ import {
   type Frame,
   type Viewport,
 } from './render_shared.ts';
+import { hypot2 } from './numeric.ts';
 
 /** How far a channel must move for a pixel to count as "not background". */
 export const BACKGROUND_TOLERANCE = 8;
@@ -511,7 +512,7 @@ function cornerSpread(box: ContentBox, displace: (x: number, y: number) => [numb
     [right, bottom],
   ]) {
     const [dx, dy] = displace(x, y);
-    worst = Math.max(worst, Math.hypot(dx, dy));
+    worst = Math.max(worst, hypot2(dx, dy));
   }
   return worst;
 }

package/src/inspect.ts

@@ -70,6 +70,7 @@ import {
   type Viewport,
   viewportFor,
 } from './render_shared.ts';
+import { hypot2 } from './numeric.ts';
 
 /** The legend's format tag. */
 export const INSPECT_SPEC = 'rigc-inspect/1';
@@ -1553,9 +1554,9 @@ function drawTile(
         entry.from = point(a.worldX, a.worldY);
         entry.to = point(b.worldX, b.worldY);
         // Across the whole tile: extend the line past both ends by the tile's diagonal, in world units.
-        const reach = Math.hypot(viewport.maxX - viewport.minX, viewport.maxY - viewport.minY);
-        const ux = (b.worldX - a.worldX) / Math.hypot(b.worldX - a.worldX, b.worldY - a.worldY);
-        const uy = (b.worldY - a.worldY) / Math.hypot(b.worldX - a.worldX, b.worldY - a.worldY);
+        const reach = hypot2(viewport.maxX - viewport.minX, viewport.maxY - viewport.minY);
+        const ux = (b.worldX - a.worldX) / hypot2(b.worldX - a.worldX, b.worldY - a.worldY);
+        const uy = (b.worldY - a.worldY) / hypot2(b.worldX - a.worldX, b.worldY - a.worldY);
         const [p0x, p0y] = toPixel(a.worldX - ux * reach, a.worldY - uy * reach);
         const [p1x, p1y] = toPixel(a.worldX + ux * reach, a.worldY + uy * reach);
         line(tile, tx(p0x) + shiftX, ty(p0y) + shiftY, tx(p1x) + shiftX, ty(p1y) + shiftY, colour('declared'));

package/src/mesh.ts

@@ -43,6 +43,7 @@
  * (assertion A18 recompiles and compares bytes).
  */
 import type { ModelBinding, ModelVertices } from './model.ts';
+import { hypot2 } from './numeric.ts';
 
 // The mesh-quality measurement and its report (issue #1224) live in their own
 // module and reach a dependant through this file, which is what
@@ -468,7 +469,7 @@ export function ringControlAngles(
     const [x, y] = positionOf(name);
     const dx = x - center[0];
     const dy = y - center[1];
-    if (Math.hypot(dx, dy) < 1e-6) {
+    if (hypot2(dx, dy) < 1e-6) {
       throw new MeshError(`control bone "${name}" sits on the aperture centre, so it has no radial direction`);
     }
     return (Math.atan2(dy, dx) * 180) / Math.PI;
@@ -755,10 +756,10 @@ export function distanceToSegment(
   const dx = b[0] - a[0];
   const dy = b[1] - a[1];
   const len = dx * dx + dy * dy;
-  if (len === 0) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  if (len === 0) return hypot2(p[0] - a[0], p[1] - a[1]);
   let t = ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len;
   t = Math.max(0, Math.min(1, t));
-  return Math.hypot(p[0] - (a[0] + dx * t), p[1] - (a[1] + dy * t));
+  return hypot2(p[0] - (a[0] + dx * t), p[1] - (a[1] + dy * t));
 }
 
 /**
@@ -809,7 +810,7 @@ export function simplifyClosedPolygon(poly: Array<[number, number]>, tolerance:
   let far = 1;
   let farD = -1;
   for (let i = 1; i < n; i++) {
-    const d = Math.hypot(poly[i][0] - poly[0][0], poly[i][1] - poly[0][1]);
+    const d = hypot2(poly[i][0] - poly[0][0], poly[i][1] - poly[0][1]);
     if (d > farD) {
       farD = d;
       far = i;
@@ -852,7 +853,7 @@ export function offsetPolygon(poly: Array<[number, number]>, margin: number): Ar
     const n2: [number, number] = [e2[1], -e2[0]];
     let bx = n1[0] + n2[0];
     let by = n1[1] + n2[1];
-    let len = Math.hypot(bx, by);
+    let len = hypot2(bx, by);
     if (len < 1e-9) {
       // A 180-degree turn: the two edges double back, so there is no bisector.
       // The incoming edge's own normal is the only direction that is outward for
@@ -870,7 +871,7 @@ export function offsetPolygon(poly: Array<[number, number]>, margin: number): Ar
 }
 
 function unit(dx: number, dy: number): [number, number] {
-  const len = Math.hypot(dx, dy);
+  const len = hypot2(dx, dy);
   return len < 1e-12 ? [0, 0] : [dx / len, dy / len];
 }
 
@@ -1425,7 +1426,7 @@ export function measureContourFit(
           const nx = x + dx;
           if (nx < 0 || nx >= w) continue;
           if (!filled[ny * w + nx]) continue;
-          const d = Math.hypot(dx, dy);
+          const d = hypot2(dx, dy);
           if (d < best) best = d;
         }
       }

package/src/meshallocation.ts

@@ -35,6 +35,7 @@
  */
 import { distanceToSegment, r6, type AlphaMask } from './mesh.ts';
 import { closedPolygonCentres, inClosedPolygon, regionEdgeBound, type MotionAmplitude, type RefinementRegion } from './meshquality.ts';
+import { hypot2 } from './numeric.ts';
 
 type Pt = readonly [number, number];
 type Weights = ReadonlyArray<ReadonlyArray<{ bone: string; weight: number }>>;
@@ -105,7 +106,7 @@ function uniqueEdges(triangles: readonly number[]): Array<[number, number]> {
   return out;
 }
 
-const lengthOf = (a: Pt, b: Pt): number => Math.hypot(b[0] - a[0], b[1] - a[1]);
+const lengthOf = (a: Pt, b: Pt): number => hypot2(b[0] - a[0], b[1] - a[1]);
 
 /**
  * Nearest rank at index round((n − 1) · p) of the values sorted ascending, ties by index — §8's percentile rule —
@@ -530,7 +531,7 @@ function needField(points: readonly Pt[], triangles: readonly number[], weights:
       const [wa, wb, wc] = [wt(i), wt(j), wt(k)];
       const gx = ((wb - wa) * (C[1] - A[1]) - (wc - wa) * (B[1] - A[1])) / det;
       const gy = ((wc - wa) * (B[0] - A[0]) - (wb - wa) * (C[0] - A[0])) / det;
-      tv += Math.hypot(gx, gy);
+      tv += hypot2(gx, gy);
     }
     tv /= 2;
     if (tv <= 0) continue;

package/src/meshcarriers.ts

@@ -15,6 +15,7 @@
  */
 import { MeshReductionError } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
+import { hypot2 } from './numeric.ts';
 
 /** `pointInTriangle`'s epsilon in `src/mesh.ts`, applied to each barycentric coordinate. */
 export const CONTAINS = 1e-9;
@@ -222,7 +223,7 @@ function slackSupport(hits: readonly Carrier[], uvOf: (v: number) => readonly [n
     const h = [0, 1, 2].map((k) => {
       const a = p[(k + 1) % 3];
       const b = p[(k + 2) % 3];
-      return twice / Math.hypot(b[0] - a[0], b[1] - a[1]);
+      return twice / hypot2(b[0] - a[0], b[1] - a[1]);
     }) as [number, number, number];
     heights.set(c, h);
     widest = Math.max(widest, ...h);

package/src/meshcompare.ts

@@ -110,6 +110,7 @@ import { poseRawAnimationEach, poseRawSetup, type RawPose } from './core/raw.ts'
 import { sampleTime } from './core/animation.ts';
 import { CORE_DEFAULT_SKIN } from './core/skins.ts';
 import { readVersion } from './package_meta.ts';
+import { hypot2 } from './numeric.ts';
 
 // ---------------------------------------------------------------------------
 // the input — §3, with what the contract left undefined defined here
@@ -664,7 +665,7 @@ function inClosedPolygon(p: readonly [number, number], poly: ReadonlyArray<reado
     const dy = b[1] - a[1];
     const len = dx * dx + dy * dy;
     const t = len === 0 ? 0 : Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len));
-    if (Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t) <= ON_BOUNDARY) return true;
+    if (hypot2(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t) <= ON_BOUNDARY) return true;
   }
   let inside = false;
   for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
@@ -1082,7 +1083,7 @@ function compareMeshesInMotionWith(input: MotionComparisonInput, plant: CompareP
             if (!both[j]) continue;
             const p = carried(refCarrier[j]!, rw);
             const q = carried(candCarrier[j]!, cw);
-            const d = Math.hypot(q[0] - p[0], q[1] - p[1]);
+            const d = hypot2(q[0] - p[0], q[1] - p[1]);
             if (d > worst) {
               worst = d;
               worstAt = j;

package/src/meshquality.ts

@@ -74,6 +74,7 @@ import { allocationContrast, boundaryNecessityOnce, deformLoad, gradeMax, minAng
 import { skinningEchoOf, skinningResidual, sourceMeshDigest, validateSkinning, type ReductionSkinning, type SkinningDetail, type SkinningEcho, type SkinningPlant, type SkinningResidualInput } from './meshskinning.ts';
 import { artRastersOf, type ArtRasters, type CoverageReading, type OutlineMemo, type RegionEdgeReading, type SilhouetteReading, type StepRasters } from './meshrasters.ts';
 import { cropToSpineY } from './transform.ts';
+import { hypot2 } from './numeric.ts';
 
 // ---------------------------------------------------------------------------
 // §1 — inputs
@@ -1465,12 +1466,12 @@ function nearestParameter(a: Pt, b: Pt, c: Pt, d: Pt): number {
  * to the polygon within the tolerance of `transition`.
  */
 function runsAlongOuterBoundary(a: Pt, b: Pt, poly: readonly Pt[], transition: number): boolean {
-  const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+  const length = hypot2(b[0] - a[0], b[1] - a[1]);
   const n = poly.length;
   for (let i = 0; i < n; i++) {
     const c = poly[i];
     const e = poly[(i + 1) % n];
-    const side = Math.hypot(e[0] - c[0], e[1] - c[1]);
+    const side = hypot2(e[0] - c[0], e[1] - c[1]);
     if (side === 0) continue;
     const ux = (e[0] - c[0]) / side;
     const uy = (e[1] - c[1]) / side;
@@ -1525,7 +1526,7 @@ export function edgeIsHeldByRegion(a: readonly [number, number], b: readonly [nu
   if (d < transition - BAND_CONTACT_TOLERANCE) return true;
   if (runsAlongOuterBoundary(a, b, poly, transition)) return true;
   // Where on the edge each polygon side is touched: one point, or several apart.
-  const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+  const length = hypot2(b[0] - a[0], b[1] - a[1]);
   let first = Infinity;
   let last = -Infinity;
   const n = poly.length;
@@ -2548,7 +2549,7 @@ function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon:
   for (let i = 0; i < encoded.length; i += 2) {
     const a = encoded[i] / 2;
     const b = encoded[i + 1] / 2;
-    edges.push({ a: Math.min(a, b), b: Math.max(a, b), length: Math.hypot(points[b][0] - points[a][0], points[b][1] - points[a][1]) });
+    edges.push({ a: Math.min(a, b), b: Math.max(a, b), length: hypot2(points[b][0] - points[a][0], points[b][1] - points[a][1]) });
   }
   edges.sort((p, q) => p.a - q.a || p.b - q.b);
 
@@ -2688,14 +2689,14 @@ function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon:
     };
     const distance = (i: number, p: Pt): number => {
       const centre = centreOf(i);
-      return Math.hypot(p[0] - centre[0], p[1] - centre[1]);
+      return hypot2(p[0] - centre[0], p[1] - centre[1]);
     };
     if (steps === null) {
       for (const i of regionPixels) {
         const centre = centreOf(i);
         if (!inClosedPolygon(centre, hullPolygon)) continue;
         let nearest = Infinity;
-        for (const p of points) nearest = Math.min(nearest, Math.hypot(p[0] - centre[0], p[1] - centre[1]));
+        for (const p of points) nearest = Math.min(nearest, hypot2(p[0] - centre[0], p[1] - centre[1]));
         visit(i, nearest);
       }
     } else {

package/src/meshskinning.ts

@@ -58,6 +58,7 @@ import { MeshReductionError, r6 } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
 import { carrierIn, resolveCarriers, uvCarriers, type Carrier } from './meshcarriers.ts';
 import type { AttachmentRef, DeformTimelineInput, SourceFrame, SourceMesh, WorstSample } from './meshquality.ts';
+import { hypot2 } from './numeric.ts';
 
 type Pt = readonly [number, number];
 
@@ -407,8 +408,8 @@ export function sampleResidual(
     const dw = Math.abs(c.wbar[k] - r.wbar[k]);
     l1 += dw;
     lInf = Math.max(lInf, dw);
-    if (plant !== 'drop-covariance') cov[k] = eps[k] * Math.hypot(c.moment[k][0] - r.moment[k][0], c.moment[k][1] - r.moment[k][1]);
-    if (plant !== 'drop-lever') lev[k] = dw * (eps[k] * Math.hypot(r.p[0] - pivot[k][0], r.p[1] - pivot[k][1]) + tau[k]);
+    if (plant !== 'drop-covariance') cov[k] = eps[k] * hypot2(c.moment[k][0] - r.moment[k][0], c.moment[k][1] - r.moment[k][1]);
+    if (plant !== 'drop-lever') lev[k] = dw * (eps[k] * hypot2(r.p[0] - pivot[k][0], r.p[1] - pivot[k][1]) + tau[k]);
     total += cov[k] + lev[k];
   }
   return { total, cov, lev, l1, lInf };
@@ -539,7 +540,7 @@ export function skinningContract(args: SkinningMeasureArgs, plant: SkinningPlant
     for (let v = 0; v < mesh.points.length; v++) {
       const dx = Math.abs(mesh.points[v][0] - mesh.uvs[v * 2] * frame.width);
       const dy = Math.abs(mesh.points[v][1] - mesh.uvs[v * 2 + 1] * frame.height);
-      vertexGap = Math.max(vertexGap, Math.hypot(dx, dy));
+      vertexGap = Math.max(vertexGap, hypot2(dx, dy));
       if ((dx > slack[0] || dy > slack[1]) && plant !== 'setup-unchecked') {
         return out(
           'refused',
@@ -601,7 +602,7 @@ export function skinningResidual(args: SkinningMeasureArgs, plant: SkinningPlant
     measured++;
     const r = termsAt(source, cs, index);
     const c = termsAt(candidate, cc, index);
-    sampleGap = Math.max(sampleGap, Math.hypot(c.p[0] - r.p[0], c.p[1] - r.p[1]));
+    sampleGap = Math.max(sampleGap, hypot2(c.p[0] - r.p[0], c.p[1] - r.p[1]));
     const { total, cov, lev, l1, lInf } = sampleResidual(r, c, eps, tau, pivot, plant);
     l1Max = Math.max(l1Max, l1);
     lInfMax = Math.max(lInfMax, lInf);
@@ -767,7 +768,7 @@ function envelopeBoneWith(ranges: EnvelopeBoneRanges, plant: EnvelopePlant | nul
   for (let j = below.length - 2; j >= 0; j--) {
     if (plant === 'translation-ignored') break;
     const x = below[j];
-    delta = eOf(x) * Math.hypot(c[0] - x.pivot[0], c[1] - x.pivot[1]) + (1 + eOf(x)) * delta + x.translate;
+    delta = eOf(x) * hypot2(c[0] - x.pivot[0], c[1] - x.pivot[1]) + (1 + eOf(x)) * delta + x.translate;
   }
   return { bone: (ranges.chain[ranges.chain.length - 1] as BoneMotionRange).bone, linear: S * composed, pivot: [c[0], c[1]], translation: S * delta };
 }

package/src/numeric.ts

@@ -0,0 +1,23 @@
+/**
+ * The length of a 2-D vector, spelled so that every platform returns the same bits
+ * (issue #1377).
+ *
+ * `Math.sqrt(dx * dx + dy * dy)` and not `Math.hypot(dx, dy)`. IEEE 754 requires
+ * `*`, `+` and `sqrt` to be correctly rounded, so this expression has one answer
+ * for one input wherever it runs; `Math.hypot` carries no such requirement, and
+ * Bun 1.4.2's was measured returning 34.27192399143071 on macOS and
+ * 34.27192399143072 on Linux for the same bit-identical input (rig-c/parts#276).
+ * One ulp is enough to turn a strict win into a tie, move a value across a
+ * rounding grid, or reorder a sort — each of which this tree writes to disk.
+ *
+ * What it gives up is `hypot`'s guard against intermediate overflow and
+ * underflow: the squares overflow above about 1.3e154 and lose precision below
+ * about 1.5e-154. Every length measured here is in pixels, world units or UV
+ * units, many orders of magnitude inside both.
+ *
+ * 🔒 `CUR128` in `selftest.ts` holds `src/` and every module `src/` imports from
+ * outside itself free of `Math.hypot`, naming the file and symbol of any call.
+ */
+export function hypot2(dx: number, dy: number): number {
+  return Math.sqrt(dx * dx + dy * dy);
+}

package/src/pose.ts

@@ -54,6 +54,7 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { Plate, readPlate } from '../tools/plate.ts';
+import { hypot2 } from './numeric.ts';
 // The rasteriser's sampler rather than a second one written here: how a pixel is
 // read between two pixel centres is exactly the kind of thing two
 // implementations drift on.
@@ -1249,7 +1250,7 @@ function localMinima(field: CoarseField, radius: number, keep: number): Candidat
   const accepted: Candidate[] = [];
   for (const cand of found) {
     if (accepted.length >= keep) break;
-    if (accepted.some((a) => Math.hypot(a.cx - cand.cx, a.cy - cand.cy) <= radius * field.stride)) continue;
+    if (accepted.some((a) => hypot2(a.cx - cand.cx, a.cy - cand.cy) <= radius * field.stride)) continue;
     accepted.push(cand);
   }
   return accepted;
@@ -1383,7 +1384,7 @@ function dedupe(sorted: Candidate[], within: number, degrees: number, scaleRatio
   for (const cand of sorted) {
     const same = out.some(
       (o) =>
-        Math.hypot(o.cx - cand.cx, o.cy - cand.cy) <= within &&
+        hypot2(o.cx - cand.cx, o.cy - cand.cy) <= within &&
         Math.abs(normaliseDegrees(o.rotDeg - cand.rotDeg)) <= degrees &&
         Math.abs(Math.log(o.scale / cand.scale)) <= Math.log(scaleRatio),
     );
@@ -2126,7 +2127,7 @@ function placePart(
   for (const m of measured) {
     const same = distinct.some(
       (d) =>
-        Math.hypot(d.placement.x - m.placement.x, d.placement.y - m.placement.y) <= Math.max(1.5, 0.03 * span * m.placement.scale) &&
+        hypot2(d.placement.x - m.placement.x, d.placement.y - m.placement.y) <= Math.max(1.5, 0.03 * span * m.placement.scale) &&
         Math.abs(normaliseDegrees(d.placement.rotationDeg - m.placement.rotationDeg)) <= 5 &&
         Math.abs(Math.log(d.placement.scale / m.placement.scale)) <= Math.log(1.05),
     );

package/src/slots.ts

@@ -55,6 +55,7 @@ import {
   type Footprint,
   type Viewport,
 } from './render_shared.ts';
+import { hypot2 } from './numeric.ts';
 
 /** Components smaller than this are antialiasing crumbs, not parts. */
 const MIN_COMPONENT_PIXELS = 4;
@@ -293,7 +294,7 @@ export interface SlotTrack {
  */
 export function driftBound(track: SlotTrack): number | null {
   if (track.method !== 'template' || track.wholePixel === null) return null;
-  return Math.hypot(Math.abs(track.wholePixel.dx) + SUBPIXEL_CLAMP, Math.abs(track.wholePixel.dy) + SUBPIXEL_CLAMP);
+  return hypot2(Math.abs(track.wholePixel.dx) + SUBPIXEL_CLAMP, Math.abs(track.wholePixel.dy) + SUBPIXEL_CLAMP);
 }
 
 /**
@@ -411,7 +412,7 @@ export function matchSlots(
     // a guess, so it is bounded by what this slot could plausibly have moved, and
     // a rival about as near makes it a guess between two things.
     const ranked = components
-      .map((c) => ({ c, d: Math.hypot(c.cx - foot.cx, c.cy - foot.cy) }))
+      .map((c) => ({ c, d: hypot2(c.cx - foot.cx, c.cy - foot.cy) }))
       .sort((a, b) => a.d - b.d);
     const nearest = ranked[0];
     if (nearest.d > radius) {
@@ -519,7 +520,7 @@ function fillComponentMatch(track: SlotTrack, foot: Footprint, component: Compon
   };
   track.driftX = component.cx - foot.cx;
   track.driftY = component.cy - foot.cy;
-  track.drift = Math.hypot(track.driftX, track.driftY);
+  track.drift = hypot2(track.driftX, track.driftY);
   track.widthDrift = foot.maxX - foot.minX - track.reference.width;
   track.heightDrift = foot.maxY - foot.minY - track.reference.height;
 }
@@ -836,12 +837,12 @@ function applyTemplateMatch(track: SlotTrack, foot: Footprint, source: SlotSourc
   const gap = Math.max(RIVAL_GAP, coarse);
   let rival = Infinity;
   for (const { dx, dy, s } of sweep) {
-    if (Math.hypot(dx - bestX, dy - bestY) < gap) continue;
+    if (hypot2(dx - bestX, dy - bestY) < gap) continue;
     if (s < rival) rival = s;
   }
   const confidence = Number.isFinite(rival) && rival > 0 ? Math.max(0, Math.min(1, 1 - best / rival)) : 0;
 
-  const reach = Math.min(1, Math.hypot(bestX, bestY) / radius);
+  const reach = Math.min(1, hypot2(bestX, bestY) / radius);
   const required = MIN_CONFIDENCE + reach * CONFIDENCE_SLOPE;
   if (best > template.contrast * MAX_RESIDUAL_FRACTION || confidence < required) {
     track.method = 'none';
@@ -851,7 +852,7 @@ function applyTemplateMatch(track: SlotTrack, foot: Footprint, source: SlotSourc
       `${radius} px either (best residual ${best.toFixed(1)} against its own ${template.contrast.toFixed(1)} of ` +
       `contrast over the ${template.ink - template.covered} of its ${template.ink} px that reach the picture; ` +
       `confidence ${(Number.isFinite(confidence) ? confidence : 0).toFixed(2)} where ` +
-      `${required.toFixed(2)} is needed ${Math.hypot(bestX, bestY).toFixed(1)} px out)`;
+      `${required.toFixed(2)} is needed ${hypot2(bestX, bestY).toFixed(1)} px out)`;
     return;
   }
 
@@ -861,7 +862,7 @@ function applyTemplateMatch(track: SlotTrack, foot: Footprint, source: SlotSourc
   track.reference = null;
   track.driftX = dx;
   track.driftY = dy;
-  track.drift = Math.hypot(dx, dy);
+  track.drift = hypot2(dx, dy);
   track.widthDrift = null;
   track.heightDrift = null;
   track.confidence = confidence;

package/tools/plate.ts

@@ -16,6 +16,7 @@ import { deflateSync, inflateSync } from 'node:zlib';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { drawText, textWidth } from './font5x7.ts';
 import { assertPng, NotAPngError } from '../src/png.ts';
+import { hypot2 } from '../src/numeric.ts';
 
 export type RGBA = [number, number, number, number];
 
@@ -88,7 +89,7 @@ export class Plate {
   }
 
   line(x0: number, y0: number, x1: number, y1: number, t: number, colour: RGBA): void {
-    const steps = Math.ceil(Math.hypot(x1 - x0, y1 - y0)) * 2 + 1;
+    const steps = Math.ceil(hypot2(x1 - x0, y1 - y0)) * 2 + 1;
     for (let s = 0; s <= steps; s++) {
       const u = s / steps;
       const cx = x0 + (x1 - x0) * u;
@@ -100,7 +101,7 @@ export class Plate {
   disc(cx: number, cy: number, r: number, colour: RGBA): void {
     for (let y = Math.floor(cy - r); y <= Math.ceil(cy + r); y++) {
       for (let x = Math.floor(cx - r); x <= Math.ceil(cx + r); x++) {
-        if (Math.hypot(x - cx, y - cy) <= r) this.blend(x, y, colour);
+        if (hypot2(x - cx, y - cy) <= r) this.blend(x, y, colour);
       }
     }
   }
@@ -108,7 +109,7 @@ export class Plate {
   ring(cx: number, cy: number, r: number, t: number, colour: RGBA): void {
     for (let y = Math.floor(cy - r - t); y <= Math.ceil(cy + r + t); y++) {
       for (let x = Math.floor(cx - r - t); x <= Math.ceil(cx + r + t); x++) {
-        const d = Math.hypot(x - cx, y - cy);
+        const d = hypot2(x - cx, y - cy);
         if (Math.abs(d - r) <= t) this.blend(x, y, colour);
       }
     }