spine-rigc 2.44.0 → 2.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.44.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
@@ -306,6 +307,54 @@ export interface MeshReductionInput {
    * a list. `protect.edges` keeps its meaning: a line held whole is listed there.
    */
   lines?: NamedLine[];
+  /**
+   * What refused each kept source vertex (issue #1374) — opt-in. Left out = the report is the one it was before the
+   * field existed, byte for byte, and no refusal is measured that the run would not measure. Set, `changes` ends in
+   * `kept` (`KeptRefusals`): for the last removal pass, the one that took nothing, each kept source vertex's reason
+   * counted per reason and split boundary / interior — and with `'by-vertex'` also listed vertex by vertex with the
+   * refusal's text. A refusal the deviation floor decided is measured in full to be named, in that pass only, as
+   * `blockingConstraint`'s is. No step, order or mesh reads it. Any other value, `null` included, is refused.
+   */
+  explainKept?: 'by-row' | 'by-vertex';
+}
+
+/**
+ * Issue #1374: why the kept source vertices are kept — `ReductionChanges.kept`, written last in `changes` and only when
+ * the input set `explainKept`. The reasons are read from the last removal pass, the one in which no step was taken, so
+ * every kept vertex not protected was attempted there once as a single removal, on the mesh the result carries (before
+ * any `retriangulate` post-pass). A vertex is boundary when it is a source-hull vertex — a kept source vertex is on the
+ * outline exactly then — and interior otherwise. Vertices the refinement inserted are never candidates and are not
+ * listed.
+ *
+ * A reason is the refusal's constraint without the object an author named: a row's code (`MQ_BOUNDARY_DEVIATION`,
+ * `MQ_SKINNING_RESIDUAL`, …, the region or line it names left in `refusal`), or a structural condition as the refusal
+ * opens — `retriangulation`, `outline`, `protect (a)`, `weightJump (b)`, `line`. A vertex no attempt in such a pass
+ * reached reads why, never an absence: `protected` (`protect`, or a line's end or crossing), and — when the run has no
+ * pass that took nothing — `budget-exhausted`, `replayed-to-accepted-step` or `no-removal-pass` (the refined source
+ * did not meet its targets, so no removal was tried), the termination it ended in.
+ */
+export interface KeptRefusals {
+  /** The 1-based removal pass the reasons were read from; null when the run had no pass that took nothing. */
+  pass: number | null;
+  /** One entry per reason that holds a kept source vertex, ascending by reason. `boundary + interior` over the entries is the kept source vertices. */
+  rows: KeptRow[];
+  /** `explainKept: 'by-vertex'` only: every kept source vertex, ascending by source index. */
+  vertices?: KeptVertex[];
+}
+
+/** Issue #1374: one reason, and the kept source vertices it holds on the outline and inside it. */
+export interface KeptRow {
+  reason: string;
+  boundary: number;
+  interior: number;
+}
+
+/** Issue #1374: one kept source vertex, its reason, and the refusal's text as `blockingConstraint` writes it — null for a reason no attempt gave. */
+export interface KeptVertex {
+  vertex: number;
+  boundary: boolean;
+  reason: string;
+  refusal: string | null;
 }
 
 /**
@@ -687,8 +736,10 @@ export interface ReductionChanges {
    * `stopAfterAccepted: k` replays to the operation at `acceptedAt[k - 1]`.
    */
   acceptedAt: AcceptedOperation[];
-  /** Issue #1283: which triangulation the mesh carries — present only when the input set `retriangulate`, written last. */
+  /** Issue #1283: which triangulation the mesh carries — present only when the input set `retriangulate`. */
   retriangulation?: Retriangulation;
+  /** Issue #1374: what refused each kept source vertex in the last removal pass — present only when the input set `explainKept`, written last. */
+  kept?: KeptRefusals;
 }
 
 export interface MeshQualityReport {
@@ -750,6 +801,8 @@ export interface EffectiveSettings {
   lines?: NamedLine[];
   /** A measurement's `lineSource`, by id and `sourceMeshDigest`, echoed when the input set it (issue #1326); absent otherwise. */
   lineSource?: { id: string; digest: string };
+  /** A reduction's `explainKept`, echoed when the input set it (issue #1374); absent otherwise. */
+  explainKept?: 'by-row' | 'by-vertex';
 }
 
 export interface MeshCounts {
@@ -1413,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;
@@ -1473,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;
@@ -2496,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);
 
@@ -2636,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 {
@@ -2805,6 +2858,7 @@ function effectiveJson(e: EffectiveSettings): Json {
     ...(e.overBound === undefined ? {} : { overBound: { maxSamples: e.overBound.maxSamples, triangles: e.overBound.triangles } }),
     ...(e.lines === undefined ? {} : { lines: e.lines.map((l): Json => ({ name: l.name, vertices: [...l.vertices], closed: l.closed, maxDeviation: l.maxDeviation })) }),
     ...(e.lineSource === undefined ? {} : { lineSource: { id: e.lineSource.id, digest: e.lineSource.digest } }),
+    ...(e.explainKept === undefined ? {} : { explainKept: e.explainKept }),
   };
 }
 
@@ -2950,6 +3004,15 @@ function candidateJson(c: CandidateReport): Json {
               monotonicity: k.retriangulation.monotonicity,
             },
           }),
+      ...(k.kept === undefined
+        ? {}
+        : {
+            kept: {
+              pass: k.kept.pass,
+              rows: k.kept.rows.map((r) => ({ reason: r.reason, boundary: r.boundary, interior: r.interior })),
+              ...(k.kept.vertices === undefined ? {} : { vertices: k.kept.vertices.map((v) => ({ vertex: v.vertex, boundary: v.boundary, reason: v.reason, refusal: v.refusal })) }),
+            },
+          }),
     };
   }
   return out;

package/src/meshreduce.ts

@@ -90,6 +90,15 @@
  * of the triangles it changed; the result's own measurement reads the row in
  * full. Left out, nothing here reads it and the call is the one it was.
  *
+ * ## What refused each kept vertex (issue #1374, opt-in)
+ *
+ * With `explainKept`, the pass that ends the reduction having taken nothing
+ * keeps each single removal's refusal and names it once the pass is over — the
+ * working mesh is then the one every attempt in it was tried on, so a refusal
+ * the deviation floor decided is measured as `blockingConstraint`'s is — and the
+ * result's `changes.kept` counts the kept source vertices per reason, boundary
+ * and interior (`keptOf`). No step, order or mesh reads it.
+ *
  * A removal whose deviation floor — the furthest removed source-hull vertex
  * from the candidate's outline, which `MQ_BOUNDARY_DEVIATION` can only exceed —
  * is over the bound is refused without the measurement; its name, when read,
@@ -148,6 +157,8 @@ import {
   type CandidateReport,
   type DeformKeyInput,
   type EffectiveSettings,
+  type KeptRefusals,
+  type KeptVertex,
   type MeasureRow,
   type MeshCounts,
   type MeshMeasureInput,
@@ -344,6 +355,9 @@ function validateReduction(input: MeshReductionInput, plant: ReductionPlant | nu
   if ('removalOrder' in input && input.removalOrder !== undefined && input.removalOrder !== 'deformation-load') {
     refuse('REDUCE_INPUT_MISSING', `${who}: removalOrder is ${JSON.stringify(input.removalOrder)}; required "deformation-load" — single removals in ascending predicted deformation load, ties by source index — or the field left out (issue #1283: ascending source index)`);
   }
+  if ('explainKept' in input && input.explainKept !== undefined && input.explainKept !== 'by-row' && input.explainKept !== 'by-vertex') {
+    refuse('REDUCE_INPUT_MISSING', `${who}: explainKept is ${JSON.stringify(input.explainKept)}; required "by-row" — what refused the kept source vertices in the last removal pass, counted per reason — or "by-vertex" — those counts and every kept source vertex listed — or the field left out (issue #1374: no such block)`);
+  }
   // Issue #1287: refused here, before the admission measurement and any step, in the measurement's own words — the
   // admission does not carry the field, and a call whose source is refused never reaches the one measurement that does.
   if (plant !== 'amplitude-unvalidated') validateMotionAmplitude(who, input.motionAmplitude);
@@ -961,6 +975,18 @@ interface Run {
   hooks: SkinningHooks | null;
   /** Issue #1326: the declared lines, or null when the input left `lines` out. */
   lines: LineRun | null;
+  /** Issue #1374: the refusals of the current pass's single removals, and the last pass's once it took nothing — null when the input left `explainKept` out. */
+  kept: KeptLog | null;
+}
+
+/**
+ * Issue #1374: what `explainKept` reads. `attempts` is the current pass's single removals refused, by source vertex,
+ * as tried — a floor's refusal still a thunk, read only if the pass takes nothing; `final` is that pass's, read in
+ * the state it was tried in, once a pass ends having taken nothing.
+ */
+interface KeptLog {
+  attempts: Map<number, Refusal>;
+  final: { pass: number; refusals: Map<number, string> } | null;
 }
 
 /** Issue #1326: the input's lines as the steps read them. */
@@ -1486,7 +1512,14 @@ export type ReductionPlant =
   | OrderPlant
   | AmplitudePlant
   | RefinementPlant
-  | LinePlant;
+  | LinePlant
+  | KeptPlant;
+
+/**
+ * Issue #1374's fault, for the `mesh-quality` suite's control: each kept vertex named by the refusal of the next
+ * vertex refused in the last pass (the first's for the last) — a reason that did not refuse it.
+ */
+export type KeptPlant = 'kept-reason-shifted';
 
 /**
  * Issue #1326's faults in the line mechanism, for the `mesh-quality` suite's controls: the line rows read by no step
@@ -1909,6 +1942,7 @@ function removeVertices(run: Run): PhaseEnd {
     let taken = 0;
     let tried = 0;
     pass++;
+    if (run.kept !== null) run.kept.attempts = new Map();
     if (runs !== undefined) {
       let walk: number[] | null = null;
       for (let s = 0; s < hull; s++) {
@@ -1990,12 +2024,14 @@ function removeVertices(run: Run): PhaseEnd {
         if (accept(run, 'removal', [v])) return { kind: 'replayed' };
       } else {
         lastBlock = { refusal: block, what: `removing source vertex ${v}` };
+        if (run.kept !== null) run.kept.attempts.set(v, block);
         if (run.hooks?.plant === 'veto-ends-search' && typeof block === 'string' && block.startsWith('MQ_SKINNING_RESIDUAL')) return { kind: 'stuck', constraint: lastName() };
       }
     }
     if (taken === 0) {
       // A pass that took nothing left the working mesh as it found it, so a refusal the floor decided is measured
       // now in the state it was decided in.
+      if (run.kept !== null) run.kept.final = { pass, refusals: new Map([...run.kept.attempts].map(([v, r]) => [v, refusalText(r)])) };
       const kept = run.lines === null ? '' : ", or an open line's end or a vertex two lines list";
       const constraint = tried === 0 ? `protect: every surviving source vertex is protected (protect.hull, protect.vertices, protect.edges, protect.regionBoundaries or a weightJump edge${kept})` : lastName();
       return { kind: 'stuck', constraint };
@@ -2688,6 +2724,7 @@ function reduceValidated(
       skinning: null,
       hooks,
       lines: null,
+      kept: input.explainKept === undefined ? null : { attempts: new Map(), final: null },
     };
     run.skinning = skinningRunOf(run, skinningAdmitted);
     run.lines = lineRunOf(run);
@@ -2880,6 +2917,7 @@ function finish(run: Run, effective: EffectiveSettings, sourceCounts: MeshCounts
     linkedMeshes: input.linkedMeshes,
     acceptedAt: run.acceptedAt.map((a) => ({ step: a.step, kind: a.kind, count: a.count, sourceVertices: [...a.sourceVertices] })),
     ...(retriangulation === undefined ? {} : { retriangulation }),
+    ...(run.kept === null ? {} : { kept: keptOf(run, termination) }),
   };
   const counts = candidate.counts!;
   const mesh: ReducedMesh = {
@@ -2894,6 +2932,62 @@ function finish(run: Run, effective: EffectiveSettings, sourceCounts: MeshCounts
   return { mesh, report: reportOf(effective, sourceCounts, { ...candidate, changes }, termination) };
 }
 
+/**
+ * A refusal's reason (issue #1374, `KeptRefusals`): a row's code, or the structural condition the refusal opens with.
+ * Every refusal a step writes opens with one of them; one that does not is a defect here, thrown rather than named.
+ */
+function refusalReason(text: string): string {
+  const code = /^MQ_[A-Z0-9_]+/.exec(text);
+  if (code !== null) return code[0];
+  if (text.startsWith('line "')) return 'line';
+  for (const condition of ['retriangulation', 'outline', 'protect (a)', 'weightJump (b)']) if (text.startsWith(`${condition}:`)) return condition;
+  throw new Error(`issue #1374: a refusal opens with no reason KeptRefusals names: "${text.slice(0, 120)}"`);
+}
+
+/**
+ * Issue #1374: `ReductionChanges.kept` — every kept source vertex with its reason: `protected`, else its refusal in the
+ * last pass when one took nothing, else the termination that ended the run without one.
+ */
+function keptOf(run: Run, termination: Termination): KeptRefusals {
+  const { work } = run;
+  const hull = run.input.source.hull;
+  const final = run.kept!.final;
+  const unreached = final !== null ? null : termination.reason === 'budget-exhausted' || termination.reason === 'replayed-to-accepted-step' ? termination.reason : 'no-removal-pass';
+  let refusals = final?.refusals ?? null;
+  if (refusals !== null && run.plant === 'kept-reason-shifted') {
+    const order = [...refusals.keys()].sort((a, b) => a - b);
+    refusals = new Map(order.map((v, i) => [v, refusals!.get(order[(i + 1) % order.length])!]));
+  }
+  const vertices: KeptVertex[] = [];
+  for (let v = 0; v < work.nSource; v++) {
+    if (!work.alive[v]) continue;
+    const boundary = v < hull;
+    if (run.protectedVertices.has(v)) {
+      vertices.push({ vertex: v, boundary, reason: 'protected', refusal: null });
+      continue;
+    }
+    if (refusals === null) {
+      vertices.push({ vertex: v, boundary, reason: unreached!, refusal: null });
+      continue;
+    }
+    const refusal = refusals.get(v);
+    if (refusal === undefined) throw new Error(`issue #1374: source vertex ${v} is kept and not protected, yet removal pass ${final!.pass}, which took nothing, did not refuse it`);
+    vertices.push({ vertex: v, boundary, reason: refusalReason(refusal), refusal });
+  }
+  const rows = new Map<string, { boundary: number; interior: number }>();
+  for (const k of vertices) {
+    const row = rows.get(k.reason) ?? { boundary: 0, interior: 0 };
+    if (k.boundary) row.boundary++;
+    else row.interior++;
+    rows.set(k.reason, row);
+  }
+  return {
+    pass: final === null ? null : final.pass,
+    rows: [...rows.keys()].sort().map((reason) => ({ reason, ...rows.get(reason)! })),
+    ...(run.input.explainKept === 'by-vertex' ? { vertices } : {}),
+  };
+}
+
 function reportOf(effective: EffectiveSettings, sourceCounts: MeshCounts | null, candidate: CandidateReport, termination: Termination): MeshQualityReport {
   return {
     spec: 'mesh-quality-report/1',
@@ -2924,6 +3018,7 @@ function effectiveOf(input: MeshReductionInput, measured: EffectiveSettings, sou
     ...(input.retriangulate === undefined ? {} : { retriangulate: input.retriangulate }),
     ...(input.removalOrder === undefined ? {} : { removalOrder: input.removalOrder }),
     ...(input.lines === undefined ? {} : { lines: input.lines }),
+    ...(input.explainKept === undefined ? {} : { explainKept: input.explainKept }),
   };
 }
 

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);
       }
     }