@buley/hexgrid-3d 3.4.0 → 3.5.1

package/dist/adapters/DashAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DashAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/DashAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAM;gBAEN,YAAY,EAAE,GAAG;IAI7B;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG;CA6BtD"}
+{"version":3,"file":"DashAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/DashAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAM;gBAEN,YAAY,EAAE,GAAG;IAI7B;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG;CA6BtD"}

package/dist/adapters/DashAdapter.js

@@ -4,6 +4,7 @@
  * This adapter subscribes to a Dash "LiveQuery" which returns pointers to shared memory (SharedArrayBuffer)
  * or Float32Arrays. It then syncs this data directly to the HexGridWasm instance.
  */
+import { logger } from '../lib/logger';
 export class DashAdapter {
     constructor(dashInstance) {
         this.dash = dashInstance;
@@ -15,11 +16,11 @@ export class DashAdapter {
      * @param gridInstance The WASM instance of the HexGrid
      */
     bindSemanticSearch(query, particleSystem) {
-        console.log('[DashAdapter] Binding semantic search:', query);
+        logger.log('[DashAdapter] Binding semantic search:', query);
         // Hypothetical Zero-Copy API from Dash 2.0
         if (this.dash.liveQueryPtr) {
             this.dash.liveQueryPtr(`SELECT embedding FROM dash_vec_idx WHERE embedding MATCH '${query}'`).subscribe((handle) => {
-                console.log(`[DashAdapter] Received ${handle.size} bytes from Dash.`);
+                logger.log(`[DashAdapter] Received ${handle.size} bytes from Dash.`);
                 // Assume the handle.buffer contains [pos, color, scale] interleaved or tightly packed
                 // For this MVP, we treat it as just positions
                 const floatView = new Float32Array(handle.buffer);
@@ -36,7 +37,7 @@ export class DashAdapter {
             });
         }
         else {
-            console.warn('[DashAdapter] Dash instance does not support Zero-Copy liveQueryPtr yet.');
+            logger.warn('[DashAdapter] Dash instance does not support Zero-Copy liveQueryPtr yet.');
         }
     }
 }

package/dist/algorithms/FluidEngineFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidEngineFactory.d.ts","sourceRoot":"","sources":["../../src/algorithms/FluidEngineFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAEvF;;;;;;GAMG;AACH,qBAAa,kBAAkB;WAChB,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;CA6BjE"}
+{"version":3,"file":"FluidEngineFactory.d.ts","sourceRoot":"","sources":["../../src/algorithms/FluidEngineFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAEvF;;;;;;GAMG;AACH,qBAAa,kBAAkB;WAChB,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;CA6BjE"}

package/dist/algorithms/FluidEngineFactory.js

@@ -1,6 +1,7 @@
 import { StableFluids3D } from './FluidSimulation3D';
 import { FluidSimulationWebNN } from './FluidSimulationWebNN';
 import { FluidSimulation3DGPU } from './FluidSimulation3DGPU';
+import { logger } from '../lib/logger';
 /**
  * Factory to select the best available Fluid Engine.
  * Priority:
@@ -15,27 +16,27 @@ export class FluidEngineFactory {
             const webnn = new FluidSimulationWebNN(config);
             const webnnSupported = await webnn.initialize();
             if (webnnSupported) {
-                console.log("Fluid Engine: Using WebNN (NPU)");
+                logger.log("Fluid Engine: Using WebNN (NPU)");
                 return webnn;
             }
         }
         catch (e) {
-            console.warn("Fluid Engine: WebNN init failed", e);
+            logger.warn("Fluid Engine: WebNN init failed", e);
         }
         // 2. Try WebGPU
         try {
             const webgpu = new FluidSimulation3DGPU(config);
             const webgpuSupported = await webgpu.initialize();
             if (webgpuSupported) {
-                console.log("Fluid Engine: Using WebGPU");
+                logger.log("Fluid Engine: Using WebGPU");
                 return webgpu;
             }
         }
         catch (e) {
-            console.warn("Fluid Engine: WebGPU init failed", e);
+            logger.warn("Fluid Engine: WebGPU init failed", e);
         }
         // 3. Fallback to CPU
-        console.log("Fluid Engine: using CPU Fallback");
+        logger.log("Fluid Engine: using CPU Fallback");
         return new StableFluids3D(config);
     }
 }

package/dist/components/HexGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HexGrid.d.ts","sourceRoot":"","sources":["../../src/components/HexGrid.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4D,MAAM,OAAO,CAAA;AAYhF,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAI/C,YAAY,EAAE,KAAK,EAAE,CAAA;AAWrB,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IAEvC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAA;IACrB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;IAGhB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IACzC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAEnC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAA;IAC9C,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI,CAAA;IAC5G,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,0BAA0B,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACpD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,KAAK,CAAA;IACZ,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAoLD,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,OAAO,EAAE,iMAalC,YAAY,CAAC,CAAC,CAAC,4CAytIjB,CAAA;AAk7DD,eAAe,OAAO,CAAC"}
+{"version":3,"file":"HexGrid.d.ts","sourceRoot":"","sources":["../../src/components/HexGrid.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4D,MAAM,OAAO,CAAA;AAYhF,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAI/C,YAAY,EAAE,KAAK,EAAE,CAAA;AAWrB,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IAEvC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAA;IACrB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;IAGhB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IACzC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAEnC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAA;IAC9C,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI,CAAA;IAC5G,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,0BAA0B,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACpD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,KAAK,CAAA;IACZ,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAoLD,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,OAAO,EAAE,iMAalC,YAAY,CAAC,CAAC,CAAC,4CA4xIjB,CAAA;AAk7DD,eAAe,OAAO,CAAC"}

package/dist/components/HexGrid.js

@@ -152,6 +152,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
     // Stream control refs to coordinate long-running UI streaming from worker
     const streamTokenRef = useRef(0);
     const streamActiveRef = useRef(false);
+    const streamTouchesOccupancyRef = useRef(false);
     // Reactive state for telemetry overlay (mirrors streamActiveRef)
     const [streamingActive, setStreamingActive] = useState(false);
     // How many tiles remain to stream in the current streaming run
@@ -283,10 +284,9 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             // gridScale >1 reduces effective hex radius (more hexes), <1 increases radius (fewer hexes)
             gridScale: 1,
             // tileSize: base hex radius in pixels (editable)
-            // Increased from 6 to 12 for better performance (larger hexes = fewer total hexes = better performance)
-            tileSize: 12,
+            tileSize: 8,
             // hexSpacing: multiplier for hex size (1.0 = perfect touching, <1.0 = gaps, >1.0 = overlap)
-            hexSpacing: 1.0,
+            hexSpacing: 0.95,
             // sphericalDensity: multiplier for spherical grid density (1.0 = default, >1.0 = more hexes)
             sphericalDensity: 1.4,
             // curvature controls (degrees) - start with a visually pleasing curvature
@@ -304,8 +304,8 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             polePower: 0.9,
             // Render both sides option: when true, draw an antipodal copy so images show on inside/outside
             renderBothSides: false,
-            // Worker debug logs (ENABLED for debugging evolution issues)
-            debugLogs: true,
+            // Worker debug logs (disabled by default for performance)
+            debugLogs: false,
             // Cluster tiling defaults: preserve aspect, center anchor, no global alignment,
             // zero uv inset for perfect alignment (seam blending handled separately), no jitter by default
             clusterPreserveAspect: true,
@@ -1254,6 +1254,8 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             dlog('HexGrid: Grid dimensions changed, reinitializing infections', { old: prevGridKeyRef.current, new: gridKey });
             const isSpherical = gridMetadataRef.current?.isSpherical ?? false;
             const initState = initializeInfectionSystem(hexPositions, photos, effectiveHexRadius, workerDebugRef.current?.spawnClusterMax ?? 8, logger, isSpherical);
+            blankNeighborCountGenerationRef.current = -1;
+            blankNeighborCountRef.current = new Map();
             setInfectionState(initState);
             infectionStateRef.current = initState;
             // Post to worker immediately (use sendEvolve helper so generation is logged)
@@ -1858,6 +1860,16 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
     const tileAlphaRef = useRef(new Map());
     // Per-tile arrival pulse timestamps (ms) to show a brief highlight when a tile appears/updates
     const tilePulseRef = useRef(new Map());
+    // Worker-precomputed neighbor blank counts (index -> blank-neighbor count)
+    const blankNeighborCountRef = useRef(new Map());
+    const blankNeighborCountGenerationRef = useRef(-1);
+    // Fallback cache for local blank-neighbor computation when worker data is unavailable/mismatched
+    const localBlankNeighborCacheRef = useRef({
+        infectionMap: null,
+        positions: null,
+        hexRadius: -1,
+        counts: new Map()
+    });
     // Runtime telemetry: frame timing buffer for FPS/ms overlay
     const frameTimesRef = useRef([]);
     const lastFrameTimeRef = useRef(performance.now());
@@ -2065,8 +2077,9 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
     const lastDrawTimeRef = useRef(0);
     const lastDrawGenRef = useRef(0);
     const cameraDirtyRef = useRef(true);
-    // Minimum ms between draws when idle (30fps)
-    const minFrameMs = 1000 / 30;
+    // Draw cadence: 30fps when actively animating, lower cadence while static.
+    const activeFrameMs = 1000 / 30;
+    const idleFrameMs = 250;
     // Helper to get effective batchPerFrame (transient override if present)
     const getEffectiveBatch = () => {
         const base = Math.max(0, Math.floor(workerDebugRef.current?.batchPerFrame ?? 0));
@@ -2250,6 +2263,8 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                 lastEvolutionTime: infectionStateRef.current.lastEvolutionTime,
                 generation: infectionStateRef.current.generation
             };
+            blankNeighborCountGenerationRef.current = -1;
+            blankNeighborCountRef.current = new Map();
             setInfectionState(filteredState);
             infectionStateRef.current = filteredState;
             if (workerRef.current) {
@@ -2277,6 +2292,8 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             // Use the live spawnClusterMax from workerDebug when available so photo reloads honor debug tuning
             const isSpherical = gridMetadataRef.current?.isSpherical ?? false;
             const initState = initializeInfectionSystem(hexPositions, photos, effectiveHexRadius, workerDebugRef.current?.spawnClusterMax ?? 8, logger, isSpherical);
+            blankNeighborCountGenerationRef.current = -1;
+            blankNeighborCountRef.current = new Map();
             setInfectionState(initState);
             infectionStateRef.current = initState;
             if (workerRef.current) {
@@ -2408,6 +2425,20 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                 dlog('Processing evolved state with', data.infections.length, 'gossip entries');
                 // Convert back from array to Map
                 const newInfectionsMap = new Map(data.infections);
+                if (Array.isArray(data.blankNeighborCounts)) {
+                    try {
+                        blankNeighborCountRef.current = new Map(data.blankNeighborCounts);
+                        blankNeighborCountGenerationRef.current = typeof data.generation === 'number' ? data.generation : -1;
+                    }
+                    catch (err) {
+                        // ignore malformed worker payload
+                    }
+                }
+                else {
+                    // Fallback to local computation when worker payload doesn't include counts.
+                    blankNeighborCountGenerationRef.current = -1;
+                    blankNeighborCountRef.current = new Map();
+                }
                 // Capture tile centers for debug visualization if available
                 if (data.tileCenters && Array.isArray(data.tileCenters)) {
                     try {
@@ -2477,6 +2508,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                 });
                 // If no changes, just replace state
                 if (changes.length === 0) {
+                    streamTouchesOccupancyRef.current = false;
                     setInfectionState({
                         infections: newInfectionsMap,
                         availableIndices: data.availableIndices,
@@ -2494,6 +2526,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                 // Start streaming changes; cancel any previous streamer.
                 streamTokenRef.current += 1;
                 const token = streamTokenRef.current;
+                streamTouchesOccupancyRef.current = changes.some((ch) => ch.type !== 'update');
                 // Mark streaming active so other code (animation loop) can avoid posting new evolves
                 streamActiveRef.current = true;
                 try {
@@ -2520,6 +2553,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                             // stop if cancelled
                             if (streamTokenRef.current !== token) {
                                 streamActiveRef.current = false;
+                                streamTouchesOccupancyRef.current = false;
                                 try {
                                     setStreamingActive(false);
                                 }
@@ -2567,6 +2601,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                             }
                             else {
                                 streamActiveRef.current = false;
+                                streamTouchesOccupancyRef.current = false;
                                 try {
                                     setStreamingActive(false);
                                 }
@@ -2598,6 +2633,10 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                                 streamActiveRef.current = false;
                             }
                             catch (e) { }
+                            try {
+                                streamTouchesOccupancyRef.current = false;
+                            }
+                            catch (e) { }
                             try {
                                 setStreamingActive(false);
                             }
@@ -2657,6 +2696,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                         }
                         finally {
                             streamActiveRef.current = false;
+                            streamTouchesOccupancyRef.current = false;
                             try {
                                 setStreamingActive(false);
                             }
@@ -2687,25 +2727,54 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
         // Clear canvas
         ctx.fillStyle = '#001122';
         ctx.fillRect(0, 0, screenWidth, screenHeight);
-        // Precompute which infected hexagons are adjacent to a blank (uninfected) hex
-        const infectedIndices = Array.from(infectionState.infections.keys());
-        const infectedSet = new Set(infectedIndices);
-        const blankNeighborCount = new Map();
-        for (const idx of infectedIndices) {
-            // Guard: ensure the index is valid before processing
-            if (idx < 0 || idx >= hexPositions.length)
-                continue;
-            const isSpherical = gridMetadataRef.current?.isSpherical ?? false;
-            const neighbors = getNeighbors(idx, hexPositions, drawnHexRadius, isSpherical);
-            let count = 0;
-            for (const n of neighbors) {
-                if (!infectedSet.has(n))
-                    count++;
+        const infections = infectionState.infections;
+        const dbg = workerDebugRef.current;
+        const projectedPositions = projectedPositionsRef.current;
+        const pulseMap = tilePulseRef.current;
+        const prevAlphaMap = tileAlphaRef.current;
+        const smooth = Math.max(0, Math.min(1, dbg?.translucencySmoothing ?? 0.08));
+        const scratchEnabled = !!dbg?.scratchEnabled;
+        const sheenIntensity = dbg?.sheenIntensity ?? 0.12;
+        const sheenEnabled = !!dbg?.sheenEnabled;
+        const seamInset = dbg?.clusterUvInset ?? 0.0;
+        const isSpherical = gridMetadataRef.current?.isSpherical ?? false;
+        const computeLocalBlankNeighborCounts = () => {
+            const cache = localBlankNeighborCacheRef.current;
+            if (cache.infectionMap === infections &&
+                cache.positions === hexPositions &&
+                cache.hexRadius === drawnHexRadius) {
+                return cache.counts;
+            }
+            const infectedIndices = Array.from(infections.keys());
+            const infectedSet = new Set(infectedIndices);
+            const computed = new Map();
+            for (const idx of infectedIndices) {
+                if (idx < 0 || idx >= hexPositions.length)
+                    continue;
+                const neighbors = getNeighbors(idx, hexPositions, drawnHexRadius, isSpherical);
+                let count = 0;
+                for (const n of neighbors) {
+                    if (!infectedSet.has(n))
+                        count++;
+                }
+                computed.set(idx, count);
             }
-            blankNeighborCount.set(idx, count);
-        }
+            localBlankNeighborCacheRef.current = {
+                infectionMap: infections,
+                positions: hexPositions,
+                hexRadius: drawnHexRadius,
+                counts: computed
+            };
+            return computed;
+        };
+        const canUseWorkerBlankCounts = blankNeighborCountRef.current.size > 0 &&
+            blankNeighborCountGenerationRef.current === infectionState.generation &&
+            !(streamActiveRef.current && streamTouchesOccupancyRef.current);
+        const blankNeighborCount = canUseWorkerBlankCounts
+            ? blankNeighborCountRef.current
+            : computeLocalBlankNeighborCounts();
         // compute sheen progress using configured speed
-        const sheenSpeed = Math.max(0.1, workerDebugRef.current?.sheenSpeed || 10);
+        const sheenSpeed = Math.max(0.1, dbg?.sheenSpeed || 10);
         const now = performance.now();
         const sheenProgress = ((now / 1000) % sheenSpeed) / sheenSpeed;
         // Draw hexagons (with alpha smoothing)
@@ -2743,39 +2812,30 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
         }
         for (let index = 0; index < hexPositions.length; index++) {
             const position = hexPositions[index];
-            // Validate index bounds first
-            if (index < 0 || index >= hexPositions.length)
-                continue;
-            const infection = infectionState.infections.get(index);
-            // CRITICAL GUARD: Skip drawing if this is an uninfected cell with no valid position data
-            // This prevents "ghost" hexagons from appearing in the background
-            if (!infection && !position)
+            if (!position)
                 continue;
+            const infection = infections.get(index);
             const blankCount = infection ? (blankNeighborCount.get(index) || 0) : 0;
             // target alpha based on blank count
             const targetAlpha = infection ? (1.0 - Math.min(blankCount, 6) * 0.066) : 1.0;
-            const prevAlphaMap = tileAlphaRef.current;
             const prev = prevAlphaMap.get(index) ?? targetAlpha;
-            const smooth = Math.max(0, Math.min(1, workerDebugRef.current?.translucencySmoothing ?? 0.08));
             const smoothed = prev + (targetAlpha - prev) * smooth;
             prevAlphaMap.set(index, smoothed);
-            const scratchEnabled = !!workerDebugRef.current?.scratchEnabled;
-            const sheenIntensity = workerDebugRef.current?.sheenIntensity ?? 0.12;
             // Compute pulse progress for this tile
-            const pulseInfo = tilePulseRef.current.get(index);
+            const pulseInfo = pulseMap.get(index);
             let pulseProgress = 0;
             if (pulseInfo) {
-                const elapsed = performance.now() - pulseInfo.start;
+                const elapsed = now - pulseInfo.start;
                 pulseProgress = Math.max(0, Math.min(1, elapsed / pulseInfo.duration));
                 if (pulseProgress >= 1)
-                    tilePulseRef.current.delete(index);
+                    pulseMap.delete(index);
             }
             // Use projected position and scale for drawing
-            const proj = projectedPositionsRef.current[index] || [position[0], position[1], 1, 0, 0];
-            const projX = proj[0];
-            const projY = proj[1];
-            const projScale = proj[2];
-            const projAngle = proj[3] || 0;
+            const proj = projectedPositions[index];
+            const projX = proj ? proj[0] : position[0];
+            const projY = proj ? proj[1] : position[1];
+            const projScale = proj ? proj[2] : 1;
+            const projAngle = proj ? (proj[3] || 0) : 0;
             // proj[4] is z-depth (not needed for drawing, only for click detection)
             // Selective culling: when low-res mode is active, always draw infected tiles but
             // sample uninfected/background tiles to reduce draw count while preserving layout.
@@ -2790,17 +2850,15 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                 }
             }
             // Draw primary - use drawnHexRadius to account for spacing
-            const sheenEnabled = !!workerDebugRef.current?.sheenEnabled;
-            drawHexagon(ctx, [projX, projY, 0], drawnHexRadius * projScale, infection, textures, index, blankCount, smoothed, sheenProgress, sheenIntensity, sheenEnabled, scratchEnabled, scratchCanvasRef.current, workerDebugRef.current?.clusterUvInset ?? 0.0, pulseProgress, false, false, projAngle);
+            drawHexagon(ctx, [projX, projY, 0], drawnHexRadius * projScale, infection, textures, index, blankCount, smoothed, sheenProgress, sheenIntensity, sheenEnabled, scratchEnabled, scratchCanvasRef.current, seamInset, pulseProgress, false, false, projAngle);
             // Optionally draw antipodal copy (opposite side of sphere).
             // Use the same projection helper as hit-tests so angles/positions match exactly.
-            if (workerDebug.renderBothSides) {
+            if (dbg?.renderBothSides) {
                 try {
                     const anti = mapAndProject(hexPositions[index], true);
                     const antiScale = anti.scale || 1;
                     const antiAngle = anti.angle || 0;
-                    const sheenEnabledAnti = !!workerDebugRef.current?.sheenEnabled;
-                    drawHexagon(ctx, [anti.x, anti.y, 0], drawnHexRadius * antiScale, infection, textures, index, blankCount, smoothed, sheenProgress, sheenIntensity, sheenEnabledAnti, scratchEnabled, scratchCanvasRef.current, workerDebugRef.current?.clusterUvInset ?? 0.0, pulseProgress, false, true, antiAngle);
+                    drawHexagon(ctx, [anti.x, anti.y, 0], drawnHexRadius * antiScale, infection, textures, index, blankCount, smoothed, sheenProgress, sheenIntensity, sheenEnabled, scratchEnabled, scratchCanvasRef.current, seamInset, pulseProgress, false, true, antiAngle);
                 }
                 catch (err) {
                     // Skip drawing antipodal hex if projection fails
@@ -2816,10 +2874,11 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
         try {
             if (workerDebugRef.current?.debugLogs) {
                 // Sample a few random infected hexes to check
+                const infectedIndices = Array.from(infections.keys());
                 const sampleSize = Math.min(5, infectedIndices.length);
                 for (let s = 0; s < sampleSize; s++) {
                     const idx = infectedIndices[Math.floor(Math.random() * infectedIndices.length)];
-                    const infection = infectionState.infections.get(idx);
+                    const infection = infections.get(idx);
                     if (!infection)
                         continue;
                     const texture = textures.get(infection.photo.id);
@@ -2829,7 +2888,7 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
                     const isSpherical = gridMetadataRef.current?.isSpherical ?? false;
                     const neighbors = getNeighbors(idx, hexPositions, drawnHexRadius, isSpherical);
                     for (const nIdx of neighbors) {
-                        const nInf = infectionState.infections.get(nIdx);
+                        const nInf = infections.get(nIdx);
                         // Only check neighbors with the same photo (adjacent tiles of same image)
                         if (!nInf || nInf.photo.id !== infection.photo.id)
                             continue;
@@ -3016,7 +3075,9 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             // If camera changed recently or infections changed (generation advanced), draw immediately
             const gen = infectionState.generation;
             const genChanged = gen !== lastDrawGenRef.current;
-            if (cameraDirtyRef.current || genChanged || timeSinceLast >= minFrameMs) {
+            const hasVisualAnimation = !!workerDebugRef.current?.sheenEnabled || tilePulseRef.current.size > 0 || streamActiveRef.current;
+            const targetFrameMs = hasVisualAnimation ? activeFrameMs : idleFrameMs;
+            if (cameraDirtyRef.current || genChanged || timeSinceLast >= targetFrameMs) {
                 draw();
                 lastDrawTimeRef.current = now;
                 lastDrawGenRef.current = gen;
@@ -3113,6 +3174,8 @@ export const HexGrid = ({ items, photos: photosProp, onItemClick, onHexClick, sp
             logger.error('spawnClusterAt: Invalid center index', centerIndex);
             return;
         }
+        blankNeighborCountGenerationRef.current = -1;
+        blankNeighborCountRef.current = new Map();
         setInfectionState(prevState => {
             const newInfections = new Map(prevState.infections);
             const newAvailableIndices = [...prevState.availableIndices];

package/dist/lib/logger.d.ts

@@ -1,13 +1,7 @@
 export declare const logger: {
     debug: (..._args: unknown[]) => void;
-    log: {
-        (...data: any[]): void;
-        (...data: any[]): void;
-    };
-    info: {
-        (...data: any[]): void;
-        (...data: any[]): void;
-    };
+    log: (..._args: unknown[]) => void;
+    info: (..._args: unknown[]) => void;
     warn: {
         (...data: any[]): void;
         (...data: any[]): void;

package/dist/lib/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM;sBANK,OAAO,EAAE;;;;;;;;;;;;;;;;;CAYhC,CAAA"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM;sBANK,OAAO,EAAE;oBAAT,OAAO,EAAE;qBAAT,OAAO,EAAE;;;;;;;;;CAYhC,CAAA"}

package/dist/lib/logger.js

@@ -2,8 +2,8 @@ const noop = (..._args) => { };
 const isDev = typeof process !== 'undefined' && process?.env?.NODE_ENV !== 'production';
 export const logger = {
     debug: isDev ? console.debug.bind(console) : noop,
-    log: console.log.bind(console),
-    info: console.info.bind(console),
+    log: isDev ? console.log.bind(console) : noop,
+    info: isDev ? console.info.bind(console) : noop,
     warn: console.warn.bind(console),
     error: console.error.bind(console),
 };

package/dist/wasm/HexGridWasmWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HexGridWasmWrapper.d.ts","sourceRoot":"","sources":["../../src/wasm/HexGridWasmWrapper.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"HexGridWasmWrapper.d.ts","sourceRoot":"","sources":["../../src/wasm/HexGridWasmWrapper.ts"],"names":[],"mappings":"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"}

package/dist/wasm/HexGridWasmWrapper.js

@@ -6,6 +6,7 @@
  *
  * @module wasm/HexGridWasmWrapper
  */
+import { logger } from '../lib/logger';
 /**
  * Wrapper class that provides TypeScript interface to WASM
  * with automatic fallback
@@ -36,11 +37,11 @@ export class HexGridWasmWrapper {
                 const wasmModule = await import('../rust/pkg/hexgrid_wasm');
                 await wasmModule.default();
                 this.module = wasmModule;
-                console.log('[HexGrid] WASM module loaded successfully');
+                logger.log('[HexGrid] WASM module loaded successfully');
                 return this.module;
             }
             catch (error) {
-                console.warn('[HexGrid] WASM module not available, using fallback:', error);
+                logger.warn('[HexGrid] WASM module not available, using fallback:', error);
                 this.loadFailed = true;
                 return null;
             }

package/dist/webgpu/WebGPUContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUContext.d.ts","sourceRoot":"","sources":["../../src/webgpu/WebGPUContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAgB;IACvC,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,aAAa;IAOnC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAoCpC,SAAS,IAAI,SAAS,GAAG,IAAI;IAI7B,UAAU,IAAI,UAAU,GAAG,IAAI;IAI/B,WAAW,IAAI,OAAO;CAGvB"}
+{"version":3,"file":"WebGPUContext.d.ts","sourceRoot":"","sources":["../../src/webgpu/WebGPUContext.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAgB;IACvC,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,aAAa;IAOnC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAoCpC,SAAS,IAAI,SAAS,GAAG,IAAI;IAI7B,UAAU,IAAI,UAAU,GAAG,IAAI;IAI/B,WAAW,IAAI,OAAO;CAGvB"}

package/dist/webgpu/WebGPUContext.js

@@ -2,6 +2,7 @@
  * WebGPU Context Manager
  * Handles the creation and management of the WebGPU Device and Adapter.
  */
+import { logger } from '../lib/logger';
 export class WebGPUContext {
     constructor() {
         this.adapter = null;
@@ -19,7 +20,7 @@ export class WebGPUContext {
      */
     async initialize() {
         if (typeof navigator === 'undefined' || !navigator.gpu) {
-            console.warn('WebGPU is not supported in this environment.');
+            logger.warn('WebGPU is not supported in this environment.');
             this.isSupported = false;
             return false;
         }
@@ -28,22 +29,22 @@ export class WebGPUContext {
                 powerPreference: 'high-performance'
             });
             if (!this.adapter) {
-                console.warn('No WebGPU adapter found.');
+                logger.warn('No WebGPU adapter found.');
                 this.isSupported = false;
                 return false;
             }
             this.device = await this.adapter.requestDevice();
             this.device.lost.then((info) => {
-                console.error(`WebGPU device lost: ${info.message}`);
+                logger.error(`WebGPU device lost: ${info.message}`);
                 this.device = null;
                 this.isSupported = false;
             });
             this.isSupported = true;
-            console.log('WebGPU initialized successfully.');
+            logger.log('WebGPU initialized successfully.');
             return true;
         }
         catch (e) {
-            console.error('Failed to initialize WebGPU:', e);
+            logger.error('Failed to initialize WebGPU:', e);
             this.isSupported = false;
             return false;
         }

package/dist/webnn/WebNNContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebNNContext.d.ts","sourceRoot":"","sources":["../../src/webnn/WebNNContext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,YAAY;IAOlC;;OAEG;IACG,UAAU,CAAC,UAAU,GAAE,eAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAuCvE,UAAU,IAAI,SAAS,GAAG,IAAI;IAI9B,aAAa,IAAI,eAAe;IAIhC,WAAW,IAAI,OAAO;CAGvB;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,EAAE,EAAE;YACF,aAAa,CAAC,OAAO,CAAC,EAAE;gBAAE,UAAU,CAAC,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;SACtE,CAAC;KACH;IAED,UAAU,SAAS;QAEjB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;KACtI;IAED,UAAU,OAAO;KAEhB;IAED,UAAU,eAAe;KAExB;CACF"}
+{"version":3,"file":"WebNNContext.d.ts","sourceRoot":"","sources":["../../src/webnn/WebNNContext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,YAAY;IAOlC;;OAEG;IACG,UAAU,CAAC,UAAU,GAAE,eAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAuCvE,UAAU,IAAI,SAAS,GAAG,IAAI;IAI9B,aAAa,IAAI,eAAe;IAIhC,WAAW,IAAI,OAAO;CAGvB;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,EAAE,EAAE;YACF,aAAa,CAAC,OAAO,CAAC,EAAE;gBAAE,UAAU,CAAC,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;SACtE,CAAC;KACH;IAED,UAAU,SAAS;QAEjB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;KACtI;IAED,UAAU,OAAO;KAEhB;IAED,UAAU,eAAe;KAExB;CACF"}

package/dist/webnn/WebNNContext.js

@@ -3,6 +3,7 @@
  * Handles the creation and management of the WebNN MLContext.
  * Prioritizes NPU -> GPU -> CPU.
  */
+import { logger } from '../lib/logger';
 export class WebNNContext {
     constructor() {
         this.context = null;
@@ -20,7 +21,7 @@ export class WebNNContext {
      */
     async initialize(preference = 'npu') {
         if (typeof navigator === 'undefined' || !navigator.ml) {
-            console.warn('WebNN is not supported in this environment.');
+            logger.warn('WebNN is not supported in this environment.');
             this.isSupported = false;
             return false;
         }
@@ -29,11 +30,11 @@ export class WebNNContext {
             this.context = await navigator.ml.createContext({ deviceType: preference });
             this.deviceType = preference;
             this.isSupported = true;
-            console.log(`WebNN initialized successfully on ${preference}`);
+            logger.log(`WebNN initialized successfully on ${preference}`);
             return true;
         }
         catch (e) {
-            console.warn(`Failed to initialize WebNN on ${preference}, trying fallback chain...`, e);
+            logger.warn(`Failed to initialize WebNN on ${preference}, trying fallback chain...`, e);
             // Fallback chain: NPU -> GPU -> CPU
             const chain = ['npu', 'gpu', 'cpu'];
             const startIndex = chain.indexOf(preference) + 1;
@@ -43,11 +44,11 @@ export class WebNNContext {
                     this.context = await navigator.ml.createContext({ deviceType: fallback });
                     this.deviceType = fallback;
                     this.isSupported = true;
-                    console.log(`WebNN initialized successfully on fallback ${fallback}`);
+                    logger.log(`WebNN initialized successfully on fallback ${fallback}`);
                     return true;
                 }
                 catch (err) {
-                    console.warn(`Failed to initialize WebNN on fallback ${fallback}`, err);
+                    logger.warn(`Failed to initialize WebNN on fallback ${fallback}`, err);
                 }
             }
         }

package/dist/workers/hexgrid-worker.worker.js

@@ -7,7 +7,11 @@
 // - defensive guards and error reporting via postMessage({type:'error', ...})
 import { getGridBounds as _getGridBounds, distanceBetween as _distanceBetween, calculateUvBoundsFromGridPosition as _calculateUvBoundsFromGridPosition, calculateContiguity as _calculateContiguity, calculatePhotoContiguity as _calculatePhotoContiguity, } from './hexgrid-math';
 const WORKER_ID = Math.random().toString(36).substring(7);
-console.log('[hexgrid-worker] loaded id=', WORKER_ID);
+/** Guarded log – only emits when workerDebug.debugLogs is true. */
+function debugLog(...args) {
+    if (workerDebug.debugLogs)
+        console.log(...args);
+}
 const workerDebug = {
     cohesionBoost: 6.0, // BOOSTED: strongly favor growth near cluster centroids to build larger regions
     enableMerges: true, // ENABLED: merge small fragments into nearby larger clusters
@@ -149,10 +153,28 @@ function getNeighborsCached(index, positions, hexRadius) {
 function calculateUvBoundsFromGridPosition(gridCol, gridRow, tilesX, tilesY) {
     return _calculateUvBoundsFromGridPosition(gridCol, gridRow, tilesX, tilesY);
 }
+function buildBlankNeighborCounts(infections, positions, hexRadius) {
+    if (!infections || infections.size === 0)
+        return [];
+    const infectedSet = new Set(infections.keys());
+    const out = [];
+    for (const idx of infectedSet) {
+        if (idx < 0 || idx >= positions.length)
+            continue;
+        const neighbors = getNeighborsCached(idx, positions, hexRadius);
+        let blankCount = 0;
+        for (const n of neighbors) {
+            if (!infectedSet.has(n))
+                blankCount++;
+        }
+        out.push([idx, blankCount]);
+    }
+    return out;
+}
 function findConnectedComponents(indices, positions, hexRadius) {
     // Immediate synchronous check - if this doesn't log, the function isn't being called or is blocked
     const startMarker = performance.now();
-    console.log('[findConnectedComponents] FUNCTION ENTERED - indices.length=', indices.length, 'positions.length=', positions.length, 'hexRadius=', hexRadius, 'marker=', startMarker);
+    debugLog('[findConnectedComponents] FUNCTION ENTERED - indices.length=', indices.length, 'positions.length=', positions.length, 'hexRadius=', hexRadius, 'marker=', startMarker);
     // Validate inputs immediately
     if (!indices || !Array.isArray(indices)) {
         console.error('[findConnectedComponents] Invalid indices:', indices);
@@ -166,13 +188,13 @@ function findConnectedComponents(indices, positions, hexRadius) {
         console.error('[findConnectedComponents] Invalid hexRadius:', hexRadius);
         return [];
     }
-    console.log('[findConnectedComponents] About to enter try block');
+    debugLog('[findConnectedComponents] About to enter try block');
     // Add immediate log after try block entry to confirm execution reaches here
     let tryBlockEntered = false;
     try {
         tryBlockEntered = true;
-        console.log('[findConnectedComponents] ✅ TRY BLOCK ENTERED - marker=', performance.now() - startMarker, 'ms');
-        console.log('[findConnectedComponents] Inside try block - Starting with', indices.length, 'indices');
+        debugLog('[findConnectedComponents] ✅ TRY BLOCK ENTERED - marker=', performance.now() - startMarker, 'ms');
+        debugLog('[findConnectedComponents] Inside try block - Starting with', indices.length, 'indices');
         const set = new Set(indices);
         const visited = new Set();
         const comps = [];
@@ -181,7 +203,7 @@ function findConnectedComponents(indices, positions, hexRadius) {
             if (visited.has(start))
                 continue;
             componentCount++;
-            console.log('[findConnectedComponents] Starting component', componentCount, 'from index', start);
+            debugLog('[findConnectedComponents] Starting component', componentCount, 'from index', start);
             const q = [start];
             visited.add(start);
             const comp = [];
@@ -194,7 +216,7 @@ function findConnectedComponents(indices, positions, hexRadius) {
                     break;
                 }
                 if (iterations % 100 === 0) {
-                    console.log('[findConnectedComponents] Component', componentCount, 'iteration', iterations, 'queue length', q.length);
+                    debugLog('[findConnectedComponents] Component', componentCount, 'iteration', iterations, 'queue length', q.length);
                 }
                 const cur = q.shift();
                 if (cur === undefined || cur === null) {
@@ -224,12 +246,12 @@ function findConnectedComponents(indices, positions, hexRadius) {
                     continue;
                 }
             }
-            console.log('[findConnectedComponents] Component', componentCount, 'complete:', comp.length, 'nodes,', iterations, 'iterations');
+            debugLog('[findConnectedComponents] Component', componentCount, 'complete:', comp.length, 'nodes,', iterations, 'iterations');
             comps.push(comp);
         }
-        console.log('[findConnectedComponents] Complete:', comps.length, 'components found');
+        debugLog('[findConnectedComponents] Complete:', comps.length, 'components found');
         const elapsed = performance.now() - startMarker;
-        console.log('[findConnectedComponents] ✅ RETURNING - elapsed=', elapsed, 'ms, components=', comps.length);
+        debugLog('[findConnectedComponents] ✅ RETURNING - elapsed=', elapsed, 'ms, components=', comps.length);
         return comps;
     }
     catch (e) {
@@ -250,7 +272,7 @@ function findConnectedComponents(indices, positions, hexRadius) {
 }
 function calculatePhotoCentroids(infections, positions, hexRadius) {
     try {
-        console.log('[calculatePhotoCentroids] Starting with', infections.size, 'infections');
+        debugLog('[calculatePhotoCentroids] Starting with', infections.size, 'infections');
         const byPhoto = new Map();
         for (const [idx, inf] of infections) {
             if (!inf || !inf.photo)
@@ -259,14 +281,14 @@ function calculatePhotoCentroids(infections, positions, hexRadius) {
             arr.push(idx);
             byPhoto.set(inf.photo.id, arr);
         }
-        console.log('[calculatePhotoCentroids] Grouped into', byPhoto.size, 'photos');
+        debugLog('[calculatePhotoCentroids] Grouped into', byPhoto.size, 'photos');
         const centroids = new Map();
         let photoNum = 0;
         for (const [photoId, inds] of byPhoto) {
             photoNum++;
-            console.log('[calculatePhotoCentroids] Processing photo', photoNum, '/', byPhoto.size, 'photoId=', photoId, 'indices=', inds.length);
+            debugLog('[calculatePhotoCentroids] Processing photo', photoNum, '/', byPhoto.size, 'photoId=', photoId, 'indices=', inds.length);
             try {
-                console.log('[calculatePhotoCentroids] About to call findConnectedComponents with', inds.length, 'indices');
+                debugLog('[calculatePhotoCentroids] About to call findConnectedComponents with', inds.length, 'indices');
                 const callStartTime = performance.now();
                 let comps;
                 try {
@@ -282,7 +304,7 @@ function calculatePhotoCentroids(infections, positions, hexRadius) {
                     else {
                         comps = findConnectedComponents(inds, positions, hexRadius);
                         const callElapsed = performance.now() - callStartTime;
-                        console.log('[calculatePhotoCentroids] findConnectedComponents RETURNED with', comps.length, 'components after', callElapsed, 'ms');
+                        debugLog('[calculatePhotoCentroids] findConnectedComponents RETURNED with', comps.length, 'components after', callElapsed, 'ms');
                     }
                 }
                 catch (e) {
@@ -291,8 +313,8 @@ function calculatePhotoCentroids(infections, positions, hexRadius) {
                     // Return empty components on error to allow evolution to continue
                     comps = [];
                 }
-                console.log('[calculatePhotoCentroids] findConnectedComponents returned', comps.length, 'components');
-                console.log('[calculatePhotoCentroids]   Found', comps.length, 'components for photo', photoId);
+                debugLog('[calculatePhotoCentroids] findConnectedComponents returned', comps.length, 'components');
+                debugLog('[calculatePhotoCentroids]   Found', comps.length, 'components for photo', photoId);
                 const cs = [];
                 for (const comp of comps) {
                     let sx = 0, sy = 0;
@@ -313,7 +335,7 @@ function calculatePhotoCentroids(infections, positions, hexRadius) {
                 centroids.set(photoId, []);
             }
         }
-        console.log('[calculatePhotoCentroids] Completed, returning', centroids.size, 'photo centroids');
+        debugLog('[calculatePhotoCentroids] Completed, returning', centroids.size, 'photo centroids');
         return centroids;
     }
     catch (e) {
@@ -330,7 +352,7 @@ function calculateContiguity(indices, positions, hexRadius) {
 function assignClusterGridPositions(infections, positions, hexRadius) {
     const debugCenters = [];
     try {
-        console.log('[assignClusterGridPositions] Starting with', infections.size, 'infections');
+        debugLog('[assignClusterGridPositions] Starting with', infections.size, 'infections');
         // Group infections by photo
         const byPhoto = new Map();
         for (const [idx, inf] of infections) {
@@ -340,7 +362,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
             arr.push(idx);
             byPhoto.set(inf.photo.id, arr);
         }
-        console.log('[assignClusterGridPositions] Processing', byPhoto.size, 'unique photos');
+        debugLog('[assignClusterGridPositions] Processing', byPhoto.size, 'unique photos');
         // Cluster size analytics
         let totalClusters = 0;
         let clusterSizes = [];
@@ -353,7 +375,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                 if (comp && comp.length > 0)
                     clusterSizes.push(comp.length);
             }
-            console.log('[assignClusterGridPositions] Photo', photoId.substring(0, 8), 'has', components.length, 'clusters, sizes:', components.map((c) => c.length).join(','));
+            debugLog('[assignClusterGridPositions] Photo', photoId.substring(0, 8), 'has', components.length, 'clusters, sizes:', components.map((c) => c.length).join(','));
             // Process each cluster separately
             let clusterIndex = 0;
             for (const cluster of components) {
@@ -432,7 +454,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                                     tilesY++;
                             }
                         }
-                        console.log('[assignClusterGridPositions][hex-lattice] cluster', photoId.substring(0, 8), 'size', cluster.length, 'latticeCols', latticeCols, 'latticeRows', latticeRows, 'tilesX', tilesX, 'tilesY', tilesY);
+                        debugLog('[assignClusterGridPositions][hex-lattice] cluster', photoId.substring(0, 8), 'size', cluster.length, 'latticeCols', latticeCols, 'latticeRows', latticeRows, 'tilesX', tilesX, 'tilesY', tilesY);
                         // Build optional serpentine ordering for assignment uniqueness (not strictly needed since lattice mapping is direct)
                         const serpentine = workerDebug.clusterScanMode === 'serpentine';
                         // Assign each infection a gridPosition derived from lattice coordinates compressed into tile grid domain.
@@ -586,7 +608,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                 }
                 const clusterWidth = Math.max(0, maxX - minX);
                 const clusterHeight = Math.max(0, maxY - minY);
-                console.log('[assignClusterGridPositions] Cluster bounds:', {
+                debugLog('[assignClusterGridPositions] Cluster bounds:', {
                     photoId: photoId.substring(0, 8),
                     clusterIndex,
                     hexCount: cluster.length,
@@ -601,7 +623,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                 // This ensures the tile grid matches the spatial layout of the cluster
                 const clusterAspect = clusterHeight > 0 ? clusterWidth / clusterHeight : 1.0;
                 const targetTileCount = 16; // Target ~16 tiles total for good image distribution
-                console.log('[assignClusterGridPositions] Cluster aspect:', clusterAspect.toFixed(3), '(width/height)');
+                debugLog('[assignClusterGridPositions] Cluster aspect:', clusterAspect.toFixed(3), '(width/height)');
                 let tilesX;
                 let tilesY;
                 if (cluster.length === 1) {
@@ -659,13 +681,13 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                         newTilesY = Math.max(1, Math.min(16, newTilesY));
                         tilesX = newTilesX;
                         tilesY = newTilesY;
-                        console.log('[assignClusterGridPositions] Expanded tile grid to', tilesX, 'x', tilesY, '=', tilesX * tilesY, 'tiles');
+                        debugLog('[assignClusterGridPositions] Expanded tile grid to', tilesX, 'x', tilesY, '=', tilesX * tilesY, 'tiles');
                     }
                 }
                 catch (e) {
                     // if anything goes wrong, keep original tilesX/tilesY
                 }
-                console.log('[assignClusterGridPositions] Final tile dimensions:', tilesX, 'x', tilesY, '=', tilesX * tilesY, 'tiles for', cluster.length, 'hexes');
+                debugLog('[assignClusterGridPositions] Final tile dimensions:', tilesX, 'x', tilesY, '=', tilesX * tilesY, 'tiles for', cluster.length, 'hexes');
                 // Single-hex or degenerate clusters: assign a deterministic tile so single hexes don't all use [0,0]
                 if (cluster.length === 1 ||
                     clusterWidth < 1e-6 ||
@@ -859,7 +881,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                         const y = normMinY + v * normHeight;
                         return [x, y];
                     };
-                    console.log('[assignClusterGridPositions] Normalized bounds for tiling:', {
+                    debugLog('[assignClusterGridPositions] Normalized bounds for tiling:', {
                         normMinX: normMinX.toFixed(2),
                         normMinY: normMinY.toFixed(2),
                         normWidth: normWidth.toFixed(2),
@@ -923,8 +945,8 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                             });
                         }
                     }
-                    console.log('[assignClusterGridPositions] Spatially assigned', cluster.length, 'hexes to nearest tile centers');
-                    console.log('[assignClusterGridPositions] Sample assignments:', assignmentSamples
+                    debugLog('[assignClusterGridPositions] Spatially assigned', cluster.length, 'hexes to nearest tile centers');
+                    debugLog('[assignClusterGridPositions] Sample assignments:', assignmentSamples
                         .map((s) => `node#${s.nodeId} at (${s.nodeX.toFixed(1)},${s.nodeY.toFixed(1)}) → tile[${s.tileCol},${s.tileRow}] center(${s.centerX.toFixed(1)},${s.centerY.toFixed(1)}) dist=${s.dist.toFixed(1)}`)
                         .join('\n  '));
                     // Optional: Neighborhood-aware refinement to reduce visual seams
@@ -996,7 +1018,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                             }
                             if (adjustments === 0)
                                 break; // Converged
-                            console.log('[assignClusterGridPositions] Neighbor-aware refinement iteration', iter + 1, ':', adjustments, 'adjustments');
+                            debugLog('[assignClusterGridPositions] Neighbor-aware refinement iteration', iter + 1, ':', adjustments, 'adjustments');
                         }
                     }
                     // Finally write assignments back into infections with UV bounds/inset
@@ -1028,7 +1050,7 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
                             tilesY,
                         });
                     }
-                    console.log('[assignClusterGridPositions] Assigned grid positions to', cluster.length, 'hexes in cluster (BFS)');
+                    debugLog('[assignClusterGridPositions] Assigned grid positions to', cluster.length, 'hexes in cluster (BFS)');
                 }
                 catch (e) {
                     console.error('[assignClusterGridPositions] BFS assignment failed, falling back to quantization', e);
@@ -1044,9 +1066,9 @@ function assignClusterGridPositions(infections, positions, hexRadius) {
             const medianSize = clusterSizes[Math.floor(clusterSizes.length / 2)];
             const maxSize = clusterSizes[0];
             const smallClusters = clusterSizes.filter((s) => s <= 3).length;
-            console.log('[assignClusterGridPositions] CLUSTER STATS: total=', totalClusters, 'avg=', avgSize.toFixed(1), 'median=', medianSize, 'max=', maxSize, 'small(≤3)=', smallClusters, '/', totalClusters, '(', ((100 * smallClusters) / totalClusters).toFixed(0), '%)');
+            debugLog('[assignClusterGridPositions] CLUSTER STATS: total=', totalClusters, 'avg=', avgSize.toFixed(1), 'median=', medianSize, 'max=', maxSize, 'small(≤3)=', smallClusters, '/', totalClusters, '(', ((100 * smallClusters) / totalClusters).toFixed(0), '%)');
         }
-        console.log('[assignClusterGridPositions] Complete');
+        debugLog('[assignClusterGridPositions] Complete');
     }
     catch (e) {
         console.error('[assignClusterGridPositions] Error:', e);
@@ -1057,7 +1079,7 @@ function postOptimizationMerge(infections, positions, hexRadius, debug = false)
     try {
         if (!workerDebug || !workerDebug.enableMerges) {
             if (debug && workerDebug.mergeLogs)
-                console.log('[merge] disabled');
+                debugLog('[merge] disabled');
             return;
         }
         const threshold = typeof workerDebug.mergeSmallComponentsThreshold === 'number'
@@ -1132,7 +1154,7 @@ function postOptimizationMerge(infections, positions, hexRadius, debug = false)
                     }
                     merges++;
                     if (debug && workerDebug.mergeLogs)
-                        console.log(`[merge] moved ${s.length} -> ${recipientId}`);
+                        debugLog(`[merge] moved ${s.length} -> ${recipientId}`);
                 }
             }
         }
@@ -1187,36 +1209,36 @@ function normalizePrevState(prevState) {
 }
 function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentTime, debug = false) {
     try {
-        console.log('[evolve] Step 1: Validating positions...');
+        debugLog('[evolve] Step 1: Validating positions...');
         if (!positions || positions.length === 0) {
             safePostError(new Error('positions required for evolve'));
             return null;
         }
-        console.log('[evolve] Step 2: Normalizing state...');
+        debugLog('[evolve] Step 2: Normalizing state...');
         const normalized = normalizePrevState(prevState);
         const infectionsMap = normalized.infections;
         const availableSet = new Set(Array.isArray(normalized.availableIndices)
             ? normalized.availableIndices
             : []);
-        console.log('[evolve] Step 3: Cleaning infections...');
+        debugLog('[evolve] Step 3: Cleaning infections...');
         for (const [idx, inf] of infectionsMap) {
             if (!inf || !inf.photo) {
                 infectionsMap.delete(idx);
                 availableSet.add(idx);
             }
         }
-        console.log('[evolve] Step 4: Calculating centroids...');
+        debugLog('[evolve] Step 4: Calculating centroids...');
         const centroids = calculatePhotoCentroids(infectionsMap, positions, hexRadius);
-        console.log('[evolve] Step 5: Creating new state copies...');
+        debugLog('[evolve] Step 5: Creating new state copies...');
         const newInfections = new Map(infectionsMap);
         const newAvailable = new Set(availableSet);
         const generation = prevState && typeof prevState.generation === 'number'
             ? prevState.generation + 1
             : 0;
-        console.log('[evolve] Step 6: Growth step - processing', infectionsMap.size, 'infections...');
+        debugLog('[evolve] Step 6: Growth step - processing', infectionsMap.size, 'infections...');
         // Skip growth step if we have no infections or no photos
         if (infectionsMap.size === 0 || photos.length === 0) {
-            console.log('[evolve]   Skipping growth - no infections or no photos');
+            debugLog('[evolve]   Skipping growth - no infections or no photos');
         }
         else {
             // Cell death step: allow fully surrounded cells to die and respawn for optimization
@@ -1351,7 +1373,7 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
                     }
                 }
                 if (deathCount > 0 || mutationCount > 0 || invaderExpulsions > 0) {
-                    console.log('[evolve]   Cell death: removed', deathCount, 'cells (', invaderExpulsions, 'invaders expelled), mutated', mutationCount, 'cells');
+                    debugLog('[evolve]   Cell death: removed', deathCount, 'cells (', invaderExpulsions, 'invaders expelled), mutated', mutationCount, 'cells');
                 }
             }
             // Growth step: prefer neighbors that increase contiguity and are closer to centroids
@@ -1359,7 +1381,7 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
             for (const [idx, inf] of infectionsMap) {
                 growthIterations++;
                 if (growthIterations % 10 === 0)
-                    console.log('[evolve]   Growth iteration', growthIterations, '/', infectionsMap.size);
+                    debugLog('[evolve]   Growth iteration', growthIterations, '/', infectionsMap.size);
                 const neighbors = getNeighborsCached(idx, positions, hexRadius);
                 for (const n of neighbors) {
                     if (!newAvailable.has(n))
@@ -1440,7 +1462,7 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
                 }
             }
         }
-        console.log('[evolve] Step 6.5: Entropy decay - applying decay to dominant successful photos...');
+        debugLog('[evolve] Step 6.5: Entropy decay - applying decay to dominant successful photos...');
         // Entropy decay: successful/dominant photos decay over time to allow new dominance to emerge
         if (workerDebug.enableEntropyDecay && newInfections.size > 0) {
             // Calculate current territory shares
@@ -1524,14 +1546,14 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
                     entropyDecayCount++;
                 }
                 if (entropyDecayCount > 0) {
-                    console.log('[evolve]   Entropy decay: removed', entropyDecayCount, 'cells from dominant successful photos');
+                    debugLog('[evolve]   Entropy decay: removed', entropyDecayCount, 'cells from dominant successful photos');
                 }
             }
         }
-        console.log('[evolve] Step 7: Deterministic fill - processing', newAvailable.size, 'available positions...');
+        debugLog('[evolve] Step 7: Deterministic fill - processing', newAvailable.size, 'available positions...');
         // Skip deterministic fill if we have no photos or no existing infections to base decisions on
         if (photos.length === 0 || newInfections.size === 0) {
-            console.log('[evolve]   Skipping deterministic fill - no photos or no infections');
+            debugLog('[evolve]   Skipping deterministic fill - no photos or no infections');
         }
         else {
             // Deterministic fill for holes with >=2 same-photo neighbors
@@ -1539,7 +1561,7 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
             for (const a of Array.from(newAvailable)) {
                 fillIterations++;
                 if (fillIterations % 50 === 0)
-                    console.log('[evolve]   Fill iteration', fillIterations, '/', newAvailable.size);
+                    debugLog('[evolve]   Fill iteration', fillIterations, '/', newAvailable.size);
                 const neighbors = getNeighborsCached(a, positions, hexRadius);
                 const counts = new Map();
                 for (const n of neighbors) {
@@ -1578,13 +1600,13 @@ function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentT
                 }
             }
         }
-        console.log('[evolve] Step 8: Optimization merge pass...');
+        debugLog('[evolve] Step 8: Optimization merge pass...');
         // Conservative merge pass (opt-in)
         postOptimizationMerge(newInfections, positions, hexRadius, !!workerDebug.mergeLogs);
-        console.log('[evolve] Step 9: Assigning cluster-aware grid positions...');
+        debugLog('[evolve] Step 9: Assigning cluster-aware grid positions...');
         // Make clusters self-aware by assigning grid positions based on spatial layout
         const tileCenters = assignClusterGridPositions(newInfections, positions, hexRadius);
-        console.log('[evolve] Step 10: Returning result - generation', generation, 'infections', newInfections.size);
+        debugLog('[evolve] Step 10: Returning result - generation', generation, 'infections', newInfections.size);
         return {
             infections: newInfections,
             availableIndices: Array.from(newAvailable),
@@ -1637,7 +1659,7 @@ self.onmessage = function (ev) {
                 if (!positions || !Array.isArray(positions))
                     return;
                 const hexRadius = typeof payload.hexRadius === 'number' ? payload.hexRadius : 24;
-                console.log('[hexgrid-worker] Pre-building neighbor cache for', positions.length, 'positions...');
+                debugLog('[hexgrid-worker] Pre-building neighbor cache for', positions.length, 'positions...');
                 const startTime = Date.now();
                 // Build ALL neighbor relationships in one O(n²) pass instead of n×O(n) passes
                 try {
@@ -1667,11 +1689,11 @@ self.onmessage = function (ev) {
                         }
                         // Log progress every 100 positions
                         if ((i + 1) % 100 === 0) {
-                            console.log('[hexgrid-worker]   Processed', i + 1, '/', positions.length, 'positions');
+                            debugLog('[hexgrid-worker]   Processed', i + 1, '/', positions.length, 'positions');
                         }
                     }
                     const elapsed = Date.now() - startTime;
-                    console.log('[hexgrid-worker] ✅ Neighbor cache built in', elapsed, 'ms - ready for evolution!');
+                    debugLog('[hexgrid-worker] ✅ Neighbor cache built in', elapsed, 'ms - ready for evolution!');
                     // Mark cache as ready
                     cache.cacheReady = true;
                     // Notify main thread that cache is ready
@@ -1694,7 +1716,7 @@ self.onmessage = function (ev) {
         if (type === 'evolve') {
             // Check if neighbor cache is ready before processing evolve
             if (!cache.cacheReady) {
-                console.log('[hexgrid-worker] ⏸️ Evolve message received but cache not ready yet - deferring...');
+                debugLog('[hexgrid-worker] ⏸️ Evolve message received but cache not ready yet - deferring...');
                 // Defer this evolve message by re-posting it after a short delay
                 setTimeout(() => {
                     try {
@@ -1714,7 +1736,7 @@ self.onmessage = function (ev) {
             // Diagnostic: log that an evolve was received and the available payload keys (only when debugLogs enabled)
             try {
                 if (workerDebug && workerDebug.debugLogs) {
-                    console.log('[hexgrid-worker] evolve received, payload keys=', Object.keys(payload || {}), 'workerDebug.evolutionIntervalMs=', workerDebug.evolutionIntervalMs, 'workerDebug.evolveIntervalMs=', workerDebug.evolveIntervalMs);
+                    debugLog('[hexgrid-worker] evolve received, payload keys=', Object.keys(payload || {}), 'workerDebug.evolutionIntervalMs=', workerDebug.evolutionIntervalMs, 'workerDebug.evolveIntervalMs=', workerDebug.evolveIntervalMs);
                 }
             }
             catch (e) { }
@@ -1724,12 +1746,12 @@ self.onmessage = function (ev) {
                 : typeof workerDebug.evolveIntervalMs === 'number'
                     ? workerDebug.evolveIntervalMs
                     : 60000;
-            console.log('[hexgrid-worker] Throttle check: interval=', interval, 'lastEvolutionAt=', lastEvolutionAt, 'now=', now, 'diff=', now - lastEvolutionAt, 'willThrottle=', now - lastEvolutionAt < interval);
+            debugLog('[hexgrid-worker] Throttle check: interval=', interval, 'lastEvolutionAt=', lastEvolutionAt, 'now=', now, 'diff=', now - lastEvolutionAt, 'willThrottle=', now - lastEvolutionAt < interval);
             // Throttle: if we're within the interval, notify (debug) and skip processing
             const reason = payload.reason || (raw && raw.reason);
             const bypassThrottle = reason === 'photos-init' || reason === 'reset';
             // Clear, high-signal log for build verification: reports whether the current evolve will bypass the worker throttle
-            console.log('[hexgrid-worker] THROTTLE DECISION', {
+            debugLog('[hexgrid-worker] THROTTLE DECISION', {
                 interval,
                 lastEvolutionAt,
                 now,
@@ -1740,7 +1762,7 @@ self.onmessage = function (ev) {
             });
             // Throttle: if we're within the interval and not bypassed, notify (debug) and skip processing
             if (!bypassThrottle && now - lastEvolutionAt < interval) {
-                console.log('[hexgrid-worker] ⛔ THROTTLED - skipping evolution processing');
+                debugLog('[hexgrid-worker] ⛔ THROTTLED - skipping evolution processing');
                 if (workerDebug && workerDebug.debugLogs) {
                     try {
                         self.postMessage({
@@ -1759,7 +1781,7 @@ self.onmessage = function (ev) {
             }
             // Mark processed time and send ack for an evolve we will process
             lastEvolutionAt = now;
-            console.log('[hexgrid-worker] ✅ PROCESSING evolution - lastEvolutionAt updated to', now);
+            debugLog('[hexgrid-worker] ✅ PROCESSING evolution - lastEvolutionAt updated to', now);
             try {
                 if (workerDebug && workerDebug.debugLogs) {
                     try {
@@ -1800,12 +1822,12 @@ self.onmessage = function (ev) {
                 Boolean(payload.isSpherical) !== cache.isSpherical) {
                 invalidateCaches(Boolean(payload.isSpherical));
             }
-            console.log('[hexgrid-worker] 🔧 About to call evolveInfectionSystem');
-            console.log('[hexgrid-worker]   - state generation:', state?.generation);
-            console.log('[hexgrid-worker]   - state infections:', state?.infections?.length || state?.infections?.size || 0);
-            console.log('[hexgrid-worker]   - positions:', positions?.length || 0);
-            console.log('[hexgrid-worker]   - photos:', photos?.length || 0);
-            console.log('[hexgrid-worker]   - hexRadius:', hexRadius);
+            debugLog('[hexgrid-worker] 🔧 About to call evolveInfectionSystem');
+            debugLog('[hexgrid-worker]   - state generation:', state?.generation);
+            debugLog('[hexgrid-worker]   - state infections:', state?.infections?.length || state?.infections?.size || 0);
+            debugLog('[hexgrid-worker]   - positions:', positions?.length || 0);
+            debugLog('[hexgrid-worker]   - photos:', photos?.length || 0);
+            debugLog('[hexgrid-worker]   - hexRadius:', hexRadius);
             let res;
             let timeoutId;
             let timedOut = false;
@@ -1822,12 +1844,12 @@ self.onmessage = function (ev) {
                 catch (e) { }
             }, 10000);
             try {
-                console.log('[hexgrid-worker] 🚀 Calling evolveInfectionSystem NOW...');
+                debugLog('[hexgrid-worker] 🚀 Calling evolveInfectionSystem NOW...');
                 const startTime = Date.now();
                 res = evolveInfectionSystem(state, positions, photos, hexRadius, now, !!workerDebug.debugLogs);
                 const elapsed = Date.now() - startTime;
                 clearTimeout(timeoutId);
-                console.log('[hexgrid-worker] ✅ evolveInfectionSystem RETURNED successfully in', elapsed, 'ms');
+                debugLog('[hexgrid-worker] ✅ evolveInfectionSystem RETURNED successfully in', elapsed, 'ms');
             }
             catch (err) {
                 clearTimeout(timeoutId);
@@ -1840,20 +1862,21 @@ self.onmessage = function (ev) {
                 console.error('[hexgrid-worker] ⏱️ Function eventually returned but after timeout was triggered');
             }
             if (!res) {
-                console.log('[hexgrid-worker] ❌ evolveInfectionSystem returned null!');
+                debugLog('[hexgrid-worker] ❌ evolveInfectionSystem returned null!');
                 return;
             }
-            console.log('[hexgrid-worker] ✅ Evolution complete! New generation=', res.generation, 'infections=', res.infections.size);
+            debugLog('[hexgrid-worker] ✅ Evolution complete! New generation=', res.generation, 'infections=', res.infections.size);
             try {
                 const payload = {
                     infections: Array.from(res.infections.entries()),
                     availableIndices: res.availableIndices,
                     lastEvolutionTime: res.lastEvolutionTime,
                     generation: res.generation,
+                    blankNeighborCounts: buildBlankNeighborCounts(res.infections, positions, hexRadius),
                 };
                 if (res.tileCenters && res.tileCenters.length > 0) {
                     payload.tileCenters = res.tileCenters;
-                    console.log('[hexgrid-worker] Including', res.tileCenters.length, 'tile center sets in evolved message');
+                    debugLog('[hexgrid-worker] Including', res.tileCenters.length, 'tile center sets in evolved message');
                 }
                 self.postMessage({ type: 'evolved', data: payload });
                 // Record posted generation/infection count so later auto-triggers can avoid regressing
@@ -1866,7 +1889,7 @@ self.onmessage = function (ev) {
             catch (e) {
                 console.error('[hexgrid-worker] ❌ Failed to post evolved message:', e);
             }
-            console.log('[hexgrid-worker] 📤 Posted evolved message back to main thread');
+            debugLog('[hexgrid-worker] 📤 Posted evolved message back to main thread');
             // Emit a completion marker so the client can confirm the evolve finished end-to-end
             try {
                 if (workerDebug && workerDebug.debugLogs) {
@@ -2011,4 +2034,4 @@ function invalidateCaches(isSpherical) {
     if (typeof isSpherical === 'boolean')
         cache.isSpherical = isSpherical;
 }
-console.log('[hexgrid-worker] ready');
+debugLog('[hexgrid-worker] ready');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buley/hexgrid-3d",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "description": "3D hexagonal grid visualization component for React",
   "type": "module",
   "main": "./dist/index.js",