From 5837dedc890254df195aee4360ced854aa9d3d02 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 10 Aug 2026 01:09:37 +0000
Subject: [PATCH 1/4] Measure the silhouette outline in CSS pixels, so it stops
 breathing when the camera moves
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The outline kernel was a fixed count of depth-texture texels, and ThreeEngine
drops the device-pixel ratio from 1.5 to 1.0 for the duration of a camera
drag. A texel is a different size on screen at each ratio, so the outline
rendered 1.5x wider while moving and snapped back ~180ms after release — most
visible on a Retina display against a dark background (#121).

Turn the shaders' kernel radius back into a uniform and drive it by the current
pixel ratio: u_radius = cssRadius * pixelRatio. Pinned to the idle-ratio width
(2.0 CSS px for the shape outline, ~1.667 for the gizmo), the on-screen
thickness is now constant across the interactive/idle ratio switch. R stays a
compile-time 3, and the CSS radius times the 1.5 ceiling lands exactly on it, so
the loop is never overrun; a clamp guards the bound if MAX_DPR is ever raised.
The GIZMO_OUTLINE_FRAG kernel had the same texel-measured drift and gets the
same treatment.

outlineTexelRadius is a pure function with a unit test covering CSS-width
constancy across the two ratios, the preserved idle appearance, and the clamp.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ToZMaeRwS2FKB8xESMuktQ
---
 src/engine/OutlinePass.test.ts | 57 +++++++++++++++++++++++++++
 src/engine/OutlinePass.ts      | 71 +++++++++++++++++++++++++++++++---
 2 files changed, 122 insertions(+), 6 deletions(-)
 create mode 100644 src/engine/OutlinePass.test.ts

diff --git a/src/engine/OutlinePass.test.ts b/src/engine/OutlinePass.test.ts
new file mode 100644
index 0000000..2b93d84
--- /dev/null
+++ b/src/engine/OutlinePass.test.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import {
+  outlineTexelRadius,
+  OUTLINE_CSS_RADIUS,
+  OUTLINE_MAX_TEXELS,
+  GIZMO_CSS_RADIUS,
+  GIZMO_MAX_TEXELS,
+} from './OutlinePass';
+
+/**
+ * Issue #121: the outline kernel was measured in depth-texture texels, so a
+ * fixed texel count spanned a different on-screen width at each device-pixel
+ * ratio. `ThreeEngine` uses 1.5 idle and 1.0 while the camera moves, so the
+ * outline thickened for the duration of a drag. `outlineTexelRadius` converts a
+ * CSS-pixel radius to texels per frame so the on-screen width stays constant.
+ */
+describe('outlineTexelRadius', () => {
+  // The two device-pixel ratios ThreeEngine actually renders at.
+  const IDLE_DPR = 1.5;
+  const INTERACTIVE_DPR = 1.0;
+
+  it('holds a constant CSS width across the idle/interactive ratio switch', () => {
+    for (const [css, max] of [
+      [OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS],
+      [GIZMO_CSS_RADIUS, GIZMO_MAX_TEXELS],
+    ] as const) {
+      const idleTexels = outlineTexelRadius(IDLE_DPR, css, max);
+      const movingTexels = outlineTexelRadius(INTERACTIVE_DPR, css, max);
+      // Texel count differs by ratio...
+      expect(idleTexels).toBeGreaterThan(movingTexels);
+      // ...but texels / ratio — the CSS-pixel width on screen — does not.
+      expect(idleTexels / IDLE_DPR).toBeCloseTo(css, 10);
+      expect(movingTexels / INTERACTIVE_DPR).toBeCloseTo(css, 10);
+    }
+  });
+
+  it('reproduces the old 3-texel kernel at the idle ratio', () => {
+    // The kernel was authored as `const float u_radius = 3.0` and looked right
+    // at 1.5; the fix must not change that idle appearance.
+    expect(outlineTexelRadius(IDLE_DPR, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS)).toBeCloseTo(3.0, 10);
+    // The old gizmo cull was `r > 2.5`.
+    expect(outlineTexelRadius(IDLE_DPR, GIZMO_CSS_RADIUS, GIZMO_MAX_TEXELS)).toBeCloseTo(2.5, 10);
+  });
+
+  it('never exceeds the shader loop bound, even above the DPR ceiling', () => {
+    // R is a compile-time constant in the shader; a texel radius past it would
+    // silently request taps the loop never visits. The clamp guarantees it can't.
+    expect(outlineTexelRadius(2, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS)).toBe(OUTLINE_MAX_TEXELS);
+    expect(outlineTexelRadius(4, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS)).toBe(OUTLINE_MAX_TEXELS);
+    expect(outlineTexelRadius(2, GIZMO_CSS_RADIUS, GIZMO_MAX_TEXELS)).toBe(GIZMO_MAX_TEXELS);
+  });
+
+  it('scales linearly with the pixel ratio below the clamp', () => {
+    expect(outlineTexelRadius(1.0, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS)).toBeCloseTo(2.0, 10);
+    expect(outlineTexelRadius(1.25, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS)).toBeCloseTo(2.5, 10);
+  });
+});
diff --git a/src/engine/OutlinePass.ts b/src/engine/OutlinePass.ts
index bc58d47..1e572f5 100644
--- a/src/engine/OutlinePass.ts
+++ b/src/engine/OutlinePass.ts
@@ -20,6 +20,7 @@ const GIZMO_OUTLINE_FRAG = `
 precision highp float;
 uniform sampler2D u_gizmo;
 uniform vec2 u_resolution;
+uniform float u_radius;
 varying vec2 vUv;
 
 void main() {
@@ -33,7 +34,7 @@ void main() {
     for (int y = -2; y <= 2; y++) {
       if (x == 0 && y == 0) continue;
       float r = sqrt(float(x*x + y*y));
-      if (r > 2.5) continue;
+      if (r > u_radius) continue;
       vec2 offset = vec2(float(x) * px, float(y) * py);
       float a = texture2D(u_gizmo, vUv + offset).a;
       maxAlpha = max(maxAlpha, a);
@@ -81,13 +82,16 @@ uniform sampler2D u_depth;
 uniform vec2 u_resolution;
 uniform float u_near;
 uniform float u_far;
+uniform float u_radius;
 varying vec2 vUv;
 
-// Kernel radius, and the loop bound that matches it. It used to sweep -4..4 —
-// 81 taps — and cull everything past r = 3.0, so 32 of them did a sqrt and two
-// depth linearisations only to be thrown away. -3..3 is the smallest box that
-// contains the disc, so the culled set is now just the four corners.
-const float u_radius = 3.0;
+// The loop bound that matches the widest kernel we ever request. It used to
+// sweep -4..4 — 81 taps — and cull everything past r = 3.0, so 32 of them did a
+// sqrt and two depth linearisations only to be thrown away. -3..3 is the
+// smallest box that contains the disc, so the culled set is now just the four
+// corners. u_radius is a uniform (see OUTLINE_CSS_RADIUS) rather than the old
+// const 3.0: the kernel is measured in CSS pixels and converted to texels per
+// frame, so it never exceeds 3.0 and never overruns this bound.
 const int R = 3;
 
 void main() {
@@ -137,6 +141,43 @@ void main() {
 }
 `;
 
+/**
+ * Device-pixel ratio the outline kernels were authored against.
+ *
+ * `ThreeEngine` renders at `MAX_DPR = 1.5` when idle and drops to `1.0` while
+ * the camera moves. Both outline shaders originally measured their kernel in
+ * *texels of the depth texture*, so a fixed texel count spanned a different
+ * number of CSS pixels at each ratio — the outline visibly thickened for the
+ * duration of a drag and snapped back on settle (issue #121). The kernels look
+ * right at the idle ratio, so that is the width we pin: the CSS-pixel radius is
+ * `texelRadius / 1.5`, and we convert back to texels per frame at whatever
+ * ratio is current.
+ */
+const OUTLINE_DESIGN_DPR = 1.5;
+
+/** Compile-time loop bound `R` in `OUTLINE_FRAG`; the kernel can never exceed this many texels. */
+export const OUTLINE_MAX_TEXELS = 3;
+/** The `if (r > 2.5)` cull the `-2..2` box in `GIZMO_OUTLINE_FRAG` enforces. */
+export const GIZMO_MAX_TEXELS = 2.5;
+
+/** Outline half-width in CSS pixels — the idle-ratio appearance, held across DPR changes. */
+export const OUTLINE_CSS_RADIUS = OUTLINE_MAX_TEXELS / OUTLINE_DESIGN_DPR; // 2.0
+export const GIZMO_CSS_RADIUS = GIZMO_MAX_TEXELS / OUTLINE_DESIGN_DPR; // ~1.667
+
+/**
+ * Convert a CSS-pixel kernel radius to depth-texture texels at a given pixel
+ * ratio, clamped to the shader's compile-time loop bound.
+ *
+ * A CSS-pixel radius times the pixel ratio is the texel radius, so the on-screen
+ * width stays constant as the ratio changes: at ratio 1.5 the outline spans
+ * `2.0 * 1.5 = 3.0` texels, at ratio 1.0 it spans `2.0` texels — both 2.0 CSS
+ * px. The clamp guards the loop bound: the ratio never exceeds `MAX_DPR = 1.5`,
+ * so this only bites if that ceiling is ever raised past the kernel width.
+ */
+export function outlineTexelRadius(pixelRatio: number, cssRadius: number, maxTexels: number): number {
+  return Math.min(cssRadius * pixelRatio, maxTexels);
+}
+
 export class OutlinePass {
   private engine: OutlinePassEngine;
   /** Colour *and* depth from the one scene render. */
@@ -182,6 +223,7 @@ export class OutlinePass {
         u_resolution: { value: new THREE.Vector2(w, h) },
         u_near: { value: 0.01 },
         u_far: { value: 5000 },
+        u_radius: { value: outlineTexelRadius(dpr, OUTLINE_CSS_RADIUS, OUTLINE_MAX_TEXELS) },
       },
       transparent: true,
       depthTest: false,
@@ -206,6 +248,7 @@ export class OutlinePass {
       uniforms: {
         u_gizmo: { value: this.gizmoTarget.texture },
         u_resolution: { value: new THREE.Vector2(w, h) },
+        u_radius: { value: outlineTexelRadius(dpr, GIZMO_CSS_RADIUS, GIZMO_MAX_TEXELS) },
       },
       transparent: true,
       depthTest: false,
@@ -293,6 +336,22 @@ export class OutlinePass {
     this.material.uniforms.u_near.value = camera.near;
     this.material.uniforms.u_far.value = camera.far;
 
+    // Pin both kernels to a constant CSS-pixel width. `getPixelRatio()` reports
+    // the interactive ratio (1.0) mid-drag and the idle ratio (1.5) otherwise;
+    // scaling the texel radius by it keeps the on-screen thickness fixed instead
+    // of letting the outline "breathe" every time the camera moves (issue #121).
+    const pr = renderer.getPixelRatio();
+    this.material.uniforms.u_radius.value = outlineTexelRadius(
+      pr,
+      OUTLINE_CSS_RADIUS,
+      OUTLINE_MAX_TEXELS,
+    );
+    this.gizmoMaterial.uniforms.u_radius.value = outlineTexelRadius(
+      pr,
+      GIZMO_CSS_RADIUS,
+      GIZMO_MAX_TEXELS,
+    );
+
     // 1. The one scene render. Colour and depth come out of the same pass.
     //    The gizmo goes into the same target immediately after, so it composites
     //    exactly where it did when it lived in `scene` — it is only stored

From 5ad2f602b0adfd568a46a06dd2bd013978ade163 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 10 Aug 2026 02:09:33 +0000
Subject: [PATCH 2/4] Bake the fit objective's mesh-field target once instead
 of per trial
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

fitPrimitive ran ~2-3s per fit here (5-9s on a contended machine), and the cost
did not fall with grid resolution — it was dominated by a fixed-iteration
coordinate descent rather than by the field's size. It is also the suite's
chronic timeout: the test file runs ten fits and repeatedly ran out the clock.

volumeCost is called thousands of times per fit — every coordinate-descent
trial of every candidate — always over the same fixed sample grid, with only
the candidate node changing. Each call re-sampled the mesh field
(sampleMeshField: a trilinear interpolation with a square root) at those
identical coordinates and allocated a fresh [x,y,z] tuple per sample, so a
single fit ran to millions of redundant interpolations and short-lived arrays.

Precompute the sample coordinates and the mesh-field target once per fit
(sampleVolume), and have volumeCost read the target from a Float64Array and
evaluate the candidate with evalAt's loose scalars — no re-interpolation, no
per-sample allocation. The sample order is unchanged, so the summation is
bit-identical and the fit stays deterministic.

Measured (res 40): sphere 2638->342ms, box 2352->298ms, cylinder 2255->284ms,
tilted cylinder 3085->400ms — ~8x, with kind/surfaceRms/surfaceMax identical.
fitPrimitive.test.ts drops from tens of seconds to ~17s, now bounded by field
baking rather than fitting. All existing gates pass, determinism included.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ToZMaeRwS2FKB8xESMuktQ
---
 src/worker/sdf/fitPrimitive.ts | 66 ++++++++++++++++++++++++++++------
 1 file changed, 55 insertions(+), 11 deletions(-)

diff --git a/src/worker/sdf/fitPrimitive.ts b/src/worker/sdf/fitPrimitive.ts
index 86a31e9..2680fe1 100644
--- a/src/worker/sdf/fitPrimitive.ts
+++ b/src/worker/sdf/fitPrimitive.ts
@@ -1,5 +1,5 @@
 import type { SDFNode, MeshFieldData, Vec3 } from './types';
-import { evaluateSDF } from './evaluate';
+import { evaluateSDF, evalAt } from './evaluate';
 import { sampleMeshField } from './meshField';
 
 /**
@@ -127,24 +127,67 @@ function surfacePoints(field: MeshFieldData): Vec3[] {
   return pts.filter((_, i) => i % stride === 0);
 }
 
-/** Squared field difference over a volume of samples — the optimiser's objective. */
-function volumeCost(field: MeshFieldData, node: SDFNode): number {
+/**
+ * The volume objective's sample points and the mesh field's value at each,
+ * baked once per fit.
+ *
+ * `volumeCost` is called thousands of times — every coordinate-descent trial of
+ * every candidate — always over this same fixed grid, and the only thing that
+ * changes between calls is the candidate node. The mesh side of the difference
+ * (`sampleMeshField`, a trilinear interpolation with a square root) was being
+ * recomputed at identical coordinates on every one of those calls; for a single
+ * fit that ran to millions of redundant interpolations. Precomputing the target
+ * once removes that half of the inner loop wholesale (#123), leaving only the
+ * candidate's own `evalAt`. The `xs/ys/zs` arrays let the loop call `evalAt`
+ * with loose scalars, so it also allocates no per-sample tuple.
+ */
+interface VolumeSamples {
+  xs: Float64Array;
+  ys: Float64Array;
+  zs: Float64Array;
+  /** `sampleMeshField` at each point — the fixed side of the difference. */
+  target: Float64Array;
+}
+
+function sampleVolume(field: MeshFieldData): VolumeSamples {
   const { bbox } = field;
-  let sum = 0;
+  const per = VOLUME_STEPS + 1;
+  const count = per * per * per;
+  const xs = new Float64Array(count);
+  const ys = new Float64Array(count);
+  const zs = new Float64Array(count);
+  const target = new Float64Array(count);
   let n = 0;
+  // Same i/j/k nesting and order as the objective always used, so the sum below
+  // accumulates in the identical sequence — a reproducible fit must not depend
+  // on this being a no-op reordering, and it is not one.
   for (let i = 0; i <= VOLUME_STEPS; i++) {
     const x = bbox.min[0] + ((bbox.max[0] - bbox.min[0]) * i) / VOLUME_STEPS;
     for (let j = 0; j <= VOLUME_STEPS; j++) {
       const y = bbox.min[1] + ((bbox.max[1] - bbox.min[1]) * j) / VOLUME_STEPS;
       for (let k = 0; k <= VOLUME_STEPS; k++) {
         const z = bbox.min[2] + ((bbox.max[2] - bbox.min[2]) * k) / VOLUME_STEPS;
-        const d = evaluateSDF(node, [x, y, z]) - sampleMeshField(field, x, y, z);
-        sum += d * d;
+        xs[n] = x;
+        ys[n] = y;
+        zs[n] = z;
+        target[n] = sampleMeshField(field, x, y, z);
         n++;
       }
     }
   }
-  return sum / n;
+  return { xs, ys, zs, target };
+}
+
+/** Squared field difference over the precomputed volume samples — the optimiser's objective. */
+function volumeCost(vol: VolumeSamples, node: SDFNode): number {
+  const { xs, ys, zs, target } = vol;
+  const count = target.length;
+  let sum = 0;
+  for (let n = 0; n < count; n++) {
+    const d = evalAt(node, xs[n], ys[n], zs[n]) - target[n];
+    sum += d * d;
+  }
+  return sum / count;
 }
 
 /** Surface residual, in millimetres, of `node` against the mesh's own surface. */
@@ -368,9 +411,9 @@ function extentAlong(pts: Vec3[], centre: Vec3, axis: Vec3): { radius: number; h
  * much as just trying the step. Coordinate descent needs no derivative, cannot
  * diverge, and the parameter count is six at most.
  */
-function refine(field: MeshFieldData, c: Candidate, scale: number): number[] {
+function refine(vol: VolumeSamples, c: Candidate, scale: number): number[] {
   let params = [...c.params];
-  let best = volumeCost(field, c.build(params));
+  let best = volumeCost(vol, c.build(params));
   let step = scale * 0.08;
   for (let pass = 0; pass < 24 && step > scale * 1e-4; pass++) {
     let improved = false;
@@ -378,7 +421,7 @@ function refine(field: MeshFieldData, c: Candidate, scale: number): number[] {
       for (const dir of [1, -1]) {
         const trial = [...params];
         trial[i] += dir * step;
-        const cost = volumeCost(field, c.build(trial));
+        const cost = volumeCost(vol, c.build(trial));
         if (cost < best) { best = cost; params = trial; improved = true; break; }
       }
     }
@@ -430,10 +473,11 @@ export function fitPrimitive(field: MeshFieldData): FitResult | null {
   if (!(diag > 0)) return null;
 
   const pts = surfacePoints(field);
+  const vol = sampleVolume(field);
   let best: FitResult | null = null;
 
   for (const c of candidates(extent, pts)) {
-    const params = refine(field, c, diag);
+    const params = refine(vol, c, diag);
     if (c.degenerate?.(params)) continue;
     const node = c.build(params);
     const { rms, max } = surfaceResidual(node, pts);

From b0372cfff51452e0e29a343d9a5375a48d40c4aa Mon Sep 17 00:00:00 2001
From: Kevin Blackburn-Matzen <kmatzen@gmail.com>
Date: Sat, 5 Sep 2026 17:05:00 -0700
Subject: [PATCH 3/4] Update outline golden for constant CSS width

---
 e2e/golden-snapshots/linear-pattern.png | Bin 7514 -> 8073 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/e2e/golden-snapshots/linear-pattern.png b/e2e/golden-snapshots/linear-pattern.png
index bd9ae87bb875b3fd8e141124973b733ce84969f8..555fc26c83ee89398b33c8dc93bc992e29a00e1e 100644
GIT binary patch
literal 8073
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

literal 7514
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


From 9ce252034a3582e6d33dacea4670b7cd95abe398 Mon Sep 17 00:00:00 2001
From: Kevin Blackburn-Matzen <kmatzen@gmail.com>
Date: Sat, 5 Sep 2026 17:14:05 -0700
Subject: [PATCH 4/4] Allow accumulated ulps in interval property test

---
 src/worker/sdf/interval.test.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/worker/sdf/interval.test.ts b/src/worker/sdf/interval.test.ts
index 1526f04..90c33b4 100644
--- a/src/worker/sdf/interval.test.ts
+++ b/src/worker/sdf/interval.test.ts
@@ -63,7 +63,10 @@ describe('the interval enclosure contains the pointwise field', () => {
         const iv = evaluateInterval(tree, box);
         if (!isFinite(iv.lo) && !isFinite(iv.hi)) return true;
         const scale = Math.max(...[0, 1, 2].map((k) => bb.max[k] - bb.min[k]));
-        const tol = scale * 1e-6 + 1e-9;
+        // Nested transforms and repetition can accumulate a few ulps beyond
+        // the scale-relative allowance (the CI counterexample missed by
+        // 9.8e-10 after six patterned, non-uniformly scaled copies).
+        const tol = scale * 1e-6 + 1e-8;
         for (const p of samplesIn(box, 120, seed)) {
           const v = evaluateSDF(tree, p);
           if (!isFinite(v)) continue;