@buley/hexgrid-3d 1.0.0 → 1.1.1

package/public/hexgrid-worker.js

@@ -1,21 +1,21 @@
-"use strict";
+'use strict';
 /// <reference lib="webworker" />
 const WORKER_ID = Math.random().toString(36).substring(7);
 console.log('[hexgrid-worker] loaded id=', WORKER_ID);
 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
-    mergeSmallComponentsThreshold: 20, // INCREASED: merge clusters of 20 hexes or fewer
-    mergeLogs: false,
-    evolutionIntervalMs: 30000,
-    debugLogs: false,
-    enableCellDeath: true, // ENABLED: allow fully surrounded cells to die and respawn with better positioning
-    cellDeathProbability: 0.05, // 5% chance per evolution for fully surrounded cells to reset
-    enableMutation: true, // ENABLED: allow dying cells to mutate into different photos
-    mutationProbability: 0.3, // 30% chance for a dying cell to respawn as a different photo
-    enableVirilityBoost: true, // ENABLED: boost infection rate based on photo velocity/upvotes
-    virilityMultiplier: 1.0, // Multiplier for virility effect (1.0 = normal, higher = more impact)
-    annealingRate: 2.0 // Multiplier for death/churn rates to help system escape local optima (1.0 = normal, higher = more reorganization)
+  cohesionBoost: 6.0, // BOOSTED: strongly favor growth near cluster centroids to build larger regions
+  enableMerges: true, // ENABLED: merge small fragments into nearby larger clusters
+  mergeSmallComponentsThreshold: 20, // INCREASED: merge clusters of 20 hexes or fewer
+  mergeLogs: false,
+  evolutionIntervalMs: 30000,
+  debugLogs: false,
+  enableCellDeath: true, // ENABLED: allow fully surrounded cells to die and respawn with better positioning
+  cellDeathProbability: 0.05, // 5% chance per evolution for fully surrounded cells to reset
+  enableMutation: true, // ENABLED: allow dying cells to mutate into different photos
+  mutationProbability: 0.3, // 30% chance for a dying cell to respawn as a different photo
+  enableVirilityBoost: true, // ENABLED: boost infection rate based on photo velocity/upvotes
+  virilityMultiplier: 1.0, // Multiplier for virility effect (1.0 = normal, higher = more impact)
+  annealingRate: 2.0, // Multiplier for death/churn rates to help system escape local optima (1.0 = normal, higher = more reorganization)
 };
 // Tuning flags for cluster tiling behaviour
 workerDebug.clusterPreserveAspect = true; // when true, preserve cluster aspect ratio when mapping to tile grid
@@ -43,1721 +43,2433 @@ workerDebug.clusterHexLattice = true;
 workerDebug.clusterParityUvShift = true;
 // when true, compact gaps in each row of the hex lattice for more contiguous image tiles
 workerDebug.clusterCompactGaps = true;
-const cache = { neighborMap: new Map(), gridBounds: null, photoClusters: new Map(), connectedComponents: new Map(), gridPositions: new Map(), lastInfectionCount: 0, lastGeneration: -1, isSpherical: false, cacheReady: false };
-function safePostError(err) { try {
-    self.postMessage({ type: 'error', error: err instanceof Error ? err.message : String(err) });
+const cache = {
+  neighborMap: new Map(),
+  gridBounds: null,
+  photoClusters: new Map(),
+  connectedComponents: new Map(),
+  gridPositions: new Map(),
+  lastInfectionCount: 0,
+  lastGeneration: -1,
+  isSpherical: false,
+  cacheReady: false,
+};
+function safePostError(err) {
+  try {
+    self.postMessage({
+      type: 'error',
+      error: err instanceof Error ? err.message : String(err),
+    });
+  } catch (e) {}
 }
-catch (e) { } }
 function getGridBounds(positions) {
-    if (cache.gridBounds)
-        return cache.gridBounds;
-    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const p of positions) {
-        if (!p)
-            continue;
-        minX = Math.min(minX, p[0]);
-        maxX = Math.max(maxX, p[0]);
-        minY = Math.min(minY, p[1]);
-        maxY = Math.max(maxY, p[1]);
-    }
-    cache.gridBounds = { minX, maxX, minY, maxY, width: maxX - minX, height: maxY - minY };
-    return cache.gridBounds;
+  if (cache.gridBounds) return cache.gridBounds;
+  let minX = Infinity,
+    maxX = -Infinity,
+    minY = Infinity,
+    maxY = -Infinity;
+  for (const p of positions) {
+    if (!p) continue;
+    minX = Math.min(minX, p[0]);
+    maxX = Math.max(maxX, p[0]);
+    minY = Math.min(minY, p[1]);
+    maxY = Math.max(maxY, p[1]);
+  }
+  cache.gridBounds = {
+    minX,
+    maxX,
+    minY,
+    maxY,
+    width: maxX - minX,
+    height: maxY - minY,
+  };
+  return cache.gridBounds;
 }
 function distanceBetween(a, b, bounds, isSpherical) {
-    let dx = b[0] - a[0];
-    let dy = b[1] - a[1];
-    if (isSpherical && bounds.width > 0 && bounds.height > 0) {
-        if (Math.abs(dx) > bounds.width / 2) {
-            dx = dx > 0 ? dx - bounds.width : dx + bounds.width;
-        }
-        if (Math.abs(dy) > bounds.height / 2) {
-            dy = dy > 0 ? dy - bounds.height : dy + bounds.height;
-        }
+  let dx = b[0] - a[0];
+  let dy = b[1] - a[1];
+  if (isSpherical && bounds.width > 0 && bounds.height > 0) {
+    if (Math.abs(dx) > bounds.width / 2) {
+      dx = dx > 0 ? dx - bounds.width : dx + bounds.width;
+    }
+    if (Math.abs(dy) > bounds.height / 2) {
+      dy = dy > 0 ? dy - bounds.height : dy + bounds.height;
     }
-    return Math.sqrt(dx * dx + dy * dy);
+  }
+  return Math.sqrt(dx * dx + dy * dy);
 }
 function getNeighborsCached(index, positions, hexRadius) {
-    // Immediate return if cached - no blocking
-    if (cache.neighborMap.has(index)) {
-        const cached = cache.neighborMap.get(index);
-        if (Array.isArray(cached))
-            return cached;
-        // Invalid cache entry - clear it and recompute
-        cache.neighborMap.delete(index);
-    }
-    // Validate inputs before computation
-    if (!positions || !Array.isArray(positions) || positions.length === 0) {
-        console.warn('[getNeighborsCached] Invalid positions array, returning empty');
-        return [];
-    }
-    if (typeof index !== 'number' || index < 0 || index >= positions.length) {
-        console.warn('[getNeighborsCached] Invalid index', index, 'for positions length', positions.length);
-        return [];
-    }
-    if (typeof hexRadius !== 'number' || hexRadius <= 0) {
-        console.warn('[getNeighborsCached] Invalid hexRadius', hexRadius);
-        return [];
-    }
-    const out = [];
-    const pos = positions[index];
-    if (!pos) {
-        console.warn('[getNeighborsCached] No position at index', index);
-        return out;
-    }
-    try {
-        const bounds = getGridBounds(positions);
-        const threshold = Math.sqrt(3) * hexRadius * 1.15;
-        const isSpherical = !!cache.isSpherical;
-        // Fast path: check only nearby candidates (≈6 neighbors for hex grid)
-        // For hex grids, each hex has at most 6 neighbors
-        // Limit search to reduce O(n²) to O(n)
-        const maxNeighbors = 10; // Safety margin for irregular grids
-        for (let j = 0; j < positions.length; j++) {
-            if (j === index)
-                continue;
-            const p2 = positions[j];
-            if (!p2)
-                continue;
-            const d = distanceBetween(pos, p2, bounds, isSpherical);
-            if (d <= threshold) {
-                out.push(j);
-                // Early exit if we found enough neighbors
-                if (out.length >= maxNeighbors)
-                    break;
-            }
-        }
-        cache.neighborMap.set(index, out);
-    }
-    catch (e) {
-        console.error('[getNeighborsCached] Error computing neighbors:', e);
-        return [];
-    }
+  // Immediate return if cached - no blocking
+  if (cache.neighborMap.has(index)) {
+    const cached = cache.neighborMap.get(index);
+    if (Array.isArray(cached)) return cached;
+    // Invalid cache entry - clear it and recompute
+    cache.neighborMap.delete(index);
+  }
+  // Validate inputs before computation
+  if (!positions || !Array.isArray(positions) || positions.length === 0) {
+    console.warn(
+      '[getNeighborsCached] Invalid positions array, returning empty'
+    );
+    return [];
+  }
+  if (typeof index !== 'number' || index < 0 || index >= positions.length) {
+    console.warn(
+      '[getNeighborsCached] Invalid index',
+      index,
+      'for positions length',
+      positions.length
+    );
+    return [];
+  }
+  if (typeof hexRadius !== 'number' || hexRadius <= 0) {
+    console.warn('[getNeighborsCached] Invalid hexRadius', hexRadius);
+    return [];
+  }
+  const out = [];
+  const pos = positions[index];
+  if (!pos) {
+    console.warn('[getNeighborsCached] No position at index', index);
     return out;
+  }
+  try {
+    const bounds = getGridBounds(positions);
+    const threshold = Math.sqrt(3) * hexRadius * 1.15;
+    const isSpherical = !!cache.isSpherical;
+    // Fast path: check only nearby candidates (≈6 neighbors for hex grid)
+    // For hex grids, each hex has at most 6 neighbors
+    // Limit search to reduce O(n²) to O(n)
+    const maxNeighbors = 10; // Safety margin for irregular grids
+    for (let j = 0; j < positions.length; j++) {
+      if (j === index) continue;
+      const p2 = positions[j];
+      if (!p2) continue;
+      const d = distanceBetween(pos, p2, bounds, isSpherical);
+      if (d <= threshold) {
+        out.push(j);
+        // Early exit if we found enough neighbors
+        if (out.length >= maxNeighbors) break;
+      }
+    }
+    cache.neighborMap.set(index, out);
+  } catch (e) {
+    console.error('[getNeighborsCached] Error computing neighbors:', e);
+    return [];
+  }
+  return out;
 }
 // Calculate UV bounds for a tile based on its grid position within a tilesX x tilesY grid
 // V=1.0 represents the top of the texture in this codebase
 function calculateUvBoundsFromGridPosition(gridCol, gridRow, tilesX, tilesY) {
-    const minU = gridCol / tilesX;
-    const maxU = (gridCol + 1) / tilesX;
-    // V=1 is top, so row 0 maps to top (maxV=1, minV=1-1/tilesY)
-    const minV = 1 - (gridRow + 1) / tilesY;
-    const maxV = 1 - gridRow / tilesY;
-    return [minU, minV, maxU, maxV];
+  const minU = gridCol / tilesX;
+  const maxU = (gridCol + 1) / tilesX;
+  // V=1 is top, so row 0 maps to top (maxV=1, minV=1-1/tilesY)
+  const minV = 1 - (gridRow + 1) / tilesY;
+  const maxV = 1 - gridRow / tilesY;
+  return [minU, minV, maxU, maxV];
 }
 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);
-    // Validate inputs immediately
-    if (!indices || !Array.isArray(indices)) {
-        console.error('[findConnectedComponents] Invalid indices:', indices);
-        return [];
-    }
-    if (!positions || !Array.isArray(positions)) {
-        console.error('[findConnectedComponents] Invalid positions:', positions);
-        return [];
-    }
-    if (typeof hexRadius !== 'number' || hexRadius <= 0) {
-        console.error('[findConnectedComponents] Invalid hexRadius:', hexRadius);
-        return [];
-    }
-    console.log('[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');
-        const set = new Set(indices);
-        const visited = new Set();
-        const comps = [];
-        let componentCount = 0;
-        for (const start of indices) {
-            if (visited.has(start))
-                continue;
-            componentCount++;
-            console.log('[findConnectedComponents] Starting component', componentCount, 'from index', start);
-            const q = [start];
-            visited.add(start);
-            const comp = [];
-            let iterations = 0;
-            const maxIterations = indices.length * 10; // Safety limit
-            while (q.length > 0) {
-                iterations++;
-                if (iterations > maxIterations) {
-                    console.error('[findConnectedComponents] Safety limit reached! indices=', indices.length, 'component=', componentCount, 'iterations=', iterations);
-                    break;
-                }
-                if (iterations % 100 === 0) {
-                    console.log('[findConnectedComponents] Component', componentCount, 'iteration', iterations, 'queue length', q.length);
-                }
-                const cur = q.shift();
-                if (cur === undefined || cur === null) {
-                    console.error('[findConnectedComponents] Invalid cur value:', cur);
-                    break;
-                }
-                comp.push(cur);
-                try {
-                    const neighbors = getNeighborsCached(cur, positions, hexRadius);
-                    if (!Array.isArray(neighbors)) {
-                        console.error('[findConnectedComponents] getNeighborsCached returned non-array:', typeof neighbors, neighbors);
-                        continue;
-                    }
-                    for (const n of neighbors) {
-                        if (typeof n !== 'number' || isNaN(n)) {
-                            console.error('[findConnectedComponents] Invalid neighbor index:', n, 'type:', typeof n);
-                            continue;
-                        }
-                        if (!visited.has(n) && set.has(n)) {
-                            visited.add(n);
-                            q.push(n);
-                        }
-                    }
-                }
-                catch (e) {
-                    console.error('[findConnectedComponents] Error getting neighbors for index', cur, ':', e);
-                    continue;
-                }
+  // 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
+  );
+  // Validate inputs immediately
+  if (!indices || !Array.isArray(indices)) {
+    console.error('[findConnectedComponents] Invalid indices:', indices);
+    return [];
+  }
+  if (!positions || !Array.isArray(positions)) {
+    console.error('[findConnectedComponents] Invalid positions:', positions);
+    return [];
+  }
+  if (typeof hexRadius !== 'number' || hexRadius <= 0) {
+    console.error('[findConnectedComponents] Invalid hexRadius:', hexRadius);
+    return [];
+  }
+  console.log('[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'
+    );
+    const set = new Set(indices);
+    const visited = new Set();
+    const comps = [];
+    let componentCount = 0;
+    for (const start of indices) {
+      if (visited.has(start)) continue;
+      componentCount++;
+      console.log(
+        '[findConnectedComponents] Starting component',
+        componentCount,
+        'from index',
+        start
+      );
+      const q = [start];
+      visited.add(start);
+      const comp = [];
+      let iterations = 0;
+      const maxIterations = indices.length * 10; // Safety limit
+      while (q.length > 0) {
+        iterations++;
+        if (iterations > maxIterations) {
+          console.error(
+            '[findConnectedComponents] Safety limit reached! indices=',
+            indices.length,
+            'component=',
+            componentCount,
+            'iterations=',
+            iterations
+          );
+          break;
+        }
+        if (iterations % 100 === 0) {
+          console.log(
+            '[findConnectedComponents] Component',
+            componentCount,
+            'iteration',
+            iterations,
+            'queue length',
+            q.length
+          );
+        }
+        const cur = q.shift();
+        if (cur === undefined || cur === null) {
+          console.error('[findConnectedComponents] Invalid cur value:', cur);
+          break;
+        }
+        comp.push(cur);
+        try {
+          const neighbors = getNeighborsCached(cur, positions, hexRadius);
+          if (!Array.isArray(neighbors)) {
+            console.error(
+              '[findConnectedComponents] getNeighborsCached returned non-array:',
+              typeof neighbors,
+              neighbors
+            );
+            continue;
+          }
+          for (const n of neighbors) {
+            if (typeof n !== 'number' || isNaN(n)) {
+              console.error(
+                '[findConnectedComponents] Invalid neighbor index:',
+                n,
+                'type:',
+                typeof n
+              );
+              continue;
             }
-            console.log('[findConnectedComponents] Component', componentCount, 'complete:', comp.length, 'nodes,', iterations, 'iterations');
-            comps.push(comp);
+            if (!visited.has(n) && set.has(n)) {
+              visited.add(n);
+              q.push(n);
+            }
+          }
+        } catch (e) {
+          console.error(
+            '[findConnectedComponents] Error getting neighbors for index',
+            cur,
+            ':',
+            e
+          );
+          continue;
         }
-        console.log('[findConnectedComponents] Complete:', comps.length, 'components found');
-        const elapsed = performance.now() - startMarker;
-        console.log('[findConnectedComponents] ✅ RETURNING - elapsed=', elapsed, 'ms, components=', comps.length);
-        return comps;
+      }
+      console.log(
+        '[findConnectedComponents] Component',
+        componentCount,
+        'complete:',
+        comp.length,
+        'nodes,',
+        iterations,
+        'iterations'
+      );
+      comps.push(comp);
     }
-    catch (e) {
-        const elapsed = performance.now() - startMarker;
-        console.error('[findConnectedComponents] ERROR after', elapsed, 'ms:', e, 'indices.length=', indices.length, 'tryBlockEntered=', tryBlockEntered);
-        // If we never entered the try block, something is seriously wrong
-        if (!tryBlockEntered) {
-            console.error('[findConnectedComponents] CRITICAL: Try block never entered! This suggests a hang before try block.');
-        }
-        throw e;
+    console.log(
+      '[findConnectedComponents] Complete:',
+      comps.length,
+      'components found'
+    );
+    const elapsed = performance.now() - startMarker;
+    console.log(
+      '[findConnectedComponents] ✅ RETURNING - elapsed=',
+      elapsed,
+      'ms, components=',
+      comps.length
+    );
+    return comps;
+  } catch (e) {
+    const elapsed = performance.now() - startMarker;
+    console.error(
+      '[findConnectedComponents] ERROR after',
+      elapsed,
+      'ms:',
+      e,
+      'indices.length=',
+      indices.length,
+      'tryBlockEntered=',
+      tryBlockEntered
+    );
+    // If we never entered the try block, something is seriously wrong
+    if (!tryBlockEntered) {
+      console.error(
+        '[findConnectedComponents] CRITICAL: Try block never entered! This suggests a hang before try block.'
+      );
     }
-    finally {
-        const elapsed = performance.now() - startMarker;
-        if (elapsed > 1000) {
-            console.warn('[findConnectedComponents] ⚠️ Function took', elapsed, 'ms to complete');
-        }
+    throw e;
+  } finally {
+    const elapsed = performance.now() - startMarker;
+    if (elapsed > 1000) {
+      console.warn(
+        '[findConnectedComponents] ⚠️ Function took',
+        elapsed,
+        'ms to complete'
+      );
     }
+  }
 }
 function calculatePhotoCentroids(infections, positions, hexRadius) {
-    try {
-        console.log('[calculatePhotoCentroids] Starting with', infections.size, 'infections');
-        const byPhoto = new Map();
-        for (const [idx, inf] of infections) {
-            if (!inf || !inf.photo)
-                continue;
-            const arr = byPhoto.get(inf.photo.id) || [];
-            arr.push(idx);
-            byPhoto.set(inf.photo.id, arr);
+  try {
+    console.log(
+      '[calculatePhotoCentroids] Starting with',
+      infections.size,
+      'infections'
+    );
+    const byPhoto = new Map();
+    for (const [idx, inf] of infections) {
+      if (!inf || !inf.photo) continue;
+      const arr = byPhoto.get(inf.photo.id) || [];
+      arr.push(idx);
+      byPhoto.set(inf.photo.id, arr);
+    }
+    console.log(
+      '[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
+      );
+      try {
+        console.log(
+          '[calculatePhotoCentroids] About to call findConnectedComponents with',
+          inds.length,
+          'indices'
+        );
+        const callStartTime = performance.now();
+        let comps;
+        try {
+          // Add a pre-call validation to ensure we're not calling with invalid data
+          if (!inds || inds.length === 0) {
+            console.warn(
+              '[calculatePhotoCentroids] Empty indices array, skipping findConnectedComponents'
+            );
+            comps = [];
+          } else if (!positions || positions.length === 0) {
+            console.warn(
+              '[calculatePhotoCentroids] Empty positions array, skipping findConnectedComponents'
+            );
+            comps = [];
+          } else {
+            comps = findConnectedComponents(inds, positions, hexRadius);
+            const callElapsed = performance.now() - callStartTime;
+            console.log(
+              '[calculatePhotoCentroids] findConnectedComponents RETURNED with',
+              comps.length,
+              'components after',
+              callElapsed,
+              'ms'
+            );
+          }
+        } catch (e) {
+          const callElapsed = performance.now() - callStartTime;
+          console.error(
+            '[calculatePhotoCentroids] findConnectedComponents threw error after',
+            callElapsed,
+            'ms:',
+            e
+          );
+          // Return empty components on error to allow evolution to continue
+          comps = [];
         }
-        console.log('[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);
-            try {
-                console.log('[calculatePhotoCentroids] About to call findConnectedComponents with', inds.length, 'indices');
-                const callStartTime = performance.now();
-                let comps;
-                try {
-                    // Add a pre-call validation to ensure we're not calling with invalid data
-                    if (!inds || inds.length === 0) {
-                        console.warn('[calculatePhotoCentroids] Empty indices array, skipping findConnectedComponents');
-                        comps = [];
-                    }
-                    else if (!positions || positions.length === 0) {
-                        console.warn('[calculatePhotoCentroids] Empty positions array, skipping findConnectedComponents');
-                        comps = [];
-                    }
-                    else {
-                        comps = findConnectedComponents(inds, positions, hexRadius);
-                        const callElapsed = performance.now() - callStartTime;
-                        console.log('[calculatePhotoCentroids] findConnectedComponents RETURNED with', comps.length, 'components after', callElapsed, 'ms');
-                    }
-                }
-                catch (e) {
-                    const callElapsed = performance.now() - callStartTime;
-                    console.error('[calculatePhotoCentroids] findConnectedComponents threw error after', callElapsed, 'ms:', e);
-                    // 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);
-                const cs = [];
-                for (const comp of comps) {
-                    let sx = 0, sy = 0;
-                    for (const i of comp) {
-                        const p = positions[i];
-                        if (p) {
-                            sx += p[0];
-                            sy += p[1];
-                        }
-                    }
-                    if (comp.length > 0)
-                        cs.push([sx / comp.length, sy / comp.length]);
-                }
-                centroids.set(photoId, cs);
-            }
-            catch (e) {
-                console.error('[calculatePhotoCentroids] Error processing photo', photoId, ':', e);
-                centroids.set(photoId, []);
+        console.log(
+          '[calculatePhotoCentroids] findConnectedComponents returned',
+          comps.length,
+          'components'
+        );
+        console.log(
+          '[calculatePhotoCentroids]   Found',
+          comps.length,
+          'components for photo',
+          photoId
+        );
+        const cs = [];
+        for (const comp of comps) {
+          let sx = 0,
+            sy = 0;
+          for (const i of comp) {
+            const p = positions[i];
+            if (p) {
+              sx += p[0];
+              sy += p[1];
             }
+          }
+          if (comp.length > 0) cs.push([sx / comp.length, sy / comp.length]);
         }
-        console.log('[calculatePhotoCentroids] Completed, returning', centroids.size, 'photo centroids');
-        return centroids;
-    }
-    catch (e) {
-        console.error('[calculatePhotoCentroids] FATAL ERROR:', e);
-        throw e;
+        centroids.set(photoId, cs);
+      } catch (e) {
+        console.error(
+          '[calculatePhotoCentroids] Error processing photo',
+          photoId,
+          ':',
+          e
+        );
+        centroids.set(photoId, []);
+      }
     }
+    console.log(
+      '[calculatePhotoCentroids] Completed, returning',
+      centroids.size,
+      'photo centroids'
+    );
+    return centroids;
+  } catch (e) {
+    console.error('[calculatePhotoCentroids] FATAL ERROR:', e);
+    throw e;
+  }
 }
 function calculateContiguity(indices, positions, hexRadius) {
-    const set = new Set(indices);
-    let total = 0;
-    for (const idx of indices)
-        for (const n of getNeighborsCached(idx, positions, hexRadius))
-            if (set.has(n))
-                total++;
-    return total;
+  const set = new Set(indices);
+  let total = 0;
+  for (const idx of indices)
+    for (const n of getNeighborsCached(idx, positions, hexRadius))
+      if (set.has(n)) total++;
+  return total;
 }
 // Assign cluster-aware grid positions so each hex in a cluster shows a different part of the image
 // Returns tile centers for debug visualization when workerDebug.showTileCenters is enabled
 function assignClusterGridPositions(infections, positions, hexRadius) {
-    var _a;
-    const debugCenters = [];
-    try {
-        console.log('[assignClusterGridPositions] Starting with', infections.size, 'infections');
-        // Group infections by photo
-        const byPhoto = new Map();
-        for (const [idx, inf] of infections) {
-            if (!inf || !inf.photo)
-                continue;
-            const arr = byPhoto.get(inf.photo.id) || [];
-            arr.push(idx);
-            byPhoto.set(inf.photo.id, arr);
-        }
-        console.log('[assignClusterGridPositions] Processing', byPhoto.size, 'unique photos');
-        // Cluster size analytics
-        let totalClusters = 0;
-        let clusterSizes = [];
-        // Process each photo's clusters
-        for (const [photoId, indices] of byPhoto) {
-            // Find connected components (separate clusters of the same photo)
-            const components = findConnectedComponents(indices, positions, hexRadius);
-            totalClusters += components.length;
-            for (const comp of components) {
-                if (comp && comp.length > 0)
-                    clusterSizes.push(comp.length);
+  var _a;
+  const debugCenters = [];
+  try {
+    console.log(
+      '[assignClusterGridPositions] Starting with',
+      infections.size,
+      'infections'
+    );
+    // Group infections by photo
+    const byPhoto = new Map();
+    for (const [idx, inf] of infections) {
+      if (!inf || !inf.photo) continue;
+      const arr = byPhoto.get(inf.photo.id) || [];
+      arr.push(idx);
+      byPhoto.set(inf.photo.id, arr);
+    }
+    console.log(
+      '[assignClusterGridPositions] Processing',
+      byPhoto.size,
+      'unique photos'
+    );
+    // Cluster size analytics
+    let totalClusters = 0;
+    let clusterSizes = [];
+    // Process each photo's clusters
+    for (const [photoId, indices] of byPhoto) {
+      // Find connected components (separate clusters of the same photo)
+      const components = findConnectedComponents(indices, positions, hexRadius);
+      totalClusters += components.length;
+      for (const comp of components) {
+        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(',')
+      );
+      // Process each cluster separately
+      let clusterIndex = 0;
+      for (const cluster of components) {
+        if (!cluster || cluster.length === 0) continue;
+        // Get the tiling configuration from the first infection in the cluster
+        const firstInf = infections.get(cluster[0]);
+        if (!firstInf) continue;
+        // --- Hex lattice mapping fast-path -------------------------------------------------
+        // If enabled, derive tile coordinates directly from inferred axial-like row/col indices
+        // instead of using normalized bounding boxes + spatial nearest matching. This produces
+        // contiguous, parity-correct tiling where adjacent hexes map to adjacent UV tiles.
+        if (workerDebug.clusterHexLattice) {
+          try {
+            let minX = Infinity,
+              maxX = -Infinity,
+              minY = Infinity,
+              maxY = -Infinity;
+            for (const idx of cluster) {
+              const p = positions[idx];
+              if (!p) continue;
+              if (p[0] < minX) minX = p[0];
+              if (p[0] > maxX) maxX = p[0];
+              if (p[1] < minY) minY = p[1];
+              if (p[1] > maxY) maxY = p[1];
             }
-            console.log('[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) {
-                if (!cluster || cluster.length === 0)
-                    continue;
-                // Get the tiling configuration from the first infection in the cluster
-                const firstInf = infections.get(cluster[0]);
-                if (!firstInf)
-                    continue;
-                // --- Hex lattice mapping fast-path -------------------------------------------------
-                // If enabled, derive tile coordinates directly from inferred axial-like row/col indices
-                // instead of using normalized bounding boxes + spatial nearest matching. This produces
-                // contiguous, parity-correct tiling where adjacent hexes map to adjacent UV tiles.
-                if (workerDebug.clusterHexLattice) {
-                    try {
-                        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-                        for (const idx of cluster) {
-                            const p = positions[idx];
-                            if (!p)
-                                continue;
-                            if (p[0] < minX)
-                                minX = p[0];
-                            if (p[0] > maxX)
-                                maxX = p[0];
-                            if (p[1] < minY)
-                                minY = p[1];
-                            if (p[1] > maxY)
-                                maxY = p[1];
-                        }
-                        const clusterWidth = Math.max(0, maxX - minX);
-                        const clusterHeight = Math.max(0, maxY - minY);
-                        // Infer spacings from hexRadius (flat-top hex layout):
-                        const horizSpacing = Math.sqrt(3) * hexRadius;
-                        const vertSpacing = 1.5 * hexRadius;
-                        // Build lattice coordinates (rowIndex, colIndex) respecting row parity offset.
-                        const latticeCoords = new Map();
-                        let minRow = Infinity, maxRow = -Infinity, minCol = Infinity, maxCol = -Infinity;
-                        for (const id of cluster) {
-                            const p = positions[id];
-                            if (!p)
-                                continue;
-                            const rowF = (p[1] - minY) / vertSpacing;
-                            const row = Math.round(rowF);
-                            // Row parity offset: odd rows in generatePixelScreen are shifted +0.5 * horizSpacing.
-                            const rowOffset = (row % 2 === 1) ? (horizSpacing * 0.5) : 0;
-                            const colF = (p[0] - (minX + rowOffset)) / horizSpacing;
-                            const col = Math.round(colF);
-                            latticeCoords.set(id, { row, col });
-                            if (row < minRow)
-                                minRow = row;
-                            if (row > maxRow)
-                                maxRow = row;
-                            if (col < minCol)
-                                minCol = col;
-                            if (col > maxCol)
-                                maxCol = col;
-                        }
-                        const latticeRows = maxRow - minRow + 1;
-                        const latticeCols = maxCol - minCol + 1;
-                        // Initial tile grid matches lattice extents.
-                        let tilesX = latticeCols;
-                        let tilesY = latticeRows;
-                        // If we have more hexes than lattice cells due to rounding collisions, expand.
-                        const rawTileCount = tilesX * tilesY;
-                        if (cluster.length > rawTileCount) {
-                            // Simple expansion: grow columns while respecting max cap.
-                            const MAX_TILES = typeof workerDebug.clusterMaxTiles === 'number' && workerDebug.clusterMaxTiles > 0 ? Math.floor(workerDebug.clusterMaxTiles) : 128;
-                            while (tilesX * tilesY < cluster.length && tilesX * tilesY < MAX_TILES) {
-                                if (tilesX <= tilesY)
-                                    tilesX++;
-                                else
-                                    tilesY++;
-                            }
-                        }
-                        console.log('[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.
-                        // Enhancement: compact gaps in each row for more contiguous image mapping
-                        const compactGaps = workerDebug.clusterCompactGaps !== false;
-                        // Build row-by-row column mapping to handle gaps
-                        const rowColMap = new Map(); // row -> (oldCol -> newCol)
-                        if (compactGaps) {
-                            for (let row = minRow; row <= maxRow; row++) {
-                                const colsInRow = Array.from(latticeCoords.entries())
-                                    .filter(([_, lc]) => lc.row === row)
-                                    .map(([_, lc]) => lc.col)
-                                    .sort((a, b) => a - b);
-                                const colMap = new Map();
-                                colsInRow.forEach((oldCol, newIdx) => {
-                                    colMap.set(oldCol, newIdx);
-                                });
-                                rowColMap.set(row, colMap);
-                            }
-                        }
-                        // Collision detection: track which tiles are occupied
-                        const tileOccupancy = new Map(); // "col,row" -> nodeId
-                        const tileKey = (c, r) => `${c},${r}`;
-                        for (const id of cluster) {
-                            const inf = infections.get(id);
-                            if (!inf)
-                                continue;
-                            const lc = latticeCoords.get(id);
-                            if (!lc)
-                                continue;
-                            let gridCol = compactGaps && rowColMap.has(lc.row)
-                                ? ((_a = rowColMap.get(lc.row).get(lc.col)) !== null && _a !== void 0 ? _a : (lc.col - minCol))
-                                : (lc.col - minCol);
-                            let gridRow = lc.row - minRow;
-                            if (serpentine && (gridRow % 2 === 1)) {
-                                gridCol = (tilesX - 1) - gridCol;
-                            }
-                            // Clamp to valid range
-                            if (gridCol < 0)
-                                gridCol = 0;
-                            if (gridCol >= tilesX)
-                                gridCol = tilesX - 1;
-                            if (gridRow < 0)
-                                gridRow = 0;
-                            if (gridRow >= tilesY)
-                                gridRow = tilesY - 1;
-                            // Collision resolution: if tile is occupied, find nearest free tile
-                            const key = tileKey(gridCol, gridRow);
-                            if (tileOccupancy.has(key)) {
-                                const nodePos = positions[id];
-                                let bestCol = gridCol, bestRow = gridRow;
-                                let bestDist = Infinity;
-                                // Search in expanding radius for free tile
-                                for (let radius = 1; radius <= Math.max(tilesX, tilesY); radius++) {
-                                    let found = false;
-                                    for (let dc = -radius; dc <= radius; dc++) {
-                                        for (let dr = -radius; dr <= radius; dr++) {
-                                            if (Math.abs(dc) !== radius && Math.abs(dr) !== radius)
-                                                continue; // Only check perimeter
-                                            const testCol = gridCol + dc;
-                                            const testRow = gridRow + dr;
-                                            if (testCol < 0 || testCol >= tilesX || testRow < 0 || testRow >= tilesY)
-                                                continue;
-                                            const testKey = tileKey(testCol, testRow);
-                                            if (!tileOccupancy.has(testKey)) {
-                                                // Calculate distance to this tile's center
-                                                const tileU = (testCol + 0.5) / tilesX;
-                                                const tileV = (testRow + 0.5) / tilesY;
-                                                const tileCenterX = minX + tileU * clusterWidth;
-                                                const tileCenterY = minY + tileV * clusterHeight;
-                                                const dist = Math.hypot(nodePos[0] - tileCenterX, nodePos[1] - tileCenterY);
-                                                if (dist < bestDist) {
-                                                    bestDist = dist;
-                                                    bestCol = testCol;
-                                                    bestRow = testRow;
-                                                    found = true;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    if (found)
-                                        break;
-                                }
-                                gridCol = bestCol;
-                                gridRow = bestRow;
-                            }
-                            tileOccupancy.set(tileKey(gridCol, gridRow), id);
-                            // Optionally support vertical anchor flip
-                            if (workerDebug.clusterAnchor === 'max') {
-                                gridRow = Math.max(0, tilesY - 1 - gridRow);
-                            }
-                            let uvBounds = calculateUvBoundsFromGridPosition(gridCol, gridRow, tilesX, tilesY);
-                            const inset = Math.max(0, Math.min(0.49, Number(workerDebug.clusterUvInset) || 0));
-                            if (inset > 0) {
-                                const u0 = uvBounds[0], v0 = uvBounds[1], u1 = uvBounds[2], v1 = uvBounds[3];
-                                const du = (u1 - u0) * inset;
-                                const dv = (v1 - v0) * inset;
-                                uvBounds = [u0 + du, v0 + dv, u1 - du, v1 - dv];
-                            }
-                            // Optional parity UV shift: shift odd rows horizontally by half a tile width in UV space.
-                            // Enhanced: use precise hex geometry for sub-pixel accuracy
-                            if (workerDebug.clusterParityUvShift && (gridRow % 2 === 1)) {
-                                // Use actual lattice row parity from hex geometry, not tile row
-                                const hexRowParity = lc.row % 2;
-                                const shift = hexRowParity === 1 ? 0.5 / tilesX : 0;
-                                let u0 = uvBounds[0] + shift;
-                                let u1 = uvBounds[2] + shift;
-                                // Wrap within [0,1]
-                                if (u0 >= 1)
-                                    u0 -= 1;
-                                if (u1 > 1)
-                                    u1 -= 1;
-                                // Guard against pathological wrapping inversion (should not occur with shift<tileWidth)
-                                if (u1 < u0) {
-                                    // If inverted due to wrapping edge case, clamp instead of wrap
-                                    u0 = Math.min(u0, 1 - (1 / tilesX));
-                                    u1 = Math.min(1, u0 + (1 / tilesX));
-                                }
-                                uvBounds = [u0, uvBounds[1], u1, uvBounds[3]];
-                            }
-                            infections.set(id, Object.assign(Object.assign({}, inf), { gridPosition: [gridCol, gridRow], uvBounds, tilesX, tilesY }));
-                        }
-                        // Advance cluster index and continue to next cluster (skip legacy logic)
-                        clusterIndex++;
-                        continue;
-                    }
-                    catch (e) {
-                        console.warn('[assignClusterGridPositions][hex-lattice] failed, falling back to legacy path:', e);
-                        // fall through to existing (spatial) logic
-                    }
-                }
-                // Find the bounding box of this cluster in grid space first
-                let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-                for (const idx of cluster) {
-                    const pos = positions[idx];
-                    if (!pos)
-                        continue;
-                    minX = Math.min(minX, pos[0]);
-                    maxX = Math.max(maxX, pos[0]);
-                    minY = Math.min(minY, pos[1]);
-                    maxY = Math.max(maxY, pos[1]);
-                }
-                const clusterWidth = Math.max(0, maxX - minX);
-                const clusterHeight = Math.max(0, maxY - minY);
-                console.log('[assignClusterGridPositions] Cluster bounds:', {
-                    photoId: photoId.substring(0, 8),
-                    clusterIndex,
-                    hexCount: cluster.length,
-                    minX: minX.toFixed(2),
-                    maxX: maxX.toFixed(2),
-                    minY: minY.toFixed(2),
-                    maxY: maxY.toFixed(2),
-                    width: clusterWidth.toFixed(2),
-                    height: clusterHeight.toFixed(2)
+            const clusterWidth = Math.max(0, maxX - minX);
+            const clusterHeight = Math.max(0, maxY - minY);
+            // Infer spacings from hexRadius (flat-top hex layout):
+            const horizSpacing = Math.sqrt(3) * hexRadius;
+            const vertSpacing = 1.5 * hexRadius;
+            // Build lattice coordinates (rowIndex, colIndex) respecting row parity offset.
+            const latticeCoords = new Map();
+            let minRow = Infinity,
+              maxRow = -Infinity,
+              minCol = Infinity,
+              maxCol = -Infinity;
+            for (const id of cluster) {
+              const p = positions[id];
+              if (!p) continue;
+              const rowF = (p[1] - minY) / vertSpacing;
+              const row = Math.round(rowF);
+              // Row parity offset: odd rows in generatePixelScreen are shifted +0.5 * horizSpacing.
+              const rowOffset = row % 2 === 1 ? horizSpacing * 0.5 : 0;
+              const colF = (p[0] - (minX + rowOffset)) / horizSpacing;
+              const col = Math.round(colF);
+              latticeCoords.set(id, { row, col });
+              if (row < minRow) minRow = row;
+              if (row > maxRow) maxRow = row;
+              if (col < minCol) minCol = col;
+              if (col > maxCol) maxCol = col;
+            }
+            const latticeRows = maxRow - minRow + 1;
+            const latticeCols = maxCol - minCol + 1;
+            // Initial tile grid matches lattice extents.
+            let tilesX = latticeCols;
+            let tilesY = latticeRows;
+            // If we have more hexes than lattice cells due to rounding collisions, expand.
+            const rawTileCount = tilesX * tilesY;
+            if (cluster.length > rawTileCount) {
+              // Simple expansion: grow columns while respecting max cap.
+              const MAX_TILES =
+                typeof workerDebug.clusterMaxTiles === 'number' &&
+                workerDebug.clusterMaxTiles > 0
+                  ? Math.floor(workerDebug.clusterMaxTiles)
+                  : 128;
+              while (
+                tilesX * tilesY < cluster.length &&
+                tilesX * tilesY < MAX_TILES
+              ) {
+                if (tilesX <= tilesY) tilesX++;
+                else tilesY++;
+              }
+            }
+            console.log(
+              '[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.
+            // Enhancement: compact gaps in each row for more contiguous image mapping
+            const compactGaps = workerDebug.clusterCompactGaps !== false;
+            // Build row-by-row column mapping to handle gaps
+            const rowColMap = new Map(); // row -> (oldCol -> newCol)
+            if (compactGaps) {
+              for (let row = minRow; row <= maxRow; row++) {
+                const colsInRow = Array.from(latticeCoords.entries())
+                  .filter(([_, lc]) => lc.row === row)
+                  .map(([_, lc]) => lc.col)
+                  .sort((a, b) => a - b);
+                const colMap = new Map();
+                colsInRow.forEach((oldCol, newIdx) => {
+                  colMap.set(oldCol, newIdx);
                 });
-                // Calculate optimal tilesX and tilesY based on cluster aspect ratio
-                // 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)');
-                let tilesX;
-                let tilesY;
-                if (cluster.length === 1) {
-                    // Single hexagon: use 1x1
-                    tilesX = 1;
-                    tilesY = 1;
-                }
-                else if (workerDebug.clusterDynamicTiling !== false) {
-                    // Dynamic tiling: match cluster aspect ratio
-                    // sqrt(tilesX * tilesY) = sqrt(targetTileCount)
-                    // tilesX / tilesY = clusterAspect
-                    // => tilesX = clusterAspect * tilesY
-                    // => clusterAspect * tilesY * tilesY = targetTileCount
-                    // => tilesY = sqrt(targetTileCount / clusterAspect)
-                    tilesY = Math.max(1, Math.round(Math.sqrt(targetTileCount / clusterAspect)));
-                    tilesX = Math.max(1, Math.round(clusterAspect * tilesY));
-                    // Clamp to reasonable range
-                    tilesX = Math.max(1, Math.min(8, tilesX));
-                    tilesY = Math.max(1, Math.min(8, tilesY));
-                }
-                else {
-                    // Fallback to fixed tiling from infection config
-                    tilesX = Math.max(1, firstInf.tilesX || 4);
-                    tilesY = Math.max(1, firstInf.tilesY || 4);
-                }
-                // If the cluster contains more hexes than tiles, expand the tile grid
-                // to avoid many hexes mapping to the same UV tile (which causes repeating
-                // image patches). Preserve the tile aspect ratio but scale up the total
-                // tile count to be at least cluster.length, clamped to a safe maximum.
-                try {
-                    const currentTileCount = tilesX * tilesY;
-                    const requiredTiles = Math.max(currentTileCount, cluster.length);
-                    const MAX_TILES = typeof workerDebug.clusterMaxTiles === 'number' && workerDebug.clusterMaxTiles > 0 ? Math.max(1, Math.floor(workerDebug.clusterMaxTiles)) : 64;
-                    const targetTiles = Math.min(requiredTiles, MAX_TILES);
-                    if (targetTiles > currentTileCount) {
-                        // preserve aspect ratio roughly: ratio = tilesX / tilesY
-                        const ratio = tilesX / Math.max(1, tilesY);
-                        // compute new tilesY from targetTiles and ratio
-                        let newTilesY = Math.max(1, Math.round(Math.sqrt(targetTiles / Math.max(1e-9, ratio))));
-                        let newTilesX = Math.max(1, Math.round(ratio * newTilesY));
-                        // if rounding produced fewer tiles than needed, bump progressively
-                        while (newTilesX * newTilesY < targetTiles) {
-                            if (newTilesX <= newTilesY)
-                                newTilesX++;
-                            else
-                                newTilesY++;
-                            if (newTilesX * newTilesY >= MAX_TILES)
-                                break;
-                        }
-                        // clamp to reasonable maxima
-                        newTilesX = Math.max(1, Math.min(16, newTilesX));
-                        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');
-                    }
-                }
-                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');
-                // 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 || clusterHeight < 1e-6) {
-                    const idx = cluster[0];
-                    const inf = infections.get(idx);
-                    if (!inf)
+                rowColMap.set(row, colMap);
+              }
+            }
+            // Collision detection: track which tiles are occupied
+            const tileOccupancy = new Map(); // "col,row" -> nodeId
+            const tileKey = (c, r) => `${c},${r}`;
+            for (const id of cluster) {
+              const inf = infections.get(id);
+              if (!inf) continue;
+              const lc = latticeCoords.get(id);
+              if (!lc) continue;
+              let gridCol =
+                compactGaps && rowColMap.has(lc.row)
+                  ? (_a = rowColMap.get(lc.row).get(lc.col)) !== null &&
+                    _a !== void 0
+                    ? _a
+                    : lc.col - minCol
+                  : lc.col - minCol;
+              let gridRow = lc.row - minRow;
+              if (serpentine && gridRow % 2 === 1) {
+                gridCol = tilesX - 1 - gridCol;
+              }
+              // Clamp to valid range
+              if (gridCol < 0) gridCol = 0;
+              if (gridCol >= tilesX) gridCol = tilesX - 1;
+              if (gridRow < 0) gridRow = 0;
+              if (gridRow >= tilesY) gridRow = tilesY - 1;
+              // Collision resolution: if tile is occupied, find nearest free tile
+              const key = tileKey(gridCol, gridRow);
+              if (tileOccupancy.has(key)) {
+                const nodePos = positions[id];
+                let bestCol = gridCol,
+                  bestRow = gridRow;
+                let bestDist = Infinity;
+                // Search in expanding radius for free tile
+                for (
+                  let radius = 1;
+                  radius <= Math.max(tilesX, tilesY);
+                  radius++
+                ) {
+                  let found = false;
+                  for (let dc = -radius; dc <= radius; dc++) {
+                    for (let dr = -radius; dr <= radius; dr++) {
+                      if (Math.abs(dc) !== radius && Math.abs(dr) !== radius)
+                        continue; // Only check perimeter
+                      const testCol = gridCol + dc;
+                      const testRow = gridRow + dr;
+                      if (
+                        testCol < 0 ||
+                        testCol >= tilesX ||
+                        testRow < 0 ||
+                        testRow >= tilesY
+                      )
                         continue;
-                    // Deterministic hash from index to pick a tile
-                    const h = (idx * 2654435761) >>> 0;
-                    const gridCol = h % tilesX;
-                    let gridRow = ((h >>> 8) % tilesY);
-                    // If configured, allow anchoring to the bottom of the image (flip vertical tile index)
-                    if (workerDebug.clusterAnchor === 'max') {
-                        gridRow = Math.max(0, tilesY - 1 - gridRow);
-                    }
-                    const uvBounds = calculateUvBoundsFromGridPosition(gridCol, gridRow, tilesX, tilesY);
-                    infections.set(idx, Object.assign(Object.assign({}, inf), { gridPosition: [gridCol, gridRow], uvBounds }));
-                    continue;
-                }
-                // Optionally preserve aspect ratio when mapping cluster to tile grid
-                const preserveAspect = !!workerDebug.clusterPreserveAspect;
-                let normMinX = minX, normMinY = minY, normWidth = clusterWidth, normHeight = clusterHeight;
-                if (preserveAspect) {
-                    const clusterAspect = clusterWidth / clusterHeight;
-                    const tileAspect = tilesX / tilesY;
-                    const fillMode = workerDebug.clusterFillMode || 'contain';
-                    if (fillMode === 'contain') {
-                        // current behavior: pad shorter dimension so the whole image fits (no cropping)
-                        if (clusterAspect > tileAspect) {
-                            const effectiveHeight = clusterWidth / tileAspect;
-                            const pad = effectiveHeight - clusterHeight;
-                            if (workerDebug.clusterAnchor === 'min') {
-                                normMinY = minY;
-                            }
-                            else {
-                                normMinY = minY - pad / 2;
-                            }
-                            normHeight = effectiveHeight;
-                        }
-                        else if (clusterAspect < tileAspect) {
-                            const effectiveWidth = clusterHeight * tileAspect;
-                            const pad = effectiveWidth - clusterWidth;
-                            if (workerDebug.clusterAnchor === 'min') {
-                                normMinX = minX;
-                            }
-                            else {
-                                normMinX = minX - pad / 2;
-                            }
-                            normWidth = effectiveWidth;
-                        }
-                    }
-                    else {
-                        // 'cover' mode: scale so tile grid fully covers cluster bounds, allowing cropping
-                        if (clusterAspect > tileAspect) {
-                            // cluster is wider than tile grid: scale width down (crop left/right)
-                            const effectiveWidth = clusterHeight * tileAspect;
-                            const crop = clusterWidth - effectiveWidth;
-                            if (workerDebug.clusterAnchor === 'min') {
-                                normMinX = minX + crop; // crop from right
-                            }
-                            else {
-                                normMinX = minX + crop / 2;
-                            }
-                            normWidth = effectiveWidth;
-                        }
-                        else if (clusterAspect < tileAspect) {
-                            // cluster is taller than tile grid: scale height down (crop top/bottom)
-                            const effectiveHeight = clusterWidth / tileAspect;
-                            const crop = clusterHeight - effectiveHeight;
-                            if (workerDebug.clusterAnchor === 'min') {
-                                normMinY = minY + crop;
-                            }
-                            else {
-                                normMinY = minY + crop / 2;
-                            }
-                            normHeight = effectiveHeight;
+                      const testKey = tileKey(testCol, testRow);
+                      if (!tileOccupancy.has(testKey)) {
+                        // Calculate distance to this tile's center
+                        const tileU = (testCol + 0.5) / tilesX;
+                        const tileV = (testRow + 0.5) / tilesY;
+                        const tileCenterX = minX + tileU * clusterWidth;
+                        const tileCenterY = minY + tileV * clusterHeight;
+                        const dist = Math.hypot(
+                          nodePos[0] - tileCenterX,
+                          nodePos[1] - tileCenterY
+                        );
+                        if (dist < bestDist) {
+                          bestDist = dist;
+                          bestCol = testCol;
+                          bestRow = testRow;
+                          found = true;
                         }
+                      }
                     }
+                  }
+                  if (found) break;
                 }
-                // Assign grid positions using preferred-quantized -> nearest-free strategy
-                // Guard tiny normalized dimensions to avoid degenerate quantization
-                // This produces contiguous tiling for clusters and avoids many hexes
-                // quantizing into the same UV tile.
-                try {
-                    const clusterSet = new Set(cluster);
-                    // Helper: tile bounds check
-                    const inTileBounds = (c, r) => c >= 0 && c < tilesX && r >= 0 && r < tilesY;
-                    // Tile occupancy map key
-                    const tileKey = (c, r) => `${c},${r}`;
-                    // Pre-allocate occupancy map and assignment map
-                    const occupied = new Map();
-                    const assignment = new Map();
-                    // Choose origin by cluster centroid (closest hex to centroid)
-                    let cx = 0, cy = 0;
-                    for (const id of cluster) {
-                        const p = positions[id];
-                        cx += p[0];
-                        cy += p[1];
-                    }
-                    cx /= cluster.length;
-                    cy /= cluster.length;
-                    let originIndex = cluster[0];
-                    let bestD = Infinity;
-                    for (const id of cluster) {
-                        const p = positions[id];
-                        const d = Math.hypot(p[0] - cx, p[1] - cy);
-                        if (d < bestD) {
-                            bestD = d;
-                            originIndex = id;
-                        }
-                    }
-                    // Tile-first scanline assignment: build tiles in row-major order, then pick nearest unassigned node
-                    const startCol = Math.floor(tilesX / 2);
-                    const startRow = Math.floor(tilesY / 2);
-                    // Ensure normalized dims aren't tiny
-                    const MIN_NORM = 1e-6;
-                    if (normWidth < MIN_NORM)
-                        normWidth = MIN_NORM;
-                    if (normHeight < MIN_NORM)
-                        normHeight = MIN_NORM;
-                    // Build tile list in row-major or serpentine order depending on config
-                    const tiles = [];
-                    const scanMode = (workerDebug.clusterScanMode || 'row');
-                    for (let r = 0; r < tilesY; r++) {
-                        if (scanMode === 'serpentine' && (r % 2 === 1)) {
-                            // right-to-left on odd rows for serpentine
-                            for (let c = tilesX - 1; c >= 0; c--)
-                                tiles.push([c, r]);
-                        }
-                        else {
-                            for (let c = 0; c < tilesX; c++)
-                                tiles.push([c, r]);
-                        }
-                    }
-                    // Helper: compute tile center in cluster-space
-                    const parityAware = !!workerDebug.clusterParityAware;
-                    // compute physical horizontal offset for hex parity from cluster geometry
-                    const hexSpacingFactor = Number(workerDebug.hexSpacing) || 1;
-                    // initial fallback spacing based on configured hexRadius
-                    let realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
-                    // Try to infer horizontal spacing from actual node positions in the cluster.
-                    // Group nodes into approximate rows and measure adjacent x-deltas.
-                    try {
-                        const rowBuckets = new Map();
-                        for (const id of cluster) {
-                            const p = positions[id];
-                            if (!p)
-                                continue;
-                            // ratio across normalized height
-                            const ratio = (p[1] - normMinY) / Math.max(1e-9, normHeight);
-                            let r = Math.floor(ratio * tilesY);
-                            r = Math.max(0, Math.min(tilesY - 1, r));
-                            const arr = rowBuckets.get(r) || [];
-                            arr.push(p[0]);
-                            rowBuckets.set(r, arr);
-                        }
-                        const diffs = [];
-                        for (const xs of rowBuckets.values()) {
-                            if (!xs || xs.length < 2)
-                                continue;
-                            xs.sort((a, b) => a - b);
-                            for (let i = 1; i < xs.length; i++)
-                                diffs.push(xs[i] - xs[i - 1]);
-                        }
-                        if (diffs.length > 0) {
-                            diffs.sort((a, b) => a - b);
-                            const mid = Math.floor(diffs.length / 2);
-                            realHorizSpacing = diffs.length % 2 === 1 ? diffs[mid] : ((diffs[mid - 1] + diffs[mid]) / 2);
-                            if (!isFinite(realHorizSpacing) || realHorizSpacing <= 0)
-                                realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
-                        }
-                    }
-                    catch (e) {
-                        // fallback to default computed spacing
-                        realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
-                    }
-                    // tile center calculation: simple regular grid, no parity offset
-                    // The hex positions already have natural staggering, so tile centers should be regular
-                    const tileCenter = (col, row) => {
-                        const u = (col + 0.5) / tilesX;
-                        const v = (row + 0.5) / tilesY;
-                        const x = normMinX + u * normWidth;
-                        const y = normMinY + v * normHeight;
-                        return [x, y];
-                    };
-                    console.log('[assignClusterGridPositions] Normalized bounds for tiling:', {
-                        normMinX: normMinX.toFixed(2),
-                        normMinY: normMinY.toFixed(2),
-                        normWidth: normWidth.toFixed(2),
-                        normHeight: normHeight.toFixed(2),
-                        preserveAspect,
-                        fillMode: workerDebug.clusterFillMode
-                    });
-                    // SPATIAL assignment: each hex gets the tile whose center is spatially nearest
-                    // This guarantees perfect alignment between hex positions and tile centers
-                    // Build centers map first
-                    const centers = [];
-                    for (let r = 0; r < tilesY; r++)
-                        for (let c = 0; c < tilesX; c++) {
-                            const [x, y] = tileCenter(c, r);
-                            centers.push({ t: [c, r], x, y });
-                        }
-                    // Optionally collect centers for debug visualization
-                    if (workerDebug.showTileCenters) {
-                        debugCenters.push({
-                            photoId,
-                            clusterIndex,
-                            centers: centers.map(c => ({ x: c.x, y: c.y, col: c.t[0], row: c.t[1] }))
-                        });
-                    }
-                    // Assign each hex to its nearest tile center (purely spatial)
-                    // Log a few examples to verify the mapping
-                    const assignmentSamples = [];
-                    for (const nodeId of cluster) {
-                        const nodePos = positions[nodeId];
-                        if (!nodePos)
-                            continue;
-                        let nearestTile = centers[0].t;
-                        let nearestDist = Infinity;
-                        let nearestCenter = centers[0];
-                        for (const c of centers) {
-                            const dist = Math.hypot(nodePos[0] - c.x, nodePos[1] - c.y);
-                            if (dist < nearestDist) {
-                                nearestDist = dist;
-                                nearestTile = c.t;
-                                nearestCenter = c;
-                            }
-                        }
-                        assignment.set(nodeId, nearestTile);
-                        occupied.set(tileKey(nearestTile[0], nearestTile[1]), true);
-                        // Sample first few for debugging
-                        if (assignmentSamples.length < 5) {
-                            assignmentSamples.push({
-                                nodeId,
-                                nodeX: nodePos[0],
-                                nodeY: nodePos[1],
-                                tileCol: nearestTile[0],
-                                tileRow: nearestTile[1],
-                                centerX: nearestCenter.x,
-                                centerY: nearestCenter.y,
-                                dist: nearestDist
-                            });
-                        }
-                    }
-                    console.log('[assignClusterGridPositions] Spatially assigned', cluster.length, 'hexes to nearest tile centers');
-                    console.log('[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
-                    // For each hex, check if its neighbors suggest a better tile assignment for visual continuity
-                    if (workerDebug.clusterNeighborAware !== false) {
-                        const maxIterations = 3; // Multiple passes to propagate improvements
-                        for (let iter = 0; iter < maxIterations; iter++) {
-                            let adjustments = 0;
-                            for (const nodeId of cluster) {
-                                const currentTile = assignment.get(nodeId);
-                                if (!currentTile)
-                                    continue;
-                                // Get neighbors within this cluster
-                                const neighbors = getNeighborsCached(nodeId, positions, hexRadius);
-                                const clusterNeighbors = neighbors.filter(n => clusterSet.has(n) && assignment.has(n));
-                                if (clusterNeighbors.length === 0)
-                                    continue;
-                                // Collect neighbor tiles and compute centroid
-                                const neighborTiles = [];
-                                for (const n of clusterNeighbors) {
-                                    const nt = assignment.get(n);
-                                    if (nt)
-                                        neighborTiles.push(nt);
-                                }
-                                if (neighborTiles.length === 0)
-                                    continue;
-                                // Compute average neighbor tile position
-                                let avgCol = 0, avgRow = 0;
-                                for (const [c, r] of neighborTiles) {
-                                    avgCol += c;
-                                    avgRow += r;
-                                }
-                                avgCol /= neighborTiles.length;
-                                avgRow /= neighborTiles.length;
-                                // Find the tile closest to the neighbor average that's spatially near this node
-                                const nodePos = positions[nodeId];
-                                if (!nodePos)
-                                    continue;
-                                let bestAlternative = null;
-                                let bestScore = Infinity;
-                                // Consider tiles in a local neighborhood around current tile
-                                const searchRadius = 2;
-                                for (let dc = -searchRadius; dc <= searchRadius; dc++) {
-                                    for (let dr = -searchRadius; dr <= searchRadius; dr++) {
-                                        const candidateCol = Math.max(0, Math.min(tilesX - 1, currentTile[0] + dc));
-                                        const candidateRow = Math.max(0, Math.min(tilesY - 1, currentTile[1] + dr));
-                                        const candidate = [candidateCol, candidateRow];
-                                        // Score: distance to neighbor tile average + spatial distance to tile center
-                                        const tileDist = Math.hypot(candidateCol - avgCol, candidateRow - avgRow);
-                                        const [cx, cy] = tileCenter(candidateCol, candidateRow);
-                                        const spatialDist = Math.hypot(nodePos[0] - cx, nodePos[1] - cy);
-                                        const score = tileDist * 0.7 + spatialDist * 0.3;
-                                        if (score < bestScore) {
-                                            bestScore = score;
-                                            bestAlternative = candidate;
-                                        }
-                                    }
-                                }
-                                // If we found a better tile and it's different from current, update
-                                if (bestAlternative && (bestAlternative[0] !== currentTile[0] || bestAlternative[1] !== currentTile[1])) {
-                                    assignment.set(nodeId, bestAlternative);
-                                    adjustments++;
-                                }
-                            }
-                            if (adjustments === 0)
-                                break; // Converged
-                            console.log('[assignClusterGridPositions] Neighbor-aware refinement iteration', iter + 1, ':', adjustments, 'adjustments');
-                        }
-                    }
-                    // Finally write assignments back into infections with UV bounds/inset
-                    const inset = Math.max(0, Math.min(0.49, Number(workerDebug.clusterUvInset) || 0));
-                    for (const id of cluster) {
-                        const inf = infections.get(id);
-                        if (!inf)
-                            continue;
-                        let assignedTile = assignment.get(id) || [0, 0];
-                        // Support bottom anchoring: flip the vertical tile index when 'max' is configured
-                        if (workerDebug.clusterAnchor === 'max') {
-                            assignedTile = [assignedTile[0], Math.max(0, tilesY - 1 - assignedTile[1])];
-                        }
-                        let uvBounds = calculateUvBoundsFromGridPosition(assignedTile[0], assignedTile[1], tilesX, tilesY);
-                        if (inset > 0) {
-                            const u0 = uvBounds[0], v0 = uvBounds[1], u1 = uvBounds[2], v1 = uvBounds[3];
-                            const du = (u1 - u0) * inset;
-                            const dv = (v1 - v0) * inset;
-                            uvBounds = [u0 + du, v0 + dv, u1 - du, v1 - dv];
-                        }
-                        infections.set(id, Object.assign(Object.assign({}, inf), { gridPosition: [assignedTile[0], assignedTile[1]], uvBounds, tilesX, tilesY }));
-                    }
-                    console.log('[assignClusterGridPositions] Assigned grid positions to', cluster.length, 'hexes in cluster (BFS)');
-                }
-                catch (e) {
-                    console.error('[assignClusterGridPositions] BFS assignment failed, falling back to quantization', e);
-                    // fallback: leave previous behavior (quantization) to avoid breaking
+                gridCol = bestCol;
+                gridRow = bestRow;
+              }
+              tileOccupancy.set(tileKey(gridCol, gridRow), id);
+              // Optionally support vertical anchor flip
+              if (workerDebug.clusterAnchor === 'max') {
+                gridRow = Math.max(0, tilesY - 1 - gridRow);
+              }
+              let uvBounds = calculateUvBoundsFromGridPosition(
+                gridCol,
+                gridRow,
+                tilesX,
+                tilesY
+              );
+              const inset = Math.max(
+                0,
+                Math.min(0.49, Number(workerDebug.clusterUvInset) || 0)
+              );
+              if (inset > 0) {
+                const u0 = uvBounds[0],
+                  v0 = uvBounds[1],
+                  u1 = uvBounds[2],
+                  v1 = uvBounds[3];
+                const du = (u1 - u0) * inset;
+                const dv = (v1 - v0) * inset;
+                uvBounds = [u0 + du, v0 + dv, u1 - du, v1 - dv];
+              }
+              // Optional parity UV shift: shift odd rows horizontally by half a tile width in UV space.
+              // Enhanced: use precise hex geometry for sub-pixel accuracy
+              if (workerDebug.clusterParityUvShift && gridRow % 2 === 1) {
+                // Use actual lattice row parity from hex geometry, not tile row
+                const hexRowParity = lc.row % 2;
+                const shift = hexRowParity === 1 ? 0.5 / tilesX : 0;
+                let u0 = uvBounds[0] + shift;
+                let u1 = uvBounds[2] + shift;
+                // Wrap within [0,1]
+                if (u0 >= 1) u0 -= 1;
+                if (u1 > 1) u1 -= 1;
+                // Guard against pathological wrapping inversion (should not occur with shift<tileWidth)
+                if (u1 < u0) {
+                  // If inverted due to wrapping edge case, clamp instead of wrap
+                  u0 = Math.min(u0, 1 - 1 / tilesX);
+                  u1 = Math.min(1, u0 + 1 / tilesX);
                 }
-                clusterIndex++;
+                uvBounds = [u0, uvBounds[1], u1, uvBounds[3]];
+              }
+              infections.set(
+                id,
+                Object.assign(Object.assign({}, inf), {
+                  gridPosition: [gridCol, gridRow],
+                  uvBounds,
+                  tilesX,
+                  tilesY,
+                })
+              );
             }
+            // Advance cluster index and continue to next cluster (skip legacy logic)
+            clusterIndex++;
+            continue;
+          } catch (e) {
+            console.warn(
+              '[assignClusterGridPositions][hex-lattice] failed, falling back to legacy path:',
+              e
+            );
+            // fall through to existing (spatial) logic
+          }
         }
-        // Log cluster statistics
-        if (clusterSizes.length > 0) {
-            clusterSizes.sort((a, b) => b - a); // descending
-            const avgSize = clusterSizes.reduce((sum, s) => sum + s, 0) / clusterSizes.length;
-            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), '%)');
+        // Find the bounding box of this cluster in grid space first
+        let minX = Infinity,
+          maxX = -Infinity,
+          minY = Infinity,
+          maxY = -Infinity;
+        for (const idx of cluster) {
+          const pos = positions[idx];
+          if (!pos) continue;
+          minX = Math.min(minX, pos[0]);
+          maxX = Math.max(maxX, pos[0]);
+          minY = Math.min(minY, pos[1]);
+          maxY = Math.max(maxY, pos[1]);
         }
-        console.log('[assignClusterGridPositions] Complete');
-    }
-    catch (e) {
-        console.error('[assignClusterGridPositions] Error:', e);
-    }
-    return debugCenters;
-}
-function postOptimizationMerge(infections, positions, hexRadius, debug = false) {
-    var _a;
-    try {
-        if (!workerDebug || !workerDebug.enableMerges) {
-            if (debug && workerDebug.mergeLogs)
-                console.log('[merge] disabled');
-            return;
+        const clusterWidth = Math.max(0, maxX - minX);
+        const clusterHeight = Math.max(0, maxY - minY);
+        console.log('[assignClusterGridPositions] Cluster bounds:', {
+          photoId: photoId.substring(0, 8),
+          clusterIndex,
+          hexCount: cluster.length,
+          minX: minX.toFixed(2),
+          maxX: maxX.toFixed(2),
+          minY: minY.toFixed(2),
+          maxY: maxY.toFixed(2),
+          width: clusterWidth.toFixed(2),
+          height: clusterHeight.toFixed(2),
+        });
+        // Calculate optimal tilesX and tilesY based on cluster aspect ratio
+        // 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)'
+        );
+        let tilesX;
+        let tilesY;
+        if (cluster.length === 1) {
+          // Single hexagon: use 1x1
+          tilesX = 1;
+          tilesY = 1;
+        } else if (workerDebug.clusterDynamicTiling !== false) {
+          // Dynamic tiling: match cluster aspect ratio
+          // sqrt(tilesX * tilesY) = sqrt(targetTileCount)
+          // tilesX / tilesY = clusterAspect
+          // => tilesX = clusterAspect * tilesY
+          // => clusterAspect * tilesY * tilesY = targetTileCount
+          // => tilesY = sqrt(targetTileCount / clusterAspect)
+          tilesY = Math.max(
+            1,
+            Math.round(Math.sqrt(targetTileCount / clusterAspect))
+          );
+          tilesX = Math.max(1, Math.round(clusterAspect * tilesY));
+          // Clamp to reasonable range
+          tilesX = Math.max(1, Math.min(8, tilesX));
+          tilesY = Math.max(1, Math.min(8, tilesY));
+        } else {
+          // Fallback to fixed tiling from infection config
+          tilesX = Math.max(1, firstInf.tilesX || 4);
+          tilesY = Math.max(1, firstInf.tilesY || 4);
         }
-        const threshold = typeof workerDebug.mergeSmallComponentsThreshold === 'number' ? workerDebug.mergeSmallComponentsThreshold : 3;
-        const byPhoto = new Map();
-        for (const [idx, inf] of infections) {
-            const arr = byPhoto.get(inf.photo.id) || [];
-            arr.push(idx);
-            byPhoto.set(inf.photo.id, arr);
+        // If the cluster contains more hexes than tiles, expand the tile grid
+        // to avoid many hexes mapping to the same UV tile (which causes repeating
+        // image patches). Preserve the tile aspect ratio but scale up the total
+        // tile count to be at least cluster.length, clamped to a safe maximum.
+        try {
+          const currentTileCount = tilesX * tilesY;
+          const requiredTiles = Math.max(currentTileCount, cluster.length);
+          const MAX_TILES =
+            typeof workerDebug.clusterMaxTiles === 'number' &&
+            workerDebug.clusterMaxTiles > 0
+              ? Math.max(1, Math.floor(workerDebug.clusterMaxTiles))
+              : 64;
+          const targetTiles = Math.min(requiredTiles, MAX_TILES);
+          if (targetTiles > currentTileCount) {
+            // preserve aspect ratio roughly: ratio = tilesX / tilesY
+            const ratio = tilesX / Math.max(1, tilesY);
+            // compute new tilesY from targetTiles and ratio
+            let newTilesY = Math.max(
+              1,
+              Math.round(Math.sqrt(targetTiles / Math.max(1e-9, ratio)))
+            );
+            let newTilesX = Math.max(1, Math.round(ratio * newTilesY));
+            // if rounding produced fewer tiles than needed, bump progressively
+            while (newTilesX * newTilesY < targetTiles) {
+              if (newTilesX <= newTilesY) newTilesX++;
+              else newTilesY++;
+              if (newTilesX * newTilesY >= MAX_TILES) break;
+            }
+            // clamp to reasonable maxima
+            newTilesX = Math.max(1, Math.min(16, newTilesX));
+            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'
+            );
+          }
+        } catch (e) {
+          // if anything goes wrong, keep original tilesX/tilesY
         }
-        let merges = 0;
-        for (const [photoId, inds] of byPhoto) {
-            const comps = findConnectedComponents(inds, positions, hexRadius);
-            const small = comps.filter(c => c.length > 0 && c.length <= threshold);
-            const big = comps.filter(c => c.length > threshold);
-            if (small.length === 0 || big.length === 0)
-                continue;
-            const bounds = getGridBounds(positions);
-            for (const s of small) {
-                let best = null;
-                let bestD = Infinity;
-                for (const b of big) {
-                    let sx = 0, sy = 0, bx = 0, by = 0;
-                    for (const i of s) {
-                        const p = positions[i];
-                        if (p) {
-                            sx += p[0];
-                            sy += p[1];
-                        }
-                    }
-                    for (const i of b) {
-                        const p = positions[i];
-                        if (p) {
-                            bx += p[0];
-                            by += p[1];
-                        }
-                    }
-                    const scx = sx / s.length, scy = sy / s.length, bcx = bx / b.length, bcy = by / b.length;
-                    const dx = Math.abs(scx - bcx);
-                    const dy = Math.abs(scy - bcy);
-                    let effDx = dx;
-                    let effDy = dy;
-                    if (cache.isSpherical && bounds.width > 0 && bounds.height > 0) {
-                        if (effDx > bounds.width / 2)
-                            effDx = bounds.width - effDx;
-                        if (effDy > bounds.height / 2)
-                            effDy = bounds.height - effDy;
-                    }
-                    const d = Math.sqrt(effDx * effDx + effDy * effDy);
-                    if (d < bestD) {
-                        bestD = d;
-                        best = b;
-                    }
+        console.log(
+          '[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 ||
+          clusterHeight < 1e-6
+        ) {
+          const idx = cluster[0];
+          const inf = infections.get(idx);
+          if (!inf) continue;
+          // Deterministic hash from index to pick a tile
+          const h = (idx * 2654435761) >>> 0;
+          const gridCol = h % tilesX;
+          let gridRow = (h >>> 8) % tilesY;
+          // If configured, allow anchoring to the bottom of the image (flip vertical tile index)
+          if (workerDebug.clusterAnchor === 'max') {
+            gridRow = Math.max(0, tilesY - 1 - gridRow);
+          }
+          const uvBounds = calculateUvBoundsFromGridPosition(
+            gridCol,
+            gridRow,
+            tilesX,
+            tilesY
+          );
+          infections.set(
+            idx,
+            Object.assign(Object.assign({}, inf), {
+              gridPosition: [gridCol, gridRow],
+              uvBounds,
+            })
+          );
+          continue;
+        }
+        // Optionally preserve aspect ratio when mapping cluster to tile grid
+        const preserveAspect = !!workerDebug.clusterPreserveAspect;
+        let normMinX = minX,
+          normMinY = minY,
+          normWidth = clusterWidth,
+          normHeight = clusterHeight;
+        if (preserveAspect) {
+          const clusterAspect = clusterWidth / clusterHeight;
+          const tileAspect = tilesX / tilesY;
+          const fillMode = workerDebug.clusterFillMode || 'contain';
+          if (fillMode === 'contain') {
+            // current behavior: pad shorter dimension so the whole image fits (no cropping)
+            if (clusterAspect > tileAspect) {
+              const effectiveHeight = clusterWidth / tileAspect;
+              const pad = effectiveHeight - clusterHeight;
+              if (workerDebug.clusterAnchor === 'min') {
+                normMinY = minY;
+              } else {
+                normMinY = minY - pad / 2;
+              }
+              normHeight = effectiveHeight;
+            } else if (clusterAspect < tileAspect) {
+              const effectiveWidth = clusterHeight * tileAspect;
+              const pad = effectiveWidth - clusterWidth;
+              if (workerDebug.clusterAnchor === 'min') {
+                normMinX = minX;
+              } else {
+                normMinX = minX - pad / 2;
+              }
+              normWidth = effectiveWidth;
+            }
+          } else {
+            // 'cover' mode: scale so tile grid fully covers cluster bounds, allowing cropping
+            if (clusterAspect > tileAspect) {
+              // cluster is wider than tile grid: scale width down (crop left/right)
+              const effectiveWidth = clusterHeight * tileAspect;
+              const crop = clusterWidth - effectiveWidth;
+              if (workerDebug.clusterAnchor === 'min') {
+                normMinX = minX + crop; // crop from right
+              } else {
+                normMinX = minX + crop / 2;
+              }
+              normWidth = effectiveWidth;
+            } else if (clusterAspect < tileAspect) {
+              // cluster is taller than tile grid: scale height down (crop top/bottom)
+              const effectiveHeight = clusterWidth / tileAspect;
+              const crop = clusterHeight - effectiveHeight;
+              if (workerDebug.clusterAnchor === 'min') {
+                normMinY = minY + crop;
+              } else {
+                normMinY = minY + crop / 2;
+              }
+              normHeight = effectiveHeight;
+            }
+          }
+        }
+        // Assign grid positions using preferred-quantized -> nearest-free strategy
+        // Guard tiny normalized dimensions to avoid degenerate quantization
+        // This produces contiguous tiling for clusters and avoids many hexes
+        // quantizing into the same UV tile.
+        try {
+          const clusterSet = new Set(cluster);
+          // Helper: tile bounds check
+          const inTileBounds = (c, r) =>
+            c >= 0 && c < tilesX && r >= 0 && r < tilesY;
+          // Tile occupancy map key
+          const tileKey = (c, r) => `${c},${r}`;
+          // Pre-allocate occupancy map and assignment map
+          const occupied = new Map();
+          const assignment = new Map();
+          // Choose origin by cluster centroid (closest hex to centroid)
+          let cx = 0,
+            cy = 0;
+          for (const id of cluster) {
+            const p = positions[id];
+            cx += p[0];
+            cy += p[1];
+          }
+          cx /= cluster.length;
+          cy /= cluster.length;
+          let originIndex = cluster[0];
+          let bestD = Infinity;
+          for (const id of cluster) {
+            const p = positions[id];
+            const d = Math.hypot(p[0] - cx, p[1] - cy);
+            if (d < bestD) {
+              bestD = d;
+              originIndex = id;
+            }
+          }
+          // Tile-first scanline assignment: build tiles in row-major order, then pick nearest unassigned node
+          const startCol = Math.floor(tilesX / 2);
+          const startRow = Math.floor(tilesY / 2);
+          // Ensure normalized dims aren't tiny
+          const MIN_NORM = 1e-6;
+          if (normWidth < MIN_NORM) normWidth = MIN_NORM;
+          if (normHeight < MIN_NORM) normHeight = MIN_NORM;
+          // Build tile list in row-major or serpentine order depending on config
+          const tiles = [];
+          const scanMode = workerDebug.clusterScanMode || 'row';
+          for (let r = 0; r < tilesY; r++) {
+            if (scanMode === 'serpentine' && r % 2 === 1) {
+              // right-to-left on odd rows for serpentine
+              for (let c = tilesX - 1; c >= 0; c--) tiles.push([c, r]);
+            } else {
+              for (let c = 0; c < tilesX; c++) tiles.push([c, r]);
+            }
+          }
+          // Helper: compute tile center in cluster-space
+          const parityAware = !!workerDebug.clusterParityAware;
+          // compute physical horizontal offset for hex parity from cluster geometry
+          const hexSpacingFactor = Number(workerDebug.hexSpacing) || 1;
+          // initial fallback spacing based on configured hexRadius
+          let realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
+          // Try to infer horizontal spacing from actual node positions in the cluster.
+          // Group nodes into approximate rows and measure adjacent x-deltas.
+          try {
+            const rowBuckets = new Map();
+            for (const id of cluster) {
+              const p = positions[id];
+              if (!p) continue;
+              // ratio across normalized height
+              const ratio = (p[1] - normMinY) / Math.max(1e-9, normHeight);
+              let r = Math.floor(ratio * tilesY);
+              r = Math.max(0, Math.min(tilesY - 1, r));
+              const arr = rowBuckets.get(r) || [];
+              arr.push(p[0]);
+              rowBuckets.set(r, arr);
+            }
+            const diffs = [];
+            for (const xs of rowBuckets.values()) {
+              if (!xs || xs.length < 2) continue;
+              xs.sort((a, b) => a - b);
+              for (let i = 1; i < xs.length; i++) diffs.push(xs[i] - xs[i - 1]);
+            }
+            if (diffs.length > 0) {
+              diffs.sort((a, b) => a - b);
+              const mid = Math.floor(diffs.length / 2);
+              realHorizSpacing =
+                diffs.length % 2 === 1
+                  ? diffs[mid]
+                  : (diffs[mid - 1] + diffs[mid]) / 2;
+              if (!isFinite(realHorizSpacing) || realHorizSpacing <= 0)
+                realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
+            }
+          } catch (e) {
+            // fallback to default computed spacing
+            realHorizSpacing = Math.sqrt(3) * hexRadius * hexSpacingFactor;
+          }
+          // tile center calculation: simple regular grid, no parity offset
+          // The hex positions already have natural staggering, so tile centers should be regular
+          const tileCenter = (col, row) => {
+            const u = (col + 0.5) / tilesX;
+            const v = (row + 0.5) / tilesY;
+            const x = normMinX + u * normWidth;
+            const y = normMinY + v * normHeight;
+            return [x, y];
+          };
+          console.log(
+            '[assignClusterGridPositions] Normalized bounds for tiling:',
+            {
+              normMinX: normMinX.toFixed(2),
+              normMinY: normMinY.toFixed(2),
+              normWidth: normWidth.toFixed(2),
+              normHeight: normHeight.toFixed(2),
+              preserveAspect,
+              fillMode: workerDebug.clusterFillMode,
+            }
+          );
+          // SPATIAL assignment: each hex gets the tile whose center is spatially nearest
+          // This guarantees perfect alignment between hex positions and tile centers
+          // Build centers map first
+          const centers = [];
+          for (let r = 0; r < tilesY; r++)
+            for (let c = 0; c < tilesX; c++) {
+              const [x, y] = tileCenter(c, r);
+              centers.push({ t: [c, r], x, y });
+            }
+          // Optionally collect centers for debug visualization
+          if (workerDebug.showTileCenters) {
+            debugCenters.push({
+              photoId,
+              clusterIndex,
+              centers: centers.map((c) => ({
+                x: c.x,
+                y: c.y,
+                col: c.t[0],
+                row: c.t[1],
+              })),
+            });
+          }
+          // Assign each hex to its nearest tile center (purely spatial)
+          // Log a few examples to verify the mapping
+          const assignmentSamples = [];
+          for (const nodeId of cluster) {
+            const nodePos = positions[nodeId];
+            if (!nodePos) continue;
+            let nearestTile = centers[0].t;
+            let nearestDist = Infinity;
+            let nearestCenter = centers[0];
+            for (const c of centers) {
+              const dist = Math.hypot(nodePos[0] - c.x, nodePos[1] - c.y);
+              if (dist < nearestDist) {
+                nearestDist = dist;
+                nearestTile = c.t;
+                nearestCenter = c;
+              }
+            }
+            assignment.set(nodeId, nearestTile);
+            occupied.set(tileKey(nearestTile[0], nearestTile[1]), true);
+            // Sample first few for debugging
+            if (assignmentSamples.length < 5) {
+              assignmentSamples.push({
+                nodeId,
+                nodeX: nodePos[0],
+                nodeY: nodePos[1],
+                tileCol: nearestTile[0],
+                tileRow: nearestTile[1],
+                centerX: nearestCenter.x,
+                centerY: nearestCenter.y,
+                dist: nearestDist,
+              });
+            }
+          }
+          console.log(
+            '[assignClusterGridPositions] Spatially assigned',
+            cluster.length,
+            'hexes to nearest tile centers'
+          );
+          console.log(
+            '[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
+          // For each hex, check if its neighbors suggest a better tile assignment for visual continuity
+          if (workerDebug.clusterNeighborAware !== false) {
+            const maxIterations = 3; // Multiple passes to propagate improvements
+            for (let iter = 0; iter < maxIterations; iter++) {
+              let adjustments = 0;
+              for (const nodeId of cluster) {
+                const currentTile = assignment.get(nodeId);
+                if (!currentTile) continue;
+                // Get neighbors within this cluster
+                const neighbors = getNeighborsCached(
+                  nodeId,
+                  positions,
+                  hexRadius
+                );
+                const clusterNeighbors = neighbors.filter(
+                  (n) => clusterSet.has(n) && assignment.has(n)
+                );
+                if (clusterNeighbors.length === 0) continue;
+                // Collect neighbor tiles and compute centroid
+                const neighborTiles = [];
+                for (const n of clusterNeighbors) {
+                  const nt = assignment.get(n);
+                  if (nt) neighborTiles.push(nt);
                 }
-                if (!best)
-                    continue;
-                const recipientId = (_a = infections.get(best[0])) === null || _a === void 0 ? void 0 : _a.photo.id;
-                if (!recipientId)
-                    continue;
-                const before = calculateContiguity(best, positions, hexRadius);
-                const after = calculateContiguity([...best, ...s], positions, hexRadius);
-                if (after > before + 1) {
-                    for (const idx of s) {
-                        const inf = infections.get(idx);
-                        if (!inf)
-                            continue;
-                        infections.set(idx, Object.assign(Object.assign({}, inf), { photo: infections.get(best[0]).photo }));
+                if (neighborTiles.length === 0) continue;
+                // Compute average neighbor tile position
+                let avgCol = 0,
+                  avgRow = 0;
+                for (const [c, r] of neighborTiles) {
+                  avgCol += c;
+                  avgRow += r;
+                }
+                avgCol /= neighborTiles.length;
+                avgRow /= neighborTiles.length;
+                // Find the tile closest to the neighbor average that's spatially near this node
+                const nodePos = positions[nodeId];
+                if (!nodePos) continue;
+                let bestAlternative = null;
+                let bestScore = Infinity;
+                // Consider tiles in a local neighborhood around current tile
+                const searchRadius = 2;
+                for (let dc = -searchRadius; dc <= searchRadius; dc++) {
+                  for (let dr = -searchRadius; dr <= searchRadius; dr++) {
+                    const candidateCol = Math.max(
+                      0,
+                      Math.min(tilesX - 1, currentTile[0] + dc)
+                    );
+                    const candidateRow = Math.max(
+                      0,
+                      Math.min(tilesY - 1, currentTile[1] + dr)
+                    );
+                    const candidate = [candidateCol, candidateRow];
+                    // Score: distance to neighbor tile average + spatial distance to tile center
+                    const tileDist = Math.hypot(
+                      candidateCol - avgCol,
+                      candidateRow - avgRow
+                    );
+                    const [cx, cy] = tileCenter(candidateCol, candidateRow);
+                    const spatialDist = Math.hypot(
+                      nodePos[0] - cx,
+                      nodePos[1] - cy
+                    );
+                    const score = tileDist * 0.7 + spatialDist * 0.3;
+                    if (score < bestScore) {
+                      bestScore = score;
+                      bestAlternative = candidate;
                     }
-                    merges++;
-                    if (debug && workerDebug.mergeLogs)
-                        console.log(`[merge] moved ${s.length} -> ${recipientId}`);
+                  }
+                }
+                // If we found a better tile and it's different from current, update
+                if (
+                  bestAlternative &&
+                  (bestAlternative[0] !== currentTile[0] ||
+                    bestAlternative[1] !== currentTile[1])
+                ) {
+                  assignment.set(nodeId, bestAlternative);
+                  adjustments++;
                 }
+              }
+              if (adjustments === 0) break; // Converged
+              console.log(
+                '[assignClusterGridPositions] Neighbor-aware refinement iteration',
+                iter + 1,
+                ':',
+                adjustments,
+                'adjustments'
+              );
             }
+          }
+          // Finally write assignments back into infections with UV bounds/inset
+          const inset = Math.max(
+            0,
+            Math.min(0.49, Number(workerDebug.clusterUvInset) || 0)
+          );
+          for (const id of cluster) {
+            const inf = infections.get(id);
+            if (!inf) continue;
+            let assignedTile = assignment.get(id) || [0, 0];
+            // Support bottom anchoring: flip the vertical tile index when 'max' is configured
+            if (workerDebug.clusterAnchor === 'max') {
+              assignedTile = [
+                assignedTile[0],
+                Math.max(0, tilesY - 1 - assignedTile[1]),
+              ];
+            }
+            let uvBounds = calculateUvBoundsFromGridPosition(
+              assignedTile[0],
+              assignedTile[1],
+              tilesX,
+              tilesY
+            );
+            if (inset > 0) {
+              const u0 = uvBounds[0],
+                v0 = uvBounds[1],
+                u1 = uvBounds[2],
+                v1 = uvBounds[3];
+              const du = (u1 - u0) * inset;
+              const dv = (v1 - v0) * inset;
+              uvBounds = [u0 + du, v0 + dv, u1 - du, v1 - dv];
+            }
+            infections.set(
+              id,
+              Object.assign(Object.assign({}, inf), {
+                gridPosition: [assignedTile[0], assignedTile[1]],
+                uvBounds,
+                tilesX,
+                tilesY,
+              })
+            );
+          }
+          console.log(
+            '[assignClusterGridPositions] Assigned grid positions to',
+            cluster.length,
+            'hexes in cluster (BFS)'
+          );
+        } catch (e) {
+          console.error(
+            '[assignClusterGridPositions] BFS assignment failed, falling back to quantization',
+            e
+          );
+          // fallback: leave previous behavior (quantization) to avoid breaking
         }
+        clusterIndex++;
+      }
     }
-    catch (e) {
-        if (debug)
-            console.warn('[merge] failed', e);
+    // Log cluster statistics
+    if (clusterSizes.length > 0) {
+      clusterSizes.sort((a, b) => b - a); // descending
+      const avgSize =
+        clusterSizes.reduce((sum, s) => sum + s, 0) / clusterSizes.length;
+      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),
+        '%)'
+      );
     }
+    console.log('[assignClusterGridPositions] Complete');
+  } catch (e) {
+    console.error('[assignClusterGridPositions] Error:', e);
+  }
+  return debugCenters;
 }
-function normalizePrevState(prevState) {
-    try {
-        if (!prevState)
-            return { infections: new Map(), availableIndices: [] };
-        let infectionsMap;
-        if (prevState.infections instanceof Map) {
-            infectionsMap = prevState.infections;
-        }
-        else if (Array.isArray(prevState.infections)) {
-            try {
-                infectionsMap = new Map(prevState.infections);
-            }
-            catch (e) {
-                infectionsMap = new Map();
-            }
-        }
-        else if (typeof prevState.infections === 'object' && prevState.infections !== null && typeof prevState.infections.entries === 'function') {
-            try {
-                infectionsMap = new Map(Array.from(prevState.infections.entries()));
+function postOptimizationMerge(
+  infections,
+  positions,
+  hexRadius,
+  debug = false
+) {
+  var _a;
+  try {
+    if (!workerDebug || !workerDebug.enableMerges) {
+      if (debug && workerDebug.mergeLogs) console.log('[merge] disabled');
+      return;
+    }
+    const threshold =
+      typeof workerDebug.mergeSmallComponentsThreshold === 'number'
+        ? workerDebug.mergeSmallComponentsThreshold
+        : 3;
+    const byPhoto = new Map();
+    for (const [idx, inf] of infections) {
+      const arr = byPhoto.get(inf.photo.id) || [];
+      arr.push(idx);
+      byPhoto.set(inf.photo.id, arr);
+    }
+    let merges = 0;
+    for (const [photoId, inds] of byPhoto) {
+      const comps = findConnectedComponents(inds, positions, hexRadius);
+      const small = comps.filter((c) => c.length > 0 && c.length <= threshold);
+      const big = comps.filter((c) => c.length > threshold);
+      if (small.length === 0 || big.length === 0) continue;
+      const bounds = getGridBounds(positions);
+      for (const s of small) {
+        let best = null;
+        let bestD = Infinity;
+        for (const b of big) {
+          let sx = 0,
+            sy = 0,
+            bx = 0,
+            by = 0;
+          for (const i of s) {
+            const p = positions[i];
+            if (p) {
+              sx += p[0];
+              sy += p[1];
             }
-            catch (e) {
-                infectionsMap = new Map();
+          }
+          for (const i of b) {
+            const p = positions[i];
+            if (p) {
+              bx += p[0];
+              by += p[1];
             }
+          }
+          const scx = sx / s.length,
+            scy = sy / s.length,
+            bcx = bx / b.length,
+            bcy = by / b.length;
+          const dx = Math.abs(scx - bcx);
+          const dy = Math.abs(scy - bcy);
+          let effDx = dx;
+          let effDy = dy;
+          if (cache.isSpherical && bounds.width > 0 && bounds.height > 0) {
+            if (effDx > bounds.width / 2) effDx = bounds.width - effDx;
+            if (effDy > bounds.height / 2) effDy = bounds.height - effDy;
+          }
+          const d = Math.sqrt(effDx * effDx + effDy * effDy);
+          if (d < bestD) {
+            bestD = d;
+            best = b;
+          }
         }
-        else {
-            infectionsMap = new Map();
+        if (!best) continue;
+        const recipientId =
+          (_a = infections.get(best[0])) === null || _a === void 0
+            ? void 0
+            : _a.photo.id;
+        if (!recipientId) continue;
+        const before = calculateContiguity(best, positions, hexRadius);
+        const after = calculateContiguity(
+          [...best, ...s],
+          positions,
+          hexRadius
+        );
+        if (after > before + 1) {
+          for (const idx of s) {
+            const inf = infections.get(idx);
+            if (!inf) continue;
+            infections.set(
+              idx,
+              Object.assign(Object.assign({}, inf), {
+                photo: infections.get(best[0]).photo,
+              })
+            );
+          }
+          merges++;
+          if (debug && workerDebug.mergeLogs)
+            console.log(`[merge] moved ${s.length} -> ${recipientId}`);
         }
-        const available = Array.isArray(prevState.availableIndices) ? prevState.availableIndices : [];
-        return { infections: infectionsMap, availableIndices: available, generation: prevState.generation };
+      }
     }
-    catch (e) {
-        safePostError(e);
-        return { infections: new Map(), availableIndices: [] };
+  } catch (e) {
+    if (debug) console.warn('[merge] failed', e);
+  }
+}
+function normalizePrevState(prevState) {
+  try {
+    if (!prevState) return { infections: new Map(), availableIndices: [] };
+    let infectionsMap;
+    if (prevState.infections instanceof Map) {
+      infectionsMap = prevState.infections;
+    } else if (Array.isArray(prevState.infections)) {
+      try {
+        infectionsMap = new Map(prevState.infections);
+      } catch (e) {
+        infectionsMap = new Map();
+      }
+    } else if (
+      typeof prevState.infections === 'object' &&
+      prevState.infections !== null &&
+      typeof prevState.infections.entries === 'function'
+    ) {
+      try {
+        infectionsMap = new Map(Array.from(prevState.infections.entries()));
+      } catch (e) {
+        infectionsMap = new Map();
+      }
+    } else {
+      infectionsMap = new Map();
     }
+    const available = Array.isArray(prevState.availableIndices)
+      ? prevState.availableIndices
+      : [];
+    return {
+      infections: infectionsMap,
+      availableIndices: available,
+      generation: prevState.generation,
+    };
+  } catch (e) {
+    safePostError(e);
+    return { infections: new Map(), availableIndices: [] };
+  }
 }
-function evolveInfectionSystem(prevState, positions, photos, hexRadius, currentTime, debug = false) {
-    var _a;
-    try {
-        console.log('[evolve] Step 1: Validating positions...');
-        if (!positions || positions.length === 0) {
-            safePostError(new Error('positions required for evolve'));
-            return null;
+function evolveInfectionSystem(
+  prevState,
+  positions,
+  photos,
+  hexRadius,
+  currentTime,
+  debug = false
+) {
+  var _a;
+  try {
+    console.log('[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...');
+    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...');
+    for (const [idx, inf] of infectionsMap) {
+      if (!inf || !inf.photo) {
+        infectionsMap.delete(idx);
+        availableSet.add(idx);
+      }
+    }
+    console.log('[evolve] Step 4: Calculating centroids...');
+    const centroids = calculatePhotoCentroids(
+      infectionsMap,
+      positions,
+      hexRadius
+    );
+    console.log('[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...'
+    );
+    // 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');
+    } else {
+      // Cell death step: allow fully surrounded cells to die and respawn for optimization
+      if (
+        workerDebug.enableCellDeath &&
+        typeof workerDebug.cellDeathProbability === 'number'
+      ) {
+        // Apply annealing rate to base death probability
+        const annealingRate =
+          typeof workerDebug.annealingRate === 'number' &&
+          workerDebug.annealingRate > 0
+            ? workerDebug.annealingRate
+            : 1.0;
+        const baseDeathProb = Math.max(
+          0,
+          Math.min(1, workerDebug.cellDeathProbability * annealingRate)
+        );
+        const mutationEnabled = !!workerDebug.enableMutation;
+        const baseMutationProb =
+          mutationEnabled && typeof workerDebug.mutationProbability === 'number'
+            ? Math.max(0, Math.min(1, workerDebug.mutationProbability))
+            : 0;
+        let deathCount = 0;
+        let mutationCount = 0;
+        let invaderExpulsions = 0;
+        // Calculate cluster sizes for mutation scaling
+        const clusterSizes = new Map();
+        for (const [_, inf] of infectionsMap) {
+          clusterSizes.set(
+            inf.photo.id,
+            (clusterSizes.get(inf.photo.id) || 0) + 1
+          );
         }
-        console.log('[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...');
         for (const [idx, inf] of infectionsMap) {
-            if (!inf || !inf.photo) {
-                infectionsMap.delete(idx);
-                availableSet.add(idx);
-            }
-        }
-        console.log('[evolve] Step 4: Calculating centroids...');
-        const centroids = calculatePhotoCentroids(infectionsMap, positions, hexRadius);
-        console.log('[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...');
-        // 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');
-        }
-        else {
-            // Cell death step: allow fully surrounded cells to die and respawn for optimization
-            if (workerDebug.enableCellDeath && typeof workerDebug.cellDeathProbability === 'number') {
-                // Apply annealing rate to base death probability
-                const annealingRate = typeof workerDebug.annealingRate === 'number' && workerDebug.annealingRate > 0
-                    ? workerDebug.annealingRate
-                    : 1.0;
-                const baseDeathProb = Math.max(0, Math.min(1, workerDebug.cellDeathProbability * annealingRate));
-                const mutationEnabled = !!workerDebug.enableMutation;
-                const baseMutationProb = mutationEnabled && typeof workerDebug.mutationProbability === 'number'
-                    ? Math.max(0, Math.min(1, workerDebug.mutationProbability))
-                    : 0;
-                let deathCount = 0;
-                let mutationCount = 0;
-                let invaderExpulsions = 0;
-                // Calculate cluster sizes for mutation scaling
-                const clusterSizes = new Map();
-                for (const [_, inf] of infectionsMap) {
-                    clusterSizes.set(inf.photo.id, (clusterSizes.get(inf.photo.id) || 0) + 1);
-                }
-                for (const [idx, inf] of infectionsMap) {
-                    const neighbors = getNeighborsCached(idx, positions, hexRadius);
-                    const totalNeighbors = neighbors.length;
-                    // Count neighbors with the same photo (affinity)
-                    const samePhotoNeighbors = neighbors.filter(n => {
-                        const nInf = newInfections.get(n);
-                        return nInf && nInf.photo.id === inf.photo.id;
-                    });
-                    // Calculate affinity ratio: 1.0 = all same photo, 0.0 = none same photo
-                    const affinityRatio = totalNeighbors > 0 ? samePhotoNeighbors.length / totalNeighbors : 0;
-                    // Count hostile (different photo) neighbors and diversity
-                    const hostileNeighbors = totalNeighbors - samePhotoNeighbors.length;
-                    const hostileRatio = totalNeighbors > 0 ? hostileNeighbors / totalNeighbors : 0;
-                    // Calculate diversity: how many unique different photo types surround this cell
-                    const uniqueHostilePhotos = new Set();
-                    for (const n of neighbors) {
-                        const nInf = newInfections.get(n);
-                        if (nInf && nInf.photo.id !== inf.photo.id) {
-                            uniqueHostilePhotos.add(nInf.photo.id);
-                        }
-                    }
-                    const diversityCount = uniqueHostilePhotos.size;
-                    const maxDiversity = 6; // hex grid max neighbors
-                    const diversityRatio = diversityCount / maxDiversity;
-                    // Affinity-adjusted death probability with boundary pressure:
-                    // - High affinity (well-integrated) = low death rate
-                    // - Low affinity (invader) = high death rate
-                    // - Partial hostile neighbors = MUCH higher death rate (boundary warfare)
-                    // - Solitary cells = VERY high death rate
-                    // 
-                    // Base formula: deathProb = baseDeathProb * (1 - affinityRatio)^2
-                    // Boundary pressure: if 1-5 hostile neighbors, apply exponential penalty
-                    let affinityPenalty = Math.pow(1 - affinityRatio, 2);
-                    // Solitary cell penalty: cells with 0-1 same neighbors are extremely vulnerable
-                    // Diversity amplifies this: being alone among many different photos is worst case
-                    if (samePhotoNeighbors.length <= 1) {
-                        // Base 10x penalty, increased by diversity: 2-6 different neighbors = 1.5x-3x additional multiplier
-                        // Formula: 10 × (1 + diversityRatio × 2)
-                        // 1 hostile type: 10x penalty
-                        // 3 hostile types (50% diversity): 20x penalty  
-                        // 6 hostile types (100% diversity): 30x penalty
-                        const diversityPenalty = 1 + diversityRatio * 2;
-                        affinityPenalty *= (10 * diversityPenalty);
-                    }
-                    // Boundary warfare multiplier: cells partially surrounded by enemies are in danger
-                    if (hostileNeighbors > 0 && hostileNeighbors < totalNeighbors) {
-                        // Peak danger at 50% hostile (3/6 neighbors): apply up to 4x multiplier
-                        // Formula: 1 + 3 * sin(hostileRatio * π) creates a bell curve peaking at 0.5
-                        const boundaryPressure = 1 + 3 * Math.sin(hostileRatio * Math.PI);
-                        affinityPenalty *= boundaryPressure;
-                    }
-                    const adjustedDeathProb = Math.min(1, baseDeathProb * affinityPenalty);
-                    // Calculate mutation probability based on cluster size and virility
-                    // Larger, more popular clusters spawn more mutations
-                    let mutationProb = baseMutationProb;
-                    if (mutationEnabled && photos.length > 1) {
-                        const clusterSize = clusterSizes.get(inf.photo.id) || 1;
-                        const velocity = typeof inf.photo.velocity === 'number' ? inf.photo.velocity : 0;
-                        // Cluster size multiplier: larger clusters spawn more mutations (1-100 cells → 1x-10x)
-                        const clusterMultiplier = Math.min(10, Math.log10(clusterSize + 1) + 1);
-                        // Virility multiplier: popular photos spawn more mutations (0-100 velocity → 1x-3x)
-                        const virilityMultiplier = 1 + (Math.min(100, Math.max(0, velocity)) / 100) * 2;
-                        // Combined mutation rate
-                        mutationProb = Math.min(1, baseMutationProb * clusterMultiplier * virilityMultiplier);
-                    }
-                    // Only consider cells with at least some neighbors (avoid isolated cells)
-                    if (totalNeighbors >= 1 && Math.random() < adjustedDeathProb) {
-                        const isInvader = affinityRatio < 0.5; // Less than half neighbors are same photo
-                        // Check for mutation: respawn as a different photo instead of just dying
-                        if (mutationEnabled && Math.random() < mutationProb && photos.length > 1) {
-                            // Pick a random photo from the pool that's different from current
-                            const otherPhotos = photos.filter(p => p.id !== inf.photo.id);
-                            if (otherPhotos.length > 0) {
-                                const newPhoto = otherPhotos[Math.floor(Math.random() * otherPhotos.length)];
-                                const tilesX = 4;
-                                const tilesY = 4;
-                                const uvBounds = calculateUvBoundsFromGridPosition(0, 0, tilesX, tilesY);
-                                // Mutate: replace with new photo instead of dying
-                                newInfections.set(idx, {
-                                    photo: newPhoto,
-                                    gridPosition: [0, 0],
-                                    infectionTime: currentTime,
-                                    generation,
-                                    uvBounds: uvBounds,
-                                    scale: 0.4,
-                                    growthRate: 0.08,
-                                    tilesX: tilesX,
-                                    tilesY: tilesY
-                                });
-                                mutationCount++;
-                            }
-                            else {
-                                // No other photos available, just die normally
-                                newInfections.delete(idx);
-                                newAvailable.add(idx);
-                                deathCount++;
-                            }
-                        }
-                        else {
-                            // Normal death: remove and make available for respawn
-                            newInfections.delete(idx);
-                            newAvailable.add(idx);
-                            deathCount++;
-                            if (isInvader)
-                                invaderExpulsions++;
-                        }
-                    }
-                }
-                if (deathCount > 0 || mutationCount > 0 || invaderExpulsions > 0) {
-                    console.log('[evolve]   Cell death: removed', deathCount, 'cells (', invaderExpulsions, 'invaders expelled), mutated', mutationCount, 'cells');
-                }
+          const neighbors = getNeighborsCached(idx, positions, hexRadius);
+          const totalNeighbors = neighbors.length;
+          // Count neighbors with the same photo (affinity)
+          const samePhotoNeighbors = neighbors.filter((n) => {
+            const nInf = newInfections.get(n);
+            return nInf && nInf.photo.id === inf.photo.id;
+          });
+          // Calculate affinity ratio: 1.0 = all same photo, 0.0 = none same photo
+          const affinityRatio =
+            totalNeighbors > 0 ? samePhotoNeighbors.length / totalNeighbors : 0;
+          // Count hostile (different photo) neighbors and diversity
+          const hostileNeighbors = totalNeighbors - samePhotoNeighbors.length;
+          const hostileRatio =
+            totalNeighbors > 0 ? hostileNeighbors / totalNeighbors : 0;
+          // Calculate diversity: how many unique different photo types surround this cell
+          const uniqueHostilePhotos = new Set();
+          for (const n of neighbors) {
+            const nInf = newInfections.get(n);
+            if (nInf && nInf.photo.id !== inf.photo.id) {
+              uniqueHostilePhotos.add(nInf.photo.id);
             }
-            // Growth step: prefer neighbors that increase contiguity and are closer to centroids
-            let growthIterations = 0;
-            for (const [idx, inf] of infectionsMap) {
-                growthIterations++;
-                if (growthIterations % 10 === 0)
-                    console.log('[evolve]   Growth iteration', growthIterations, '/', infectionsMap.size);
-                const neighbors = getNeighborsCached(idx, positions, hexRadius);
-                for (const n of neighbors) {
-                    if (!newAvailable.has(n))
-                        continue;
-                    let base = 0.5; // BOOSTED from 0.3 to encourage more aggressive growth
-                    const sameNeighbors = getNeighborsCached(n, positions, hexRadius).filter(x => newInfections.has(x) && newInfections.get(x).photo.id === inf.photo.id).length;
-                    if (sameNeighbors >= 2)
-                        base = 0.95;
-                    else if (sameNeighbors === 1)
-                        base = 0.75; // BOOSTED to favor contiguous growth
-                    // Virility boost: photos with higher velocity (upvotes/engagement) grow faster
-                    if (workerDebug.enableVirilityBoost && typeof inf.photo.velocity === 'number' && inf.photo.velocity > 0) {
-                        const virilityMult = typeof workerDebug.virilityMultiplier === 'number' ? workerDebug.virilityMultiplier : 1.0;
-                        // Normalize velocity to a 0-1 range (assuming velocity is already normalized or 0-100)
-                        // Then apply as a percentage boost: velocity=100 -> 100% boost (2x), velocity=50 -> 50% boost (1.5x)
-                        const normalizedVelocity = Math.min(1, Math.max(0, inf.photo.velocity / 100));
-                        const virilityBoost = 1 + (normalizedVelocity * virilityMult);
-                        base *= virilityBoost;
-                    }
-                    // Centroid cohesion bias
-                    try {
-                        const cList = centroids.get(inf.photo.id) || [];
-                        if (cList.length > 0) {
-                            const bounds = getGridBounds(positions);
-                            let minD = Infinity;
-                            const p = positions[n];
-                            for (const c of cList) {
-                                const dx = Math.abs(p[0] - c[0]);
-                                const dy = Math.abs(p[1] - c[1]);
-                                let effDx = dx;
-                                let effDy = dy;
-                                if (cache.isSpherical && bounds.width > 0 && bounds.height > 0) {
-                                    if (effDx > bounds.width / 2)
-                                        effDx = bounds.width - effDx;
-                                    if (effDy > bounds.height / 2)
-                                        effDy = bounds.height - effDy;
-                                }
-                                const d = Math.sqrt(effDx * effDx + effDy * effDy);
-                                if (d < minD)
-                                    minD = d;
-                            }
-                            const radius = Math.max(1, hexRadius * 3);
-                            const distFactor = Math.max(0, Math.min(1, 1 - (minD / radius)));
-                            const boost = typeof workerDebug.cohesionBoost === 'number' ? workerDebug.cohesionBoost : 0.6;
-                            base *= (1 + distFactor * boost);
-                        }
-                    }
-                    catch (e) {
-                        if (debug)
-                            console.warn('cohesion calc failed', e);
-                    }
-                    if (Math.random() < Math.min(0.999, base)) {
-                        const tilesX = inf.tilesX || 4;
-                        const tilesY = inf.tilesY || 4;
-                        const uvBounds = calculateUvBoundsFromGridPosition(0, 0, tilesX, tilesY);
-                        newInfections.set(n, { photo: inf.photo, gridPosition: [0, 0], infectionTime: currentTime, generation, uvBounds: uvBounds, scale: 0.4, growthRate: inf.growthRate || 0.08, tilesX: tilesX, tilesY: tilesY });
-                        newAvailable.delete(n);
-                    }
-                }
+          }
+          const diversityCount = uniqueHostilePhotos.size;
+          const maxDiversity = 6; // hex grid max neighbors
+          const diversityRatio = diversityCount / maxDiversity;
+          // Affinity-adjusted death probability with boundary pressure:
+          // - High affinity (well-integrated) = low death rate
+          // - Low affinity (invader) = high death rate
+          // - Partial hostile neighbors = MUCH higher death rate (boundary warfare)
+          // - Solitary cells = VERY high death rate
+          //
+          // Base formula: deathProb = baseDeathProb * (1 - affinityRatio)^2
+          // Boundary pressure: if 1-5 hostile neighbors, apply exponential penalty
+          let affinityPenalty = Math.pow(1 - affinityRatio, 2);
+          // Solitary cell penalty: cells with 0-1 same neighbors are extremely vulnerable
+          // Diversity amplifies this: being alone among many different photos is worst case
+          if (samePhotoNeighbors.length <= 1) {
+            // Base 10x penalty, increased by diversity: 2-6 different neighbors = 1.5x-3x additional multiplier
+            // Formula: 10 × (1 + diversityRatio × 2)
+            // 1 hostile type: 10x penalty
+            // 3 hostile types (50% diversity): 20x penalty
+            // 6 hostile types (100% diversity): 30x penalty
+            const diversityPenalty = 1 + diversityRatio * 2;
+            affinityPenalty *= 10 * diversityPenalty;
+          }
+          // Boundary warfare multiplier: cells partially surrounded by enemies are in danger
+          if (hostileNeighbors > 0 && hostileNeighbors < totalNeighbors) {
+            // Peak danger at 50% hostile (3/6 neighbors): apply up to 4x multiplier
+            // Formula: 1 + 3 * sin(hostileRatio * π) creates a bell curve peaking at 0.5
+            const boundaryPressure = 1 + 3 * Math.sin(hostileRatio * Math.PI);
+            affinityPenalty *= boundaryPressure;
+          }
+          const adjustedDeathProb = Math.min(
+            1,
+            baseDeathProb * affinityPenalty
+          );
+          // Calculate mutation probability based on cluster size and virility
+          // Larger, more popular clusters spawn more mutations
+          let mutationProb = baseMutationProb;
+          if (mutationEnabled && photos.length > 1) {
+            const clusterSize = clusterSizes.get(inf.photo.id) || 1;
+            const velocity =
+              typeof inf.photo.velocity === 'number' ? inf.photo.velocity : 0;
+            // Cluster size multiplier: larger clusters spawn more mutations (1-100 cells → 1x-10x)
+            const clusterMultiplier = Math.min(
+              10,
+              Math.log10(clusterSize + 1) + 1
+            );
+            // Virility multiplier: popular photos spawn more mutations (0-100 velocity → 1x-3x)
+            const virilityMultiplier =
+              1 + (Math.min(100, Math.max(0, velocity)) / 100) * 2;
+            // Combined mutation rate
+            mutationProb = Math.min(
+              1,
+              baseMutationProb * clusterMultiplier * virilityMultiplier
+            );
+          }
+          // Only consider cells with at least some neighbors (avoid isolated cells)
+          if (totalNeighbors >= 1 && Math.random() < adjustedDeathProb) {
+            const isInvader = affinityRatio < 0.5; // Less than half neighbors are same photo
+            // Check for mutation: respawn as a different photo instead of just dying
+            if (
+              mutationEnabled &&
+              Math.random() < mutationProb &&
+              photos.length > 1
+            ) {
+              // Pick a random photo from the pool that's different from current
+              const otherPhotos = photos.filter((p) => p.id !== inf.photo.id);
+              if (otherPhotos.length > 0) {
+                const newPhoto =
+                  otherPhotos[Math.floor(Math.random() * otherPhotos.length)];
+                const tilesX = 4;
+                const tilesY = 4;
+                const uvBounds = calculateUvBoundsFromGridPosition(
+                  0,
+                  0,
+                  tilesX,
+                  tilesY
+                );
+                // Mutate: replace with new photo instead of dying
+                newInfections.set(idx, {
+                  photo: newPhoto,
+                  gridPosition: [0, 0],
+                  infectionTime: currentTime,
+                  generation,
+                  uvBounds: uvBounds,
+                  scale: 0.4,
+                  growthRate: 0.08,
+                  tilesX: tilesX,
+                  tilesY: tilesY,
+                });
+                mutationCount++;
+              } else {
+                // No other photos available, just die normally
+                newInfections.delete(idx);
+                newAvailable.add(idx);
+                deathCount++;
+              }
+            } else {
+              // Normal death: remove and make available for respawn
+              newInfections.delete(idx);
+              newAvailable.add(idx);
+              deathCount++;
+              if (isInvader) invaderExpulsions++;
             }
+          }
         }
-        console.log('[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');
+        if (deathCount > 0 || mutationCount > 0 || invaderExpulsions > 0) {
+          console.log(
+            '[evolve]   Cell death: removed',
+            deathCount,
+            'cells (',
+            invaderExpulsions,
+            'invaders expelled), mutated',
+            mutationCount,
+            'cells'
+          );
         }
-        else {
-            // Deterministic fill for holes with >=2 same-photo neighbors
-            let fillIterations = 0;
-            for (const a of Array.from(newAvailable)) {
-                fillIterations++;
-                if (fillIterations % 50 === 0)
-                    console.log('[evolve]   Fill iteration', fillIterations, '/', newAvailable.size);
-                const neighbors = getNeighborsCached(a, positions, hexRadius);
-                const counts = new Map();
-                for (const n of neighbors) {
-                    const inf = newInfections.get(n);
-                    if (!inf)
-                        continue;
-                    counts.set(inf.photo.id, (counts.get(inf.photo.id) || 0) + 1);
-                }
-                let bestId;
-                let best = 0;
-                for (const [pid, c] of counts)
-                    if (c > best) {
-                        best = c;
-                        bestId = pid;
-                    }
-                if (bestId && best >= 2) {
-                    const src = photos.find(p => p.id === bestId) || ((_a = Array.from(infectionsMap.values())[0]) === null || _a === void 0 ? void 0 : _a.photo);
-                    if (src) {
-                        const tilesX = 4;
-                        const tilesY = 4;
-                        const uvBounds = calculateUvBoundsFromGridPosition(0, 0, tilesX, tilesY);
-                        newInfections.set(a, { photo: src, gridPosition: [0, 0], infectionTime: currentTime, generation, uvBounds: uvBounds, scale: 0.35, growthRate: 0.08, tilesX: tilesX, tilesY: tilesY });
-                        newAvailable.delete(a);
-                    }
+      }
+      // Growth step: prefer neighbors that increase contiguity and are closer to centroids
+      let growthIterations = 0;
+      for (const [idx, inf] of infectionsMap) {
+        growthIterations++;
+        if (growthIterations % 10 === 0)
+          console.log(
+            '[evolve]   Growth iteration',
+            growthIterations,
+            '/',
+            infectionsMap.size
+          );
+        const neighbors = getNeighborsCached(idx, positions, hexRadius);
+        for (const n of neighbors) {
+          if (!newAvailable.has(n)) continue;
+          let base = 0.5; // BOOSTED from 0.3 to encourage more aggressive growth
+          const sameNeighbors = getNeighborsCached(
+            n,
+            positions,
+            hexRadius
+          ).filter(
+            (x) =>
+              newInfections.has(x) &&
+              newInfections.get(x).photo.id === inf.photo.id
+          ).length;
+          if (sameNeighbors >= 2) base = 0.95;
+          else if (sameNeighbors === 1) base = 0.75; // BOOSTED to favor contiguous growth
+          // Virility boost: photos with higher velocity (upvotes/engagement) grow faster
+          if (
+            workerDebug.enableVirilityBoost &&
+            typeof inf.photo.velocity === 'number' &&
+            inf.photo.velocity > 0
+          ) {
+            const virilityMult =
+              typeof workerDebug.virilityMultiplier === 'number'
+                ? workerDebug.virilityMultiplier
+                : 1.0;
+            // Normalize velocity to a 0-1 range (assuming velocity is already normalized or 0-100)
+            // Then apply as a percentage boost: velocity=100 -> 100% boost (2x), velocity=50 -> 50% boost (1.5x)
+            const normalizedVelocity = Math.min(
+              1,
+              Math.max(0, inf.photo.velocity / 100)
+            );
+            const virilityBoost = 1 + normalizedVelocity * virilityMult;
+            base *= virilityBoost;
+          }
+          // Centroid cohesion bias
+          try {
+            const cList = centroids.get(inf.photo.id) || [];
+            if (cList.length > 0) {
+              const bounds = getGridBounds(positions);
+              let minD = Infinity;
+              const p = positions[n];
+              for (const c of cList) {
+                const dx = Math.abs(p[0] - c[0]);
+                const dy = Math.abs(p[1] - c[1]);
+                let effDx = dx;
+                let effDy = dy;
+                if (
+                  cache.isSpherical &&
+                  bounds.width > 0 &&
+                  bounds.height > 0
+                ) {
+                  if (effDx > bounds.width / 2) effDx = bounds.width - effDx;
+                  if (effDy > bounds.height / 2) effDy = bounds.height - effDy;
                 }
+                const d = Math.sqrt(effDx * effDx + effDy * effDy);
+                if (d < minD) minD = d;
+              }
+              const radius = Math.max(1, hexRadius * 3);
+              const distFactor = Math.max(0, Math.min(1, 1 - minD / radius));
+              const boost =
+                typeof workerDebug.cohesionBoost === 'number'
+                  ? workerDebug.cohesionBoost
+                  : 0.6;
+              base *= 1 + distFactor * boost;
             }
+          } catch (e) {
+            if (debug) console.warn('cohesion calc failed', e);
+          }
+          if (Math.random() < Math.min(0.999, base)) {
+            const tilesX = inf.tilesX || 4;
+            const tilesY = inf.tilesY || 4;
+            const uvBounds = calculateUvBoundsFromGridPosition(
+              0,
+              0,
+              tilesX,
+              tilesY
+            );
+            newInfections.set(n, {
+              photo: inf.photo,
+              gridPosition: [0, 0],
+              infectionTime: currentTime,
+              generation,
+              uvBounds: uvBounds,
+              scale: 0.4,
+              growthRate: inf.growthRate || 0.08,
+              tilesX: tilesX,
+              tilesY: tilesY,
+            });
+            newAvailable.delete(n);
+          }
         }
-        console.log('[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...');
-        // 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);
-        return { infections: newInfections, availableIndices: Array.from(newAvailable), lastEvolutionTime: currentTime, generation, tileCenters };
+      }
     }
-    catch (e) {
-        safePostError(e);
-        return null;
+    console.log(
+      '[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'
+      );
+    } else {
+      // Deterministic fill for holes with >=2 same-photo neighbors
+      let fillIterations = 0;
+      for (const a of Array.from(newAvailable)) {
+        fillIterations++;
+        if (fillIterations % 50 === 0)
+          console.log(
+            '[evolve]   Fill iteration',
+            fillIterations,
+            '/',
+            newAvailable.size
+          );
+        const neighbors = getNeighborsCached(a, positions, hexRadius);
+        const counts = new Map();
+        for (const n of neighbors) {
+          const inf = newInfections.get(n);
+          if (!inf) continue;
+          counts.set(inf.photo.id, (counts.get(inf.photo.id) || 0) + 1);
+        }
+        let bestId;
+        let best = 0;
+        for (const [pid, c] of counts)
+          if (c > best) {
+            best = c;
+            bestId = pid;
+          }
+        if (bestId && best >= 2) {
+          const src =
+            photos.find((p) => p.id === bestId) ||
+            ((_a = Array.from(infectionsMap.values())[0]) === null ||
+            _a === void 0
+              ? void 0
+              : _a.photo);
+          if (src) {
+            const tilesX = 4;
+            const tilesY = 4;
+            const uvBounds = calculateUvBoundsFromGridPosition(
+              0,
+              0,
+              tilesX,
+              tilesY
+            );
+            newInfections.set(a, {
+              photo: src,
+              gridPosition: [0, 0],
+              infectionTime: currentTime,
+              generation,
+              uvBounds: uvBounds,
+              scale: 0.35,
+              growthRate: 0.08,
+              tilesX: tilesX,
+              tilesY: tilesY,
+            });
+            newAvailable.delete(a);
+          }
+        }
+      }
     }
+    console.log('[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...');
+    // 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
+    );
+    return {
+      infections: newInfections,
+      availableIndices: Array.from(newAvailable),
+      lastEvolutionTime: currentTime,
+      generation,
+      tileCenters,
+    };
+  } catch (e) {
+    safePostError(e);
+    return null;
+  }
 }
 let lastEvolutionAt = 0;
 function mergeDebugFromPayload(d) {
-    if (!d || typeof d !== 'object')
-        return;
-    // Map main-thread naming (evolveIntervalMs) into worker's evolutionIntervalMs
-    if (typeof d.evolveIntervalMs === 'number')
-        d.evolutionIntervalMs = d.evolveIntervalMs;
-    // Merge into workerDebug
-    try {
-        Object.assign(workerDebug, d);
-    }
-    catch (e) { }
+  if (!d || typeof d !== 'object') return;
+  // Map main-thread naming (evolveIntervalMs) into worker's evolutionIntervalMs
+  if (typeof d.evolveIntervalMs === 'number')
+    d.evolutionIntervalMs = d.evolveIntervalMs;
+  // Merge into workerDebug
+  try {
+    Object.assign(workerDebug, d);
+  } catch (e) {}
 }
 self.onmessage = function (ev) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-    const raw = ev.data;
-    try {
-        if (!raw || typeof raw !== 'object')
-            return;
-        const type = raw.type;
-        const payload = (_a = raw.data) !== null && _a !== void 0 ? _a : raw;
-        if (type === 'setDataAndConfig' || type === 'setDebug') {
-            // Accept either { type:'setDataAndConfig', data: { photos, debug } } or { type:'setDebug', debug }
-            const dbg = (_c = (_b = payload.debug) !== null && _b !== void 0 ? _b : raw.debug) !== null && _c !== void 0 ? _c : payload;
-            mergeDebugFromPayload(dbg);
-            // Pre-build neighbor cache if positions are provided
-            if (type === 'setDataAndConfig') {
-                const incomingIsSpherical = typeof payload.isSpherical === 'boolean' ? Boolean(payload.isSpherical) : cache.isSpherical;
-                const shouldUpdateTopology = typeof payload.isSpherical === 'boolean' && incomingIsSpherical !== cache.isSpherical;
-                if (shouldUpdateTopology)
-                    invalidateCaches(incomingIsSpherical);
-                else
-                    invalidateCaches();
-                const positions = payload.positions;
-                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...');
-                const startTime = Date.now();
-                // Build ALL neighbor relationships in one O(n²) pass instead of n×O(n) passes
-                try {
-                    const bounds = getGridBounds(positions);
-                    const threshold = Math.sqrt(3) * hexRadius * 1.15;
-                    const isSpherical = !!cache.isSpherical;
-                    // Initialize empty arrays for all positions
-                    for (let i = 0; i < positions.length; i++) {
-                        cache.neighborMap.set(i, []);
-                    }
-                    // Single pass: check each pair once and add bidirectional neighbors
-                    for (let i = 0; i < positions.length; i++) {
-                        const pos1 = positions[i];
-                        if (!pos1)
-                            continue;
-                        // Only check j > i to avoid duplicate checks
-                        for (let j = i + 1; j < positions.length; j++) {
-                            const pos2 = positions[j];
-                            if (!pos2)
-                                continue;
-                            const d = distanceBetween(pos1, pos2, bounds, isSpherical);
-                            if (d <= threshold) {
-                                // Add bidirectional neighbors
-                                cache.neighborMap.get(i).push(j);
-                                cache.neighborMap.get(j).push(i);
-                            }
-                        }
-                        // Log progress every 100 positions
-                        if ((i + 1) % 100 === 0) {
-                            console.log('[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!');
-                    // Mark cache as ready
-                    cache.cacheReady = true;
-                    // Notify main thread that cache is ready
-                    try {
-                        self.postMessage({ type: 'cache-ready', data: { elapsed, positions: positions.length } });
-                    }
-                    catch (e) { }
-                }
-                catch (e) {
-                    console.error('[hexgrid-worker] Error during cache pre-build:', e);
-                    // Mark cache as ready anyway to allow evolution to proceed
-                    cache.cacheReady = true;
-                }
-            }
-            return;
-        }
-        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...');
-                // Defer this evolve message by re-posting it after a short delay
-                setTimeout(() => {
-                    try {
-                        self.postMessage({ type: 'deferred-evolve', data: { reason: 'cache-not-ready' } });
-                    }
-                    catch (e) { }
-                    // Re-process the message
-                    self.onmessage(ev);
-                }, 100);
-                return;
-            }
-            // Normalize payload shape: support { data: { prevState, positions, photos, hexRadius, debug } }
-            mergeDebugFromPayload(payload.debug || payload);
-            // 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);
-                }
-            }
-            catch (e) { }
-            const now = Date.now();
-            const interval = typeof workerDebug.evolutionIntervalMs === 'number' ? workerDebug.evolutionIntervalMs : (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));
-            // 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', { interval, lastEvolutionAt, now, diff: now - lastEvolutionAt, willThrottle: (!bypassThrottle && (now - lastEvolutionAt < interval)), reason, bypassThrottle });
-            // 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');
-                if (workerDebug && workerDebug.debugLogs) {
-                    try {
-                        self.postMessage({ type: 'throttled-evolve', data: { receivedAt: now, nextAvailableAt: lastEvolutionAt + interval, payloadKeys: Object.keys(payload || {}), reason } });
-                    }
-                    catch (e) { }
-                }
-                return;
-            }
-            // Mark processed time and send ack for an evolve we will process
-            lastEvolutionAt = now;
-            console.log('[hexgrid-worker] ✅ PROCESSING evolution - lastEvolutionAt updated to', now);
-            try {
-                if (workerDebug && workerDebug.debugLogs) {
-                    try {
-                        self.postMessage({ type: 'ack-evolve', data: { receivedAt: now, payloadKeys: Object.keys(payload || {}) } });
-                    }
-                    catch (e) { }
-                }
-            }
-            catch (e) { }
-            // Emit a lightweight processing marker so the client can see evolve processing started
-            try {
-                if (workerDebug && workerDebug.debugLogs) {
-                    try {
-                        self.postMessage({ type: 'processing-evolve', data: { startedAt: now, payloadKeys: Object.keys(payload || {}) } });
-                    }
-                    catch (e) { }
-                }
-            }
-            catch (e) { }
-            const state = (_f = (_e = (_d = payload.prevState) !== null && _d !== void 0 ? _d : payload.state) !== null && _e !== void 0 ? _e : raw.state) !== null && _f !== void 0 ? _f : null;
-            const positions = (_h = (_g = payload.positions) !== null && _g !== void 0 ? _g : raw.positions) !== null && _h !== void 0 ? _h : [];
-            const photos = (_k = (_j = payload.photos) !== null && _j !== void 0 ? _j : raw.photos) !== null && _k !== void 0 ? _k : [];
-            const hexRadius = typeof payload.hexRadius === 'number' ? payload.hexRadius : (typeof raw.hexRadius === 'number' ? raw.hexRadius : 16);
-            if (typeof payload.isSpherical === 'boolean' && Boolean(payload.isSpherical) !== cache.isSpherical) {
-                invalidateCaches(Boolean(payload.isSpherical));
-            }
-            console.log('[hexgrid-worker] 🔧 About to call evolveInfectionSystem');
-            console.log('[hexgrid-worker]   - state generation:', state === null || state === void 0 ? void 0 : state.generation);
-            console.log('[hexgrid-worker]   - state infections:', ((_l = state === null || state === void 0 ? void 0 : state.infections) === null || _l === void 0 ? void 0 : _l.length) || ((_m = state === null || state === void 0 ? void 0 : state.infections) === null || _m === void 0 ? void 0 : _m.size) || 0);
-            console.log('[hexgrid-worker]   - positions:', (positions === null || positions === void 0 ? void 0 : positions.length) || 0);
-            console.log('[hexgrid-worker]   - photos:', (photos === null || photos === void 0 ? void 0 : photos.length) || 0);
-            console.log('[hexgrid-worker]   - hexRadius:', hexRadius);
-            let res;
-            let timeoutId;
-            let timedOut = false;
-            // Set a watchdog timer to detect hangs (10 seconds)
-            timeoutId = setTimeout(() => {
-                timedOut = true;
-                console.error('[hexgrid-worker] ⏱️ TIMEOUT: evolveInfectionSystem is taking too long (>10s)! Possible infinite loop.');
-                try {
-                    self.postMessage({ type: 'error', error: 'Evolution timeout - possible infinite loop' });
-                }
-                catch (e) { }
-            }, 10000);
-            try {
-                console.log('[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');
-            }
-            catch (err) {
-                clearTimeout(timeoutId);
-                console.error('[hexgrid-worker] ❌ FATAL: evolveInfectionSystem threw an error:', err);
-                console.error('[hexgrid-worker] Error stack:', err instanceof Error ? err.stack : 'no stack');
-                safePostError(err);
-                return;
-            }
-            if (timedOut) {
-                console.error('[hexgrid-worker] ⏱️ Function eventually returned but after timeout was triggered');
-            }
-            if (!res) {
-                console.log('[hexgrid-worker] ❌ evolveInfectionSystem returned null!');
-                return;
-            }
-            console.log('[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 };
-                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');
-                }
-                self.postMessage({ type: 'evolved', data: payload });
-                // Record posted generation/infection count so later auto-triggers can avoid regressing
-                try {
-                    cache.lastGeneration = res.generation;
-                    cache.lastInfectionCount = res.infections ? res.infections.size : 0;
-                }
-                catch (e) { }
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+  const raw = ev.data;
+  try {
+    if (!raw || typeof raw !== 'object') return;
+    const type = raw.type;
+    const payload = (_a = raw.data) !== null && _a !== void 0 ? _a : raw;
+    if (type === 'setDataAndConfig' || type === 'setDebug') {
+      // Accept either { type:'setDataAndConfig', data: { photos, debug } } or { type:'setDebug', debug }
+      const dbg =
+        (_c =
+          (_b = payload.debug) !== null && _b !== void 0 ? _b : raw.debug) !==
+          null && _c !== void 0
+          ? _c
+          : payload;
+      mergeDebugFromPayload(dbg);
+      // Pre-build neighbor cache if positions are provided
+      if (type === 'setDataAndConfig') {
+        const incomingIsSpherical =
+          typeof payload.isSpherical === 'boolean'
+            ? Boolean(payload.isSpherical)
+            : cache.isSpherical;
+        const shouldUpdateTopology =
+          typeof payload.isSpherical === 'boolean' &&
+          incomingIsSpherical !== cache.isSpherical;
+        if (shouldUpdateTopology) invalidateCaches(incomingIsSpherical);
+        else invalidateCaches();
+        const positions = payload.positions;
+        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...'
+        );
+        const startTime = Date.now();
+        // Build ALL neighbor relationships in one O(n²) pass instead of n×O(n) passes
+        try {
+          const bounds = getGridBounds(positions);
+          const threshold = Math.sqrt(3) * hexRadius * 1.15;
+          const isSpherical = !!cache.isSpherical;
+          // Initialize empty arrays for all positions
+          for (let i = 0; i < positions.length; i++) {
+            cache.neighborMap.set(i, []);
+          }
+          // Single pass: check each pair once and add bidirectional neighbors
+          for (let i = 0; i < positions.length; i++) {
+            const pos1 = positions[i];
+            if (!pos1) continue;
+            // Only check j > i to avoid duplicate checks
+            for (let j = i + 1; j < positions.length; j++) {
+              const pos2 = positions[j];
+              if (!pos2) continue;
+              const d = distanceBetween(pos1, pos2, bounds, isSpherical);
+              if (d <= threshold) {
+                // Add bidirectional neighbors
+                cache.neighborMap.get(i).push(j);
+                cache.neighborMap.get(j).push(i);
+              }
             }
-            catch (e) {
-                console.error('[hexgrid-worker] ❌ Failed to post evolved message:', e);
+            // Log progress every 100 positions
+            if ((i + 1) % 100 === 0) {
+              console.log(
+                '[hexgrid-worker]   Processed',
+                i + 1,
+                '/',
+                positions.length,
+                'positions'
+              );
             }
-            console.log('[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) {
-                    try {
-                        self.postMessage({ type: 'evolved-complete', data: { finishedAt: Date.now(), generation: res.generation, lastEvolutionTime: res.lastEvolutionTime } });
-                    }
-                    catch (e) { }
-                }
-            }
-            catch (e) { }
-            return;
-        }
-        if (type === 'optimize') {
-            try {
-                const infectionsArr = payload.infections || raw.infections || [];
-                const infections = new Map(infectionsArr);
-                const positions = (_o = payload.positions) !== null && _o !== void 0 ? _o : raw.positions;
-                const hexRadius = typeof payload.hexRadius === 'number' ? payload.hexRadius : (typeof raw.hexRadius === 'number' ? raw.hexRadius : 16);
-                postOptimizationMerge(infections, positions, hexRadius, !!workerDebug.mergeLogs);
-                try {
-                    self.postMessage({ type: 'optimized', data: { infections: Array.from(infections.entries()) } });
-                }
-                catch (e) { }
-            }
-            catch (e) {
-                safePostError(e);
-            }
-            return;
+          }
+          const elapsed = Date.now() - startTime;
+          console.log(
+            '[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
+          try {
+            self.postMessage({
+              type: 'cache-ready',
+              data: { elapsed, positions: positions.length },
+            });
+          } catch (e) {}
+        } catch (e) {
+          console.error('[hexgrid-worker] Error during cache pre-build:', e);
+          // Mark cache as ready anyway to allow evolution to proceed
+          cache.cacheReady = true;
         }
+      }
+      return;
     }
-    catch (err) {
+    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...'
+        );
+        // Defer this evolve message by re-posting it after a short delay
+        setTimeout(() => {
+          try {
+            self.postMessage({
+              type: 'deferred-evolve',
+              data: { reason: 'cache-not-ready' },
+            });
+          } catch (e) {}
+          // Re-process the message
+          self.onmessage(ev);
+        }, 100);
+        return;
+      }
+      // Normalize payload shape: support { data: { prevState, positions, photos, hexRadius, debug } }
+      mergeDebugFromPayload(payload.debug || payload);
+      // 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
+          );
+        }
+      } catch (e) {}
+      const now = Date.now();
+      const interval =
+        typeof workerDebug.evolutionIntervalMs === 'number'
+          ? workerDebug.evolutionIntervalMs
+          : 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
+      );
+      // 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', {
+        interval,
+        lastEvolutionAt,
+        now,
+        diff: now - lastEvolutionAt,
+        willThrottle: !bypassThrottle && now - lastEvolutionAt < interval,
+        reason,
+        bypassThrottle,
+      });
+      // 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'
+        );
+        if (workerDebug && workerDebug.debugLogs) {
+          try {
+            self.postMessage({
+              type: 'throttled-evolve',
+              data: {
+                receivedAt: now,
+                nextAvailableAt: lastEvolutionAt + interval,
+                payloadKeys: Object.keys(payload || {}),
+                reason,
+              },
+            });
+          } catch (e) {}
+        }
+        return;
+      }
+      // Mark processed time and send ack for an evolve we will process
+      lastEvolutionAt = now;
+      console.log(
+        '[hexgrid-worker] ✅ PROCESSING evolution - lastEvolutionAt updated to',
+        now
+      );
+      try {
+        if (workerDebug && workerDebug.debugLogs) {
+          try {
+            self.postMessage({
+              type: 'ack-evolve',
+              data: {
+                receivedAt: now,
+                payloadKeys: Object.keys(payload || {}),
+              },
+            });
+          } catch (e) {}
+        }
+      } catch (e) {}
+      // Emit a lightweight processing marker so the client can see evolve processing started
+      try {
+        if (workerDebug && workerDebug.debugLogs) {
+          try {
+            self.postMessage({
+              type: 'processing-evolve',
+              data: { startedAt: now, payloadKeys: Object.keys(payload || {}) },
+            });
+          } catch (e) {}
+        }
+      } catch (e) {}
+      const state =
+        (_f =
+          (_e =
+            (_d = payload.prevState) !== null && _d !== void 0
+              ? _d
+              : payload.state) !== null && _e !== void 0
+            ? _e
+            : raw.state) !== null && _f !== void 0
+          ? _f
+          : null;
+      const positions =
+        (_h =
+          (_g = payload.positions) !== null && _g !== void 0
+            ? _g
+            : raw.positions) !== null && _h !== void 0
+          ? _h
+          : [];
+      const photos =
+        (_k =
+          (_j = payload.photos) !== null && _j !== void 0 ? _j : raw.photos) !==
+          null && _k !== void 0
+          ? _k
+          : [];
+      const hexRadius =
+        typeof payload.hexRadius === 'number'
+          ? payload.hexRadius
+          : typeof raw.hexRadius === 'number'
+          ? raw.hexRadius
+          : 16;
+      if (
+        typeof payload.isSpherical === 'boolean' &&
+        Boolean(payload.isSpherical) !== cache.isSpherical
+      ) {
+        invalidateCaches(Boolean(payload.isSpherical));
+      }
+      console.log('[hexgrid-worker] 🔧 About to call evolveInfectionSystem');
+      console.log(
+        '[hexgrid-worker]   - state generation:',
+        state === null || state === void 0 ? void 0 : state.generation
+      );
+      console.log(
+        '[hexgrid-worker]   - state infections:',
+        ((_l =
+          state === null || state === void 0 ? void 0 : state.infections) ===
+          null || _l === void 0
+          ? void 0
+          : _l.length) ||
+          ((_m =
+            state === null || state === void 0 ? void 0 : state.infections) ===
+            null || _m === void 0
+            ? void 0
+            : _m.size) ||
+          0
+      );
+      console.log(
+        '[hexgrid-worker]   - positions:',
+        (positions === null || positions === void 0
+          ? void 0
+          : positions.length) || 0
+      );
+      console.log(
+        '[hexgrid-worker]   - photos:',
+        (photos === null || photos === void 0 ? void 0 : photos.length) || 0
+      );
+      console.log('[hexgrid-worker]   - hexRadius:', hexRadius);
+      let res;
+      let timeoutId;
+      let timedOut = false;
+      // Set a watchdog timer to detect hangs (10 seconds)
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        console.error(
+          '[hexgrid-worker] ⏱️ TIMEOUT: evolveInfectionSystem is taking too long (>10s)! Possible infinite loop.'
+        );
+        try {
+          self.postMessage({
+            type: 'error',
+            error: 'Evolution timeout - possible infinite loop',
+          });
+        } catch (e) {}
+      }, 10000);
+      try {
+        console.log('[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'
+        );
+      } catch (err) {
+        clearTimeout(timeoutId);
+        console.error(
+          '[hexgrid-worker] ❌ FATAL: evolveInfectionSystem threw an error:',
+          err
+        );
+        console.error(
+          '[hexgrid-worker] Error stack:',
+          err instanceof Error ? err.stack : 'no stack'
+        );
         safePostError(err);
+        return;
+      }
+      if (timedOut) {
+        console.error(
+          '[hexgrid-worker] ⏱️ Function eventually returned but after timeout was triggered'
+        );
+      }
+      if (!res) {
+        console.log('[hexgrid-worker] ❌ evolveInfectionSystem returned null!');
+        return;
+      }
+      console.log(
+        '[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,
+        };
+        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'
+          );
+        }
+        self.postMessage({ type: 'evolved', data: payload });
+        // Record posted generation/infection count so later auto-triggers can avoid regressing
+        try {
+          cache.lastGeneration = res.generation;
+          cache.lastInfectionCount = res.infections ? res.infections.size : 0;
+        } catch (e) {}
+      } catch (e) {
+        console.error('[hexgrid-worker] ❌ Failed to post evolved message:', e);
+      }
+      console.log(
+        '[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) {
+          try {
+            self.postMessage({
+              type: 'evolved-complete',
+              data: {
+                finishedAt: Date.now(),
+                generation: res.generation,
+                lastEvolutionTime: res.lastEvolutionTime,
+              },
+            });
+          } catch (e) {}
+        }
+      } catch (e) {}
+      return;
     }
+    if (type === 'optimize') {
+      try {
+        const infectionsArr = payload.infections || raw.infections || [];
+        const infections = new Map(infectionsArr);
+        const positions =
+          (_o = payload.positions) !== null && _o !== void 0
+            ? _o
+            : raw.positions;
+        const hexRadius =
+          typeof payload.hexRadius === 'number'
+            ? payload.hexRadius
+            : typeof raw.hexRadius === 'number'
+            ? raw.hexRadius
+            : 16;
+        postOptimizationMerge(
+          infections,
+          positions,
+          hexRadius,
+          !!workerDebug.mergeLogs
+        );
+        try {
+          self.postMessage({
+            type: 'optimized',
+            data: { infections: Array.from(infections.entries()) },
+          });
+        } catch (e) {}
+      } catch (e) {
+        safePostError(e);
+      }
+      return;
+    }
+  } catch (err) {
+    safePostError(err);
+  }
 };
 // Additional helpers that the optimizer uses (kept separate and consistent)
-function calculatePhotoContiguityCached(photoIdOrPhoto, indices, positions, hexRadius, debugLogs = true) {
-    const photoId = typeof photoIdOrPhoto === 'string' ? photoIdOrPhoto : photoIdOrPhoto.id;
-    return calculatePhotoContiguity(photoId, indices, positions, hexRadius, debugLogs);
+function calculatePhotoContiguityCached(
+  photoIdOrPhoto,
+  indices,
+  positions,
+  hexRadius,
+  debugLogs = true
+) {
+  const photoId =
+    typeof photoIdOrPhoto === 'string' ? photoIdOrPhoto : photoIdOrPhoto.id;
+  return calculatePhotoContiguity(
+    photoId,
+    indices,
+    positions,
+    hexRadius,
+    debugLogs
+  );
 }
-function calculatePhotoContiguity(photoId, indices, positions, hexRadius, debugLogs = true) {
-    let totalScore = 0;
-    const indicesSet = new Set(indices);
-    for (const index of indices) {
-        const neighbors = getNeighborsCached(index, positions, hexRadius);
-        let connections = 0;
-        for (const neighborIndex of neighbors) {
-            if (indicesSet.has(neighborIndex))
-                connections++;
-        }
-        totalScore += connections;
+function calculatePhotoContiguity(
+  photoId,
+  indices,
+  positions,
+  hexRadius,
+  debugLogs = true
+) {
+  let totalScore = 0;
+  const indicesSet = new Set(indices);
+  for (const index of indices) {
+    const neighbors = getNeighborsCached(index, positions, hexRadius);
+    let connections = 0;
+    for (const neighborIndex of neighbors) {
+      if (indicesSet.has(neighborIndex)) connections++;
     }
-    return totalScore;
+    totalScore += connections;
+  }
+  return totalScore;
 }
-function calculateSwappedContiguityCached(photoId, indices, positions, hexRadius, fromIndex, toIndex, infections, debugLogs = true) {
-    const tempIndices = [...indices];
-    const fromPos = tempIndices.indexOf(fromIndex);
-    const toPos = tempIndices.indexOf(toIndex);
-    if (fromPos !== -1)
-        tempIndices[fromPos] = toIndex;
-    if (toPos !== -1)
-        tempIndices[toPos] = fromIndex;
-    return calculatePhotoContiguity(photoId, tempIndices, positions, hexRadius, debugLogs);
+function calculateSwappedContiguityCached(
+  photoId,
+  indices,
+  positions,
+  hexRadius,
+  fromIndex,
+  toIndex,
+  infections,
+  debugLogs = true
+) {
+  const tempIndices = [...indices];
+  const fromPos = tempIndices.indexOf(fromIndex);
+  const toPos = tempIndices.indexOf(toIndex);
+  if (fromPos !== -1) tempIndices[fromPos] = toIndex;
+  if (toPos !== -1) tempIndices[toPos] = fromIndex;
+  return calculatePhotoContiguity(
+    photoId,
+    tempIndices,
+    positions,
+    hexRadius,
+    debugLogs
+  );
 }
-function analyzeLocalEnvironment(centerIndex, infections, positions, hexRadius, radius = 2, debugLogs = true) {
-    const centerPos = positions[centerIndex];
-    const localIndices = [];
-    const visited = new Set();
-    const queue = [[centerIndex, 0]];
-    while (queue.length > 0) {
-        const [currentIndex, distance] = queue.shift();
-        if (visited.has(currentIndex) || distance > radius)
-            continue;
-        visited.add(currentIndex);
-        localIndices.push(currentIndex);
-        if (distance < radius) {
-            const neighbors = getNeighborsCached(currentIndex, positions, hexRadius);
-            for (const neighborIndex of neighbors) {
-                if (!visited.has(neighborIndex))
-                    queue.push([neighborIndex, distance + 1]);
-            }
-        }
+function analyzeLocalEnvironment(
+  centerIndex,
+  infections,
+  positions,
+  hexRadius,
+  radius = 2,
+  debugLogs = true
+) {
+  const centerPos = positions[centerIndex];
+  const localIndices = [];
+  const visited = new Set();
+  const queue = [[centerIndex, 0]];
+  while (queue.length > 0) {
+    const [currentIndex, distance] = queue.shift();
+    if (visited.has(currentIndex) || distance > radius) continue;
+    visited.add(currentIndex);
+    localIndices.push(currentIndex);
+    if (distance < radius) {
+      const neighbors = getNeighborsCached(currentIndex, positions, hexRadius);
+      for (const neighborIndex of neighbors) {
+        if (!visited.has(neighborIndex))
+          queue.push([neighborIndex, distance + 1]);
+      }
     }
-    let infectedCount = 0;
-    const photoCounts = new Map();
-    const clusterSizes = new Map();
-    let boundaryPressure = 0;
-    let totalVariance = 0;
-    for (const index of localIndices) {
-        const infection = infections.get(index);
-        if (infection) {
-            infectedCount++;
-            const photoId = infection.photo.id;
-            photoCounts.set(photoId, (photoCounts.get(photoId) || 0) + 1);
-            clusterSizes.set(photoId, (clusterSizes.get(photoId) || 0) + 1);
-        }
-        else {
-            boundaryPressure += 0.1;
-        }
+  }
+  let infectedCount = 0;
+  const photoCounts = new Map();
+  const clusterSizes = new Map();
+  let boundaryPressure = 0;
+  let totalVariance = 0;
+  for (const index of localIndices) {
+    const infection = infections.get(index);
+    if (infection) {
+      infectedCount++;
+      const photoId = infection.photo.id;
+      photoCounts.set(photoId, (photoCounts.get(photoId) || 0) + 1);
+      clusterSizes.set(photoId, (clusterSizes.get(photoId) || 0) + 1);
+    } else {
+      boundaryPressure += 0.1;
     }
-    const totalPhotos = photoCounts.size;
-    const avgPhotoCount = infectedCount / Math.max(totalPhotos, 1);
-    for (const count of photoCounts.values())
-        totalVariance += Math.pow(count - avgPhotoCount, 2);
-    const localVariance = totalVariance / Math.max(infectedCount, 1);
-    let dominantPhoto = null;
-    let maxCount = 0;
-    for (const [photoId, count] of photoCounts) {
-        if (count > maxCount) {
-            maxCount = count;
-            for (const infection of infections.values()) {
-                if (infection.photo.id === photoId) {
-                    dominantPhoto = infection.photo;
-                    break;
-                }
-            }
+  }
+  const totalPhotos = photoCounts.size;
+  const avgPhotoCount = infectedCount / Math.max(totalPhotos, 1);
+  for (const count of photoCounts.values())
+    totalVariance += Math.pow(count - avgPhotoCount, 2);
+  const localVariance = totalVariance / Math.max(infectedCount, 1);
+  let dominantPhoto = null;
+  let maxCount = 0;
+  for (const [photoId, count] of photoCounts) {
+    if (count > maxCount) {
+      maxCount = count;
+      for (const infection of infections.values()) {
+        if (infection.photo.id === photoId) {
+          dominantPhoto = infection.photo;
+          break;
         }
+      }
     }
-    const density = infectedCount / Math.max(localIndices.length, 1);
-    const stability = dominantPhoto ? (maxCount / Math.max(infectedCount, 1)) : 0;
-    return { density, stability, dominantPhoto, clusterSizes, boundaryPressure, localVariance };
+  }
+  const density = infectedCount / Math.max(localIndices.length, 1);
+  const stability = dominantPhoto ? maxCount / Math.max(infectedCount, 1) : 0;
+  return {
+    density,
+    stability,
+    dominantPhoto,
+    clusterSizes,
+    boundaryPressure,
+    localVariance,
+  };
 }
 function invalidateCaches(isSpherical) {
-    cache.neighborMap.clear();
-    cache.gridBounds = null;
-    cache.photoClusters.clear();
-    cache.connectedComponents.clear();
-    cache.gridPositions.clear();
-    cache.cacheReady = false;
-    if (typeof isSpherical === 'boolean')
-        cache.isSpherical = isSpherical;
+  cache.neighborMap.clear();
+  cache.gridBounds = null;
+  cache.photoClusters.clear();
+  cache.connectedComponents.clear();
+  cache.gridPositions.clear();
+  cache.cacheReady = false;
+  if (typeof isSpherical === 'boolean') cache.isSpherical = isSpherical;
 }
 console.log('[hexgrid-worker] ready');