www/map: revert circle-mode picker override — circle is a pure render swap

Prior commit `aca0fcd5c9e` had circle mode coarsen the picker (r10→r9,
r11→r10 etc) to save bandwidth. That conflates two orthogonal concerns:
viz rendering vs. wire-format optimization. The original circle-mode
design was superficial — draw each cell as a circular column instead of
a hex tessellation, everything else identical.

Reverting the coarsest-fit override; circle mode now uses identical
picker → identical res → identical cell fetch as hex mode.

Bandwidth optimizations for the ~1 MB responses at coarse zoom still
wanted — but they belong elsewhere:
  - Worker-side `maxCells` adaptive coarsening on the combo path
  - Parquet transport (drop JSON overhead per row)
Neither of those changes what the user sees — only what fills the wire.

Tests updated accordingly: circle-mode picker now asserted equal to
hex-mode picker across the zoom sweep. 32 passing, was 46.

Refs #121.

Author: ryan-williams

www/src/map/picker.test.ts

@@ -48,82 +48,30 @@ describe("picker: hex mode auto res per zoom", () => {
     }
 })
 
-describe("picker: circle mode coarsest-fit override", () => {
-    // Below the rasterized threshold (target dot < 1.5px), circle mode
-    // MUST fall through to hex-mode auto to preserve statewide density
-    // paint. Above it, circle can go coarser than hex mode.
-    it("z=8.5 (target < 1.5px): matches hex auto (r9, rasterized)", () => {
-        expect(circleRadiusPx(8.5)).toBeLessThan(1.5)
-        expect(pickRes("circle", 8.5, NJ_LAT)).toBe(pickRes("hex", 8.5, NJ_LAT))
-    })
-
-    // Anchor circle-mode picks at every zoom in a table so any drift
-    // shows up loud.
-    const cases: Array<[number, number, number]> = [
-        // [zoom, hex_res, circle_res]
-        [8.5, 9, 9],    // rasterized preserved (target < 1.5)
-        [8.7, 9, 8],    // one-step jump at threshold crossing (target ≈ 1.53)
-        [9.0, 9, 8],
-        [10.94, 10, 9], // Bergen — the vp that flagged the picker over-fetch
-        [11.0, 10, 9],
-        [12.0, 11, 9],
-        [13.81, 11, 10], // mid-zoom (DTJC)
-        [14.0, 12, 11],
-        [16.91, 12, 12], // deep: auto wins (coarsestFit fits inside auto)
-        [17.0, 13, 12], // circle stays r12; hex bumps to r13
-        [18.0, 14, 13],
-        [19.0, 15, 13], // circle strictly coarser at very deep zoom
-        [20.0, 15, 14],
-    ]
-    for (const [zoom, hex, circle] of cases) {
-        it(`z=${zoom}: hex=r${hex}, circle=r${circle}`, () => {
-            expect(pickRes("hex", zoom, NJ_LAT)).toBe(hex)
-            expect(pickRes("circle", zoom, NJ_LAT)).toBe(circle)
-        })
-    }
-})
-
-describe("picker: hex mode monotone (never coarser as we zoom in)", () => {
-    // Hex-mode tessellation should never drop res as zoom increases.
-    // Circle mode is intentionally *not* monotone at the boundary
-    // crossing (z≈8.5 target=1.49→1.55 wants slightly-coarser cells so
-    // 1.5px dots fit inscribed instead of clamping to sub-px on r9).
-    it("res non-decreasing across z=7 → 20 (hex)", () => {
-        let prev = -1
-        for (let z = 7; z <= 20; z += 0.1) {
-            const r = pickRes("hex", z, NJ_LAT)
-            expect(r).toBeGreaterThanOrEqual(prev)
-            prev = r
-        }
-    })
-})
-
-describe("picker: circle mode piecewise monotone", () => {
-    // Circle mode has ONE legit dropdown at the rasterized→discrete-dot
-    // threshold crossing (z≈8.6 for the current curve). Everywhere else
-    // it should stay non-decreasing as z increases.
-    it("at most one res-drop across z=7 → 20", () => {
-        let prev = -1
-        let drops = 0
-        for (let z = 7; z <= 20; z += 0.1) {
-            const r = pickRes("circle", z, NJ_LAT)
-            if (r < prev) drops++
-            prev = r
+describe("picker: circle mode == hex mode (pure rendering swap)", () => {
+    // Circle mode is a rendering swap only — same picker, same res,
+    // same cell fetch. Anything else conflates two concerns (viz
+    // rendering vs. bandwidth optimization). Bandwidth wins live
+    // elsewhere (worker-side coarsening, parquet transport).
+    it("hex and circle pick identical res across z=7 → 20", () => {
+        for (let z = 7; z <= 20; z += 0.25) {
+            expect(pickRes("circle", z, NJ_LAT)).toBe(pickRes("hex", z, NJ_LAT))
         }
-        expect(drops).toBeLessThanOrEqual(1)
     })
 })
 
-describe("picker: circle mode never picks a res finer than hex mode", () => {
-    // Corollary of the "Math.max with auto" guard — circle-mode's data
-    // reduction should never accidentally fetch finer cells than hex.
-    it("across z=7 → 20", () => {
-        for (let z = 7; z <= 20; z += 0.25) {
-            const hexRes = pickRes("hex", z, NJ_LAT)
-            const circleRes = pickRes("circle", z, NJ_LAT)
-            expect(circleRes).toBeLessThanOrEqual(hexRes)
-        }
-    })
+describe("picker: monotone in zoom (never coarser as we zoom in)", () => {
+    // Both modes: as zoom deepens, res never decreases.
+    for (const viz of ["hex", "circle"] as const) {
+        it(`${viz} mode: res non-decreasing across z=7 → 20`, () => {
+            let prev = -1
+            for (let z = 7; z <= 20; z += 0.1) {
+                const r = pickRes(viz, z, NJ_LAT)
+                expect(r).toBeGreaterThanOrEqual(prev)
+                prev = r
+            }
+        })
+    }
 })
 
 describe("picker: circleRadiusPx curve", () => {

www/src/map/picker.ts

@@ -39,32 +39,20 @@ export function autoHexPxTarget(
     return Math.min(30, Math.max(1.0, diaPx * 0.99))
 }
 
-/** Threshold (px) below which we stay in the *rasterized-heatmap*
- *  regime — target dot < ~1.5px, cells blend into density paint. Above
- *  this we're in the *discrete-dot* regime where we can safely drop to
- *  a coarser resolution whose inscribed circle still fits the target
- *  dot, saving bandwidth without changing the visual. */
-const CIRCLE_RASTERIZED_THRESHOLD_PX = 1.5
-
 /** Effective `hexPxTarget` fed into `pickHexResolutionForPixels`.
- *  Layer over the auto target with viz-mode overrides. */
+ *  Circle mode uses the identical picker as hex mode — same res, same
+ *  cell count, same fetch. Circle is a pure rendering swap: each cell
+ *  is drawn as a circular column clamped to the cell's inscribed
+ *  radius. Bandwidth optimizations belong elsewhere (worker-side
+ *  aggregation, parquet transport). */
 export function hexPxTargetFor(
     viz: VizMode,
     zoom: number,
     lat: number,
     autoOverrides: Record<number, number> = {},
 ): number {
-    const auto = autoHexPxTarget(zoom, lat, autoOverrides)
-    if (viz !== "circle") return auto
-    const target = circleRadiusPx(zoom)
-    if (target < CIRCLE_RASTERIZED_THRESHOLD_PX) return auto
-    // inscribed_radius ≥ target_radius ⇔ hex_diameter ≥ 4·target/√3.
-    // Accept up to ~15% clamp (dot rendered slightly smaller than
-    // target) rather than jump two H3 levels for a strict fit — the
-    // difference between "1.5px" and "1.3px" dots is invisible; the
-    // difference between r7 and r8 cell counts is 7×.
-    const coarsestFit = ((4 * target) / Math.sqrt(3)) / 1.15
-    return Math.max(auto, coarsestFit)
+    void viz  // parity with hex mode
+    return autoHexPxTarget(zoom, lat, autoOverrides)
 }
 
 /** End-to-end: given (viz, zoom, lat, autoOverrides), return the H3