@buley/hexgrid-3d 3.0.1 → 3.2.0

package/public/hexgrid-worker.js

@@ -1,2475 +0,0 @@
-'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)
-};
-// Tuning flags for cluster tiling behaviour
-workerDebug.clusterPreserveAspect = true; // when true, preserve cluster aspect ratio when mapping to tile grid
-workerDebug.clusterDynamicTiling = true; // when true, calculate tilesX/tilesY dynamically based on cluster aspect ratio
-workerDebug.clusterAnchor = 'center'; // 'center' or 'min' (used during aspect correction)
-workerDebug.clusterGlobalAlign = false; // when true, clusters snap to global tile anchor for better neighbor alignment
-workerDebug.clusterUvInset = 0.0; // shrink UVs slightly to allow texture filtering/edge blending (0..0.5)
-workerDebug.clusterJitter = 0.0; // small (0..0.5) fractional jitter applied to normalized coords before quantization
-// adjacency mode for cluster tiling: 'hex' (6-way) or 'rect' (4-way). 'rect' gives raster-like, cohesive images
-workerDebug.clusterAdjacency = 'rect';
-// maximum number of tiles to allocate for a cluster when dynamically expanding (cap)
-workerDebug.clusterMaxTiles = 128;
-// whether to 'contain' (fit whole image within cluster bounds) or 'cover' (fill cluster and allow cropping)
-workerDebug.clusterFillMode = 'contain';
-// scan order for filling tiles: 'row' = left->right each row, 'serpentine' = zig-zag per row
-workerDebug.clusterScanMode = 'row';
-// when true, compute tile centers using hex-row parity offsets so ordering follows hex staggering
-workerDebug.clusterParityAware = true;
-// when true, include computed tile centers in evolved message for debug visualization
-workerDebug.showTileCenters = false;
-// when true, enable direct hex lattice mapping fast-path (parity-correct row/col inference)
-workerDebug.clusterHexLattice = true;
-// when true, horizontally nudge odd rows' UV sampling by half a tile width to compensate
-// for physical hex center staggering (attempts to eliminate visible half-hex seams)
-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),
-    });
-  } 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;
-}
-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;
-    }
-  }
-  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 [];
-  }
-  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];
-}
-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;
-        }
-      }
-      console.log(
-        '[findConnectedComponents] Component',
-        componentCount,
-        'complete:',
-        comp.length,
-        'nodes,',
-        iterations,
-        'iterations'
-      );
-      comps.push(comp);
-    }
-    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.'
-      );
-    }
-    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);
-    }
-    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] 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;
-}
-// 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);
-      }
-      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),
-        });
-        // 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) 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 (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
-        }
-        clusterIndex++;
-      }
-    }
-    // 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 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];
-            }
-          }
-          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;
-          }
-        }
-        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}`);
-        }
-      }
-    }
-  } 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;
-    }
-    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'
-          );
-        }
-      }
-      // 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 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) {}
-}
-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) {}
-      } 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 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;
-  }
-  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 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;
-    }
-  }
-  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,
-  };
-}
-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;
-}
-console.log('[hexgrid-worker] ready');