@inventure71/paddockjs 2.0.0 → 3.0.0

package/src/simulation/track/trackQueryIndex.js

@@ -1,5 +1,21 @@
 import { clamp, wrapDistance } from '../simMath.js';
 import { metersToSimUnits } from '../units.js';
+import {
+  candidateIdsFromGrid,
+  candidateIdsFromGridBounds,
+  createSpatialGrid,
+  gridCellForPoint,
+  insertIdIntoGridBounds,
+} from './trackQueryGrid.js';
+import { createPitQueryIndex } from './trackQueryPitIndex.js';
+import { createQueryScratch, ensureQueryScratch, ensureScratchArray, nextScratchEpoch } from './trackQueryScratch.js';
+import { createQueryStats, recordFallback, recordStat } from './trackQueryStats.js';
+
+export {
+  queryPitBoxCandidates,
+  queryPitRoadSegmentCandidates,
+  queryPitRoadSegmentCandidatesByRoute,
+} from './trackQueryPitIndex.js';
 
 const DEFAULT_GRID_CELL_SIZE = metersToSimUnits(32);
 const GRID_NEIGHBOR_LIMIT = 2;
@@ -27,6 +43,7 @@ export function createTrackQueryIndex(track) {
   const index = {
     version: 1,
     bands,
+    nearestGridExpansion: expansion,
     centerline,
     grid,
     segmentGrid,
@@ -38,7 +55,7 @@ export function createTrackQueryIndex(track) {
   return index;
 }
 
-export function queryNearestTrackProjection(track, position, progressHint = null, options = {}) {
+export function queryNearestTrackProjection(track, position, progressHint = null) {
   const index = track?.queryIndex;
   if (!index?.centerline?.segmentCount) {
     recordFallback(index, 'nearestFallbackReasons', 'missing-index');
@@ -50,8 +67,7 @@ export function queryNearestTrackProjection(track, position, progressHint = null
   }
   index.stats.nearestQueries += 1;
 
-  const mode = options.indexMode === 'sample' ? 'sample' : 'projection';
-  const { projection, path, reason } = bestNearestFromIndex(track, index, position, progressHint, mode, options);
+  const { projection, path, reason } = bestProjectionFromIndex(index, position, progressHint);
   if (!projection) {
     recordFallback(index, 'nearestFallbackReasons', reason ?? 'unknown');
     return null;
@@ -61,169 +77,173 @@ export function queryNearestTrackProjection(track, position, progressHint = null
   return projection;
 }
 
-function bestNearestFromIndex(track, index, position, progressHint, mode, options) {
-  return mode === 'sample'
-    ? bestSampleFromIndex(track, index, position, progressHint, options)
-    : bestProjectionFromIndex(index, position, progressHint, options);
-}
-
-function bestProjectionFromIndex(index, position, progressHint, options) {
+function bestProjectionFromIndex(index, position, progressHint) {
   const hintedCandidateIds = Number.isFinite(progressHint)
     ? candidateIdsFromArcBuckets(index, progressHint, 2)
     : [];
   if (hintedCandidateIds.length) {
     const hinted = bestProjectionFromCandidates(index.centerline, hintedCandidateIds, position, progressHint);
-    const maxHintDistance = resolveHintMaxDistance(index, options);
-    if (hinted.projection && hinted.projection.distanceSquared <= maxHintDistance * maxHintDistance) {
-      return {
-        projection: hinted.projection,
-        path: hinted.reason === 'tie-resolved' ? 'arc-hint-tie-resolved' : 'arc-hint',
-      };
+    if (hinted.projection) {
+      const exact = bestProjectionFromCellSearch(index, position, progressHint, hinted.projection);
+      if (exact.projection) {
+        const path = projectionMatches(hinted.projection, exact.projection)
+          ? (hinted.reason === 'tie-resolved' ? 'arc-hint-tie-resolved' : 'arc-hint')
+          : 'arc-hint-refined';
+        return {
+          projection: exact.projection,
+          path: exact.reason === 'tie-resolved' && !path.endsWith('tie-resolved') ? `${path}-tie-resolved` : path,
+        };
+      }
     }
-    recordStat(index, 'nearestPaths', hinted.projection ? 'arc-hint-rejected-distance' : `arc-hint-${hinted.reason}`);
   }
 
+  let local = { projection: null, path: null };
   const gridCandidateIds = candidateIdsFromGrid(index, index.grid, position, GRID_NEIGHBOR_LIMIT);
   const grid = bestProjectionFromCandidates(index.centerline, gridCandidateIds, position, progressHint);
-  return grid.projection
-    ? {
-      projection: grid.projection,
-      path: grid.reason === 'tie-resolved' ? 'spatial-grid-tie-resolved' : 'spatial-grid',
+  if (grid.projection) {
+    local = chooseBetterProjectionResult(local, grid, 'spatial-grid', progressHint);
+    if (grid.projection.distanceSquared <= index.nearestGridExpansion * index.nearestGridExpansion) {
+      return local;
     }
-    : { projection: null, reason: `spatial-grid-${grid.reason}` };
-}
+  }
 
-function bestSampleFromIndex(track, index, position, progressHint, options) {
-  const samples = track?.samples;
-  const sampleCount = Math.max(0, samples?.length - 1);
-  if (sampleCount <= 0) return { projection: null, reason: 'missing-samples' };
-  const hintedCandidateIds = Number.isFinite(progressHint)
-    ? candidateIdsFromArcBuckets(index, progressHint, 2)
-    : [];
-  if (hintedCandidateIds.length) {
-    const hinted = bestSampleFromCandidates(index, samples, sampleCount, hintedCandidateIds, position, progressHint);
-    const maxHintDistance = resolveHintMaxDistance(index, options);
-    if (hinted.sample && hinted.distanceSquared <= maxHintDistance * maxHintDistance) {
+  if (local.projection) {
+    const exact = bestProjectionFromCellSearch(index, position, progressHint, local.projection);
+    if (exact.projection) {
+      const path = projectionMatches(local.projection, exact.projection)
+        ? local.path
+        : `${local.path}-refined`;
       return {
-        projection: hinted.sample,
-        path: hinted.reason === 'tie-resolved' ? 'arc-hint-tie-resolved' : 'arc-hint',
+        projection: exact.projection,
+        path: exact.reason === 'tie-resolved' && !path.endsWith('tie-resolved') ? `${path}-tie-resolved` : path,
       };
     }
-    recordStat(index, 'nearestPaths', hinted.sample ? 'arc-hint-rejected-distance' : `arc-hint-${hinted.reason}`);
+
+    return {
+      projection: local.projection,
+      path: local.path,
+    };
   }
 
-  const gridCandidateIds = candidateIdsFromGrid(index, index.grid, position, GRID_NEIGHBOR_LIMIT);
-  const grid = bestSampleFromCandidates(index, samples, sampleCount, gridCandidateIds, position, progressHint);
-  return grid.sample
+  const exact = bestProjectionFromCellSearch(index, position, progressHint);
+  const global = exact.projection ? exact : bestProjectionFromAllSegments(index.centerline, position, progressHint);
+  return global.projection
     ? {
-      projection: grid.sample,
-      path: grid.reason === 'tie-resolved' ? 'spatial-grid-tie-resolved' : 'spatial-grid',
+      projection: global.projection,
+      path: exact.projection
+        ? (global.reason === 'tie-resolved' ? 'exact-grid-tie-resolved' : 'exact-grid')
+        : (global.reason === 'tie-resolved' ? 'global-index-tie-resolved' : 'global-index'),
     }
-    : { projection: null, reason: `spatial-grid-${grid.reason}` };
+    : { projection: null, reason: `global-index-${global.reason}` };
 }
 
-function resolveHintMaxDistance(index, options = {}) {
-  if (options.hintMaxDistance == null) return index.bands.runoffEdge + metersToSimUnits(24);
-  if (!Number.isFinite(options.hintMaxDistance)) return Infinity;
-  return Math.max(0, options.hintMaxDistance);
+function chooseBetterProjectionResult(current, candidate, source, preferredDistance) {
+  if (!candidate.projection) return current;
+  const path = candidate.reason === 'tie-resolved' ? `${source}-tie-resolved` : source;
+  if (!current.projection) return { projection: candidate.projection, path };
+  if (candidate.projection.distanceSquared < current.projection.distanceSquared - AMBIGUOUS_DISTANCE_EPSILON) {
+    return { projection: candidate.projection, path };
+  }
+  if (Math.abs(candidate.projection.distanceSquared - current.projection.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON) {
+    const candidateTie = projectionTieScore(candidate.projection, preferredDistance);
+    const currentTie = projectionTieScore(current.projection, preferredDistance);
+    if (projectionTieBeats(candidate.projection, candidateTie, current.projection, currentTie)) {
+      return { projection: candidate.projection, path: `${path}-tie-resolved` };
+    }
+  }
+  return current;
 }
 
-function bestSampleFromCandidates(index, samples, sampleCount, candidateSegmentIds, position, preferredDistance = null) {
-  if (!candidateSegmentIds.length || sampleCount <= 0) return { sample: null, reason: 'no-candidates' };
-  const scratch = ensureQueryScratch(index);
-  const sampleMarks = ensureScratchArray(scratch, 'sampleMarks', sampleCount);
-  const sampleEpoch = nextScratchEpoch(scratch, 'sampleEpoch', sampleMarks);
+function bestProjectionFromCellSearch(index, position, preferredDistance, initialProjection = null) {
+  const grid = index.segmentGrid ?? index.grid;
+  const center = gridCellForPoint(grid, position, true);
 
-  let bestSample = null;
-  let bestDistanceSquared = Infinity;
-  let bestTieScore = Infinity;
+  const scratch = ensureQueryScratch(index);
+  const segmentMarks = ensureScratchArray(scratch, 'exactSegmentMarks', index.centerline.segmentCount);
+  const cellMarks = ensureScratchArray(scratch, 'exactCellMarks', grid.columns * grid.rows);
+  const segmentEpoch = nextScratchEpoch(scratch, 'exactSegmentEpoch', segmentMarks);
+  const cellEpoch = nextScratchEpoch(scratch, 'exactCellEpoch', cellMarks);
+  const maxRadius = Math.max(grid.columns, grid.rows);
+  let best = initialProjection;
+  let bestTieScore = best ? projectionTieScore(best, preferredDistance) : Infinity;
   let secondBestDistance = Infinity;
   let tieResolved = false;
-  for (const segmentId of candidateSegmentIds) {
-    const normalized = ((segmentId % sampleCount) + sampleCount) % sampleCount;
-    const adjacent = (normalized + 1) % sampleCount;
-    if (sampleMarks[normalized] !== sampleEpoch) {
-      sampleMarks[normalized] = sampleEpoch;
-      ({ bestSample, bestDistanceSquared, bestTieScore, secondBestDistance, tieResolved } = considerSampleCandidate({
-        samples,
-        sampleId: normalized,
-        position,
-        preferredDistance,
-        bestSample,
-        bestDistanceSquared,
-        bestTieScore,
-        secondBestDistance,
-        tieResolved,
-      }));
-    }
-    if (sampleMarks[adjacent] !== sampleEpoch) {
-      sampleMarks[adjacent] = sampleEpoch;
-      ({ bestSample, bestDistanceSquared, bestTieScore, secondBestDistance, tieResolved } = considerSampleCandidate({
-        samples,
-        sampleId: adjacent,
-        position,
-        preferredDistance,
-        bestSample,
-        bestDistanceSquared,
-        bestTieScore,
-        secondBestDistance,
-        tieResolved,
-      }));
-    }
-  }
 
-  if (!bestSample) return { sample: null, reason: 'no-best' };
+  for (let radius = 0; radius <= maxRadius; radius += 1) {
+    let ringCanImprove = !best;
 
+    forEachRingCell(grid, center, radius, (cellIndex, row, column) => {
+      if (cellMarks[cellIndex] === cellEpoch) return;
+      cellMarks[cellIndex] = cellEpoch;
+      const lowerBound = cellDistanceSquared(grid, row, column, position);
+      if (best && lowerBound > best.distanceSquared + AMBIGUOUS_DISTANCE_EPSILON) {
+        return;
+      }
+      ringCanImprove = true;
+      const cell = grid.cells[cellIndex];
+      if (!cell) return;
+      for (const segmentId of cell) {
+        if (segmentMarks[segmentId] === segmentEpoch) continue;
+        segmentMarks[segmentId] = segmentEpoch;
+        const projection = projectIndexedSegment(index.centerline, segmentId, position);
+        const tieScore = projectionTieScore(projection, preferredDistance);
+        if (!best || projection.distanceSquared < best.distanceSquared - AMBIGUOUS_DISTANCE_EPSILON) {
+          secondBestDistance = best?.distanceSquared ?? Infinity;
+          best = projection;
+          bestTieScore = tieScore;
+        } else if (Math.abs(projection.distanceSquared - best.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON) {
+          tieResolved = true;
+          secondBestDistance = Math.min(secondBestDistance, projection.distanceSquared);
+          if (projectionTieBeats(projection, tieScore, best, bestTieScore)) {
+            best = projection;
+            bestTieScore = tieScore;
+          }
+        } else if (projection.distanceSquared < secondBestDistance) {
+          secondBestDistance = projection.distanceSquared;
+        }
+      }
+    });
+    if (best && !ringCanImprove) break;
+  }
+
+  if (!best) return { projection: null, reason: 'no-candidates' };
   const ambiguous = Number.isFinite(secondBestDistance) &&
-    Math.abs(secondBestDistance - bestDistanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON;
-  return {
-    sample: bestSample,
-    distanceSquared: bestDistanceSquared,
-    reason: ambiguous || tieResolved ? 'tie-resolved' : 'ok',
-  };
+    Math.abs(secondBestDistance - best.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON;
+  return { projection: best, reason: ambiguous || tieResolved ? 'tie-resolved' : 'ok' };
 }
 
-function considerSampleCandidate({
-  samples,
-  sampleId,
-  position,
-  preferredDistance,
-  bestSample,
-  bestDistanceSquared,
-  bestTieScore,
-  secondBestDistance,
-  tieResolved,
-}) {
-  const sample = samples[sampleId];
-  if (!sample) {
-    return { bestSample, bestDistanceSquared, bestTieScore, secondBestDistance, tieResolved };
-  }
-  const dx = position.x - sample.x;
-  const dy = position.y - sample.y;
-  const distanceSquared = dx * dx + dy * dy;
-  const tieScore = sampleTieScore(sample, preferredDistance);
-  if (!bestSample || distanceSquared < bestDistanceSquared - AMBIGUOUS_DISTANCE_EPSILON) {
-    secondBestDistance = bestDistanceSquared;
-    bestSample = sample;
-    bestDistanceSquared = distanceSquared;
-    bestTieScore = tieScore;
-  } else if (Math.abs(distanceSquared - bestDistanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON) {
-    tieResolved = true;
-    secondBestDistance = Math.min(secondBestDistance, distanceSquared);
-    if (tieScore < bestTieScore) {
-      bestSample = sample;
-      bestDistanceSquared = distanceSquared;
-      bestTieScore = tieScore;
+function projectionMatches(first, second) {
+  return first.segmentId === second.segmentId &&
+    Math.abs(first.distanceSquared - second.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON;
+}
+
+function forEachRingCell(grid, center, radius, visitor) {
+  const minRow = Math.max(0, center.row - radius);
+  const maxRow = Math.min(grid.rows - 1, center.row + radius);
+  const minColumn = Math.max(0, center.column - radius);
+  const maxColumn = Math.min(grid.columns - 1, center.column + radius);
+  for (let row = minRow; row <= maxRow; row += 1) {
+    for (let column = minColumn; column <= maxColumn; column += 1) {
+      if (
+        radius > 0 &&
+        row !== minRow &&
+        row !== maxRow &&
+        column !== minColumn &&
+        column !== maxColumn
+      ) continue;
+      visitor(row * grid.columns + column, row, column);
     }
-  } else if (distanceSquared < secondBestDistance) {
-    secondBestDistance = distanceSquared;
   }
-  return { bestSample, bestDistanceSquared, bestTieScore, secondBestDistance, tieResolved };
 }
 
-function sampleTieScore(sample, preferredDistance) {
-  if (!Number.isFinite(preferredDistance)) return sample.distance;
-  return Math.abs(sample.distance - preferredDistance);
+function cellDistanceSquared(grid, row, column, position) {
+  const minX = grid.bounds.minX + column * grid.cellSize;
+  const minY = grid.bounds.minY + row * grid.cellSize;
+  const maxX = Math.min(grid.bounds.maxX, minX + grid.cellSize);
+  const maxY = Math.min(grid.bounds.maxY, minY + grid.cellSize);
+  const dx = position.x < minX ? minX - position.x : position.x > maxX ? position.x - maxX : 0;
+  const dy = position.y < minY ? minY - position.y : position.y > maxY ? position.y - maxY : 0;
+  return dx * dx + dy * dy;
 }
 
 function bestProjectionFromCandidates(centerline, candidateIds, position, preferredDistance = null) {
@@ -242,7 +262,7 @@ function bestProjectionFromCandidates(centerline, candidateIds, position, prefer
     } else if (Math.abs(projection.distanceSquared - best.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON) {
       tieResolved = true;
       secondBestDistance = Math.min(secondBestDistance, projection.distanceSquared);
-      if (tieScore < bestTieScore) {
+      if (projectionTieBeats(projection, tieScore, best, bestTieScore)) {
         best = projection;
         bestTieScore = tieScore;
       }
@@ -258,62 +278,48 @@ function bestProjectionFromCandidates(centerline, candidateIds, position, prefer
   return { projection: best, reason: ambiguous || tieResolved ? 'tie-resolved' : 'ok' };
 }
 
-function projectionTieScore(projection, preferredDistance) {
-  if (!Number.isFinite(preferredDistance)) return projection.segmentId;
-  return Math.abs(projection.distance - preferredDistance);
-}
+function bestProjectionFromAllSegments(centerline, position, preferredDistance = null) {
+  const segmentCount = centerline?.segmentCount ?? 0;
+  if (segmentCount <= 0) return { projection: null, reason: 'no-candidates' };
+  let best = null;
+  let bestTieScore = Infinity;
+  let secondBestDistance = Infinity;
+  let tieResolved = false;
 
-export function queryPitBoxCandidates(track, position) {
-  const index = track?.queryIndex;
-  const pit = index?.pit;
-  if (!pit?.boxGrid) {
-    recordFallback(index, 'pitFallbackReasons', 'missing-box-index');
-    return null;
-  }
-  if (!finitePoint(position)) {
-    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
-    return null;
-  }
-  index.stats.pitQueries += 1;
-  const ids = candidateIdsFromGrid(index, pit.boxGrid, position, 1);
-  if (!ids.length) {
-    recordStat(index, 'pitPaths', 'box-grid-miss');
-    return [];
+  for (let segmentId = 0; segmentId < segmentCount; segmentId += 1) {
+    const projection = projectIndexedSegment(centerline, segmentId, position);
+    const tieScore = projectionTieScore(projection, preferredDistance);
+    if (!best || projection.distanceSquared < best.distanceSquared - AMBIGUOUS_DISTANCE_EPSILON) {
+      secondBestDistance = best?.distanceSquared ?? Infinity;
+      best = projection;
+      bestTieScore = tieScore;
+    } else if (Math.abs(projection.distanceSquared - best.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON) {
+      tieResolved = true;
+      secondBestDistance = Math.min(secondBestDistance, projection.distanceSquared);
+      if (projectionTieBeats(projection, tieScore, best, bestTieScore)) {
+        best = projection;
+        bestTieScore = tieScore;
+      }
+    } else if (projection.distanceSquared < secondBestDistance) {
+      secondBestDistance = projection.distanceSquared;
+    }
   }
-  recordStat(index, 'pitPaths', 'box-grid-hit');
-  return ids.map((id) => pit.boxCandidates[id]).filter(Boolean);
+
+  if (!best) return { projection: null, reason: 'no-best' };
+  const ambiguous = Number.isFinite(secondBestDistance) &&
+    Math.abs(secondBestDistance - best.distanceSquared) <= AMBIGUOUS_DISTANCE_EPSILON;
+  return { projection: best, reason: ambiguous || tieResolved ? 'tie-resolved' : 'ok' };
 }
 
-export function queryPitRoadSegmentCandidates(track, routeId, position) {
-  const candidatesByRoute = queryPitRoadSegmentCandidatesByRoute(track, position);
-  return candidatesByRoute?.[routeId] ?? candidatesByRoute;
+function projectionTieScore(projection, preferredDistance) {
+  if (!Number.isFinite(preferredDistance)) return projection.segmentId;
+  return Math.abs(projection.distance - preferredDistance);
 }
 
-export function queryPitRoadSegmentCandidatesByRoute(track, position) {
-  const index = track?.queryIndex;
-  const pit = index?.pit;
-  if (!pit?.roadGrid) {
-    recordFallback(index, 'pitFallbackReasons', 'missing-road-index');
-    return null;
-  }
-  if (!finitePoint(position)) {
-    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
-    return null;
-  }
-  index.stats.pitQueries += 1;
-  const ids = candidateIdsFromGrid(index, pit.roadGrid, position, 1);
-  if (!ids.length) {
-    recordStat(index, 'pitPaths', 'road-grid-miss');
-    return null;
-  }
-  const candidatesByRoute = { entry: [], main: [], working: [], exit: [] };
-  ids.forEach((id) => {
-    const segment = pit.roadSegments[id];
-    if (!segment || !candidatesByRoute[segment.routeId]) return;
-    candidatesByRoute[segment.routeId].push(segment.segmentIndex);
-  });
-  recordStat(index, 'pitPaths', 'road-grid-hit');
-  return candidatesByRoute;
+function projectionTieBeats(candidate, candidateTieScore, current, currentTieScore) {
+  if (candidateTieScore < currentTieScore - AMBIGUOUS_DISTANCE_EPSILON) return true;
+  if (Math.abs(candidateTieScore - currentTieScore) > AMBIGUOUS_DISTANCE_EPSILON) return false;
+  return candidate.segmentId < current.segmentId;
 }
 
 export function queryNearbyTrackProjections(track, position, { neighborLimit = GRID_NEIGHBOR_LIMIT } = {}) {
@@ -401,13 +407,15 @@ export function attachTrackQueryIndex(track, queryIndex) {
   return track;
 }
 
-export function forkTrackQueryIndex(sourceIndex) {
+export function forkTrackQueryIndex(sourceIndex, runtimeTrack = null) {
   if (!sourceIndex || typeof sourceIndex !== 'object') return null;
-  return {
+  const index = {
     ...sourceIndex,
+    pit: runtimeTrack ? createPitQueryIndex(runtimeTrack, sourceIndex.grid?.cellSize ?? DEFAULT_GRID_CELL_SIZE) : sourceIndex.pit,
     stats: createQueryStats(),
-    queryScratch: createQueryScratch(sourceIndex),
   };
+  index.queryScratch = createQueryScratch(index);
+  return index;
 }
 
 export function resetTrackQueryStats(track) {
@@ -422,35 +430,6 @@ export function snapshotTrackQueryStats(track) {
   return stats ? JSON.parse(JSON.stringify(stats)) : null;
 }
 
-function createQueryStats() {
-  return {
-    nearestQueries: 0,
-    nearestFallbacks: 0,
-    nearestPaths: {},
-    nearestFallbackReasons: {
-      'spatial-grid-no-candidates': 0,
-    },
-    pitQueries: 0,
-    pitFallbacks: 0,
-    pitPaths: {},
-    pitFallbackReasons: {},
-  };
-}
-
-function recordFallback(index, bucket, reason) {
-  if (!index?.stats) return;
-  if (bucket.startsWith('nearest')) index.stats.nearestFallbacks += 1;
-  if (bucket.startsWith('pit')) index.stats.pitFallbacks += 1;
-  recordStat(index, bucket, reason);
-}
-
-function recordStat(index, bucket, reason) {
-  if (!index?.stats || !reason) return;
-  const target = index.stats[bucket] ?? {};
-  target[reason] = (target[reason] ?? 0) + 1;
-  index.stats[bucket] = target;
-}
-
 function createTrackBands(track) {
   const trackEdge = track.width / 2;
   const kerbEdge = trackEdge + (track.kerbWidth ?? 0);
@@ -559,18 +538,6 @@ function expandedSampleBounds(samples, expansion) {
   };
 }
 
-function createSpatialGrid(bounds, cellSize) {
-  const columns = Math.max(1, Math.ceil((bounds.maxX - bounds.minX) / cellSize));
-  const rows = Math.max(1, Math.ceil((bounds.maxY - bounds.minY) / cellSize));
-  return {
-    bounds,
-    cellSize,
-    columns,
-    rows,
-    cells: new Array(columns * rows),
-  };
-}
-
 function insertSegmentIntoGrid(grid, centerline, segmentId, expansion) {
   insertIdIntoGridBounds(grid, segmentId, {
     minX: centerline.minX[segmentId] - expansion,
@@ -580,19 +547,6 @@ function insertSegmentIntoGrid(grid, centerline, segmentId, expansion) {
   });
 }
 
-function insertIdIntoGridBounds(grid, id, bounds) {
-  const minCell = gridCellForPoint(grid, { x: bounds.minX, y: bounds.minY }, true);
-  const maxCell = gridCellForPoint(grid, { x: bounds.maxX, y: bounds.maxY }, true);
-  for (let row = minCell.row; row <= maxCell.row; row += 1) {
-    for (let column = minCell.column; column <= maxCell.column; column += 1) {
-      const cellIndex = row * grid.columns + column;
-      const cell = grid.cells[cellIndex];
-      if (cell) cell.push(id);
-      else grid.cells[cellIndex] = [id];
-    }
-  }
-}
-
 function candidateIdsFromArcBuckets(index, distanceAlong, radius) {
   const arcBuckets = index?.arcBuckets;
   if (!arcBuckets?.count || !Number.isFinite(distanceAlong)) return [];
@@ -613,73 +567,6 @@ function candidateIdsFromArcBuckets(index, distanceAlong, radius) {
   return ids;
 }
 
-function candidateIdsFromGrid(index, grid, position, neighborLimit) {
-  const center = gridCellForPoint(grid, position, false);
-  if (!center) return [];
-  const scratch = ensureQueryScratch(index);
-  const maxId = Math.max(index.centerline.segmentCount, index.pit?.roadSegments?.length ?? 0, index.pit?.boxCandidates?.length ?? 0);
-  const idMarks = ensureScratchArray(scratch, 'candidateMarks', maxId);
-  const ids = [];
-  for (let radius = 0; radius <= neighborLimit; radius += 1) {
-    const candidateEpoch = nextScratchEpoch(scratch, 'candidateEpoch', idMarks);
-    ids.length = 0;
-    for (let row = center.row - radius; row <= center.row + radius; row += 1) {
-      for (let column = center.column - radius; column <= center.column + radius; column += 1) {
-        if (column < 0 || row < 0 || column >= grid.columns || row >= grid.rows) continue;
-        const cell = grid.cells[row * grid.columns + column];
-        if (!cell) continue;
-        for (const id of cell) {
-          if (idMarks[id] === candidateEpoch) continue;
-          idMarks[id] = candidateEpoch;
-          ids.push(id);
-        }
-      }
-    }
-    if (ids.length) return ids.slice();
-  }
-  return [];
-}
-
-function candidateIdsFromGridBounds(index, grid, bounds) {
-  if (
-    bounds.maxX < grid.bounds.minX ||
-    bounds.minX > grid.bounds.maxX ||
-    bounds.maxY < grid.bounds.minY ||
-    bounds.minY > grid.bounds.maxY
-  ) return [];
-  const minPoint = { x: bounds.minX, y: bounds.minY };
-  const maxPoint = { x: bounds.maxX, y: bounds.maxY };
-  const minCell = gridCellForPoint(grid, minPoint, true);
-  const maxCell = gridCellForPoint(grid, maxPoint, true);
-  const scratch = ensureQueryScratch(index);
-  const maxId = Math.max(index.centerline.segmentCount, index.pit?.roadSegments?.length ?? 0, index.pit?.boxCandidates?.length ?? 0);
-  const idMarks = ensureScratchArray(scratch, 'candidateMarks', maxId);
-  const candidateEpoch = nextScratchEpoch(scratch, 'candidateEpoch', idMarks);
-  const ids = [];
-  for (let row = minCell.row; row <= maxCell.row; row += 1) {
-    for (let column = minCell.column; column <= maxCell.column; column += 1) {
-      const cell = grid.cells[row * grid.columns + column];
-      if (!cell) continue;
-      for (const id of cell) {
-        if (idMarks[id] === candidateEpoch) continue;
-        idMarks[id] = candidateEpoch;
-        ids.push(id);
-      }
-    }
-  }
-  return ids;
-}
-
-function gridCellForPoint(grid, point, clampToGrid) {
-  const column = Math.floor((point.x - grid.bounds.minX) / grid.cellSize);
-  const row = Math.floor((point.y - grid.bounds.minY) / grid.cellSize);
-  if (!clampToGrid && (column < 0 || row < 0 || column >= grid.columns || row >= grid.rows)) return null;
-  return {
-    column: clampToGrid ? clamp(column, 0, grid.columns - 1) : column,
-    row: clampToGrid ? clamp(row, 0, grid.rows - 1) : row,
-  };
-}
-
 function projectIndexedSegment(centerline, segmentId, position) {
   const ax = centerline.startX[segmentId];
   const ay = centerline.startY[segmentId];
@@ -733,134 +620,6 @@ function segmentFromIndex(centerline, segmentId) {
   };
 }
 
-function createPitQueryIndex(track, cellSize) {
-  const pitLane = track.pitLane;
-  if (!pitLane?.enabled) return null;
-  const bounds = {
-    minX: pitLane.bounds.minX - cellSize,
-    maxX: pitLane.bounds.maxX + cellSize,
-    minY: pitLane.bounds.minY - cellSize,
-    maxY: pitLane.bounds.maxY + cellSize,
-  };
-  const roadGrid = createSpatialGrid(bounds, cellSize);
-  const boxGrid = createSpatialGrid(bounds, cellSize);
-  const roadSegments = [];
-  const routes = {};
-
-  [
-    ['entry', pitLane.entry?.roadCenterline],
-    ['main', pitLane.mainLane?.points],
-    ['working', pitLane.workingLane?.points],
-    ['exit', pitLane.exit?.roadCenterline],
-  ].forEach(([routeId, points]) => {
-    routes[routeId] = { start: roadSegments.length };
-    indexPitRoute(roadGrid, roadSegments, routeId, points, cellSize);
-    routes[routeId].end = roadSegments.length;
-  });
-
-  const boxCandidates = [];
-  [
-    ...(pitLane.serviceAreas ?? []).flatMap((area) => [
-      { type: 'service-area', target: area, polygon: area.corners },
-      { type: 'service-queue', target: area, polygon: area.queueCorners },
-    ]),
-    ...(pitLane.boxes ?? []).map((box) => ({ type: 'garage-box', target: box, polygon: box.corners })),
-  ]
-    .filter((candidate) => Array.isArray(candidate.polygon) && candidate.polygon.length >= 3)
-    .forEach((candidate) => {
-      const id = boxCandidates.length;
-      boxCandidates.push(candidate);
-      insertIdIntoGridBounds(boxGrid, id, polygonBounds(candidate.polygon, cellSize));
-    });
-
-  return {
-    roadGrid,
-    boxGrid,
-    routes,
-    roadSegments,
-    boxCandidates,
-  };
-}
-
-function indexPitRoute(grid, roadSegments, routeId, points, expansion) {
-  if (!Array.isArray(points) || points.length < 2) return;
-  for (let index = 0; index < points.length - 1; index += 1) {
-    const start = points[index];
-    const end = points[index + 1];
-    const id = roadSegments.length;
-    roadSegments.push({ routeId, segmentIndex: index });
-    const bounds = {
-      minX: Math.min(start.x, end.x) - expansion,
-      maxX: Math.max(start.x, end.x) + expansion,
-      minY: Math.min(start.y, end.y) - expansion,
-      maxY: Math.max(start.y, end.y) + expansion,
-    };
-    insertIdIntoGridBounds(grid, id, bounds);
-  }
-}
-
-function polygonBounds(polygon, expansion) {
-  const bounds = polygon.reduce((current, point) => ({
-    minX: Math.min(current.minX, point.x),
-    maxX: Math.max(current.maxX, point.x),
-    minY: Math.min(current.minY, point.y),
-    maxY: Math.max(current.maxY, point.y),
-  }), { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity });
-  return {
-    minX: bounds.minX - expansion,
-    maxX: bounds.maxX + expansion,
-    minY: bounds.minY - expansion,
-    maxY: bounds.maxY + expansion,
-  };
-}
-
-function createQueryScratch(index) {
-  const segmentCount = Math.max(0, index?.centerline?.segmentCount ?? 0);
-  const maxId = Math.max(
-    segmentCount,
-    index?.pit?.roadSegments?.length ?? 0,
-    index?.pit?.boxCandidates?.length ?? 0,
-  );
-  const grid = index?.segmentGrid ?? index?.grid;
-  const cellCount = Math.max(0, (grid?.columns ?? 0) * (grid?.rows ?? 0));
-  return {
-    candidateMarks: new Uint32Array(Math.max(1, maxId)),
-    candidateEpoch: 1,
-    sampleMarks: new Uint32Array(Math.max(1, segmentCount)),
-    sampleEpoch: 1,
-    raySegmentMarks: new Uint32Array(Math.max(1, segmentCount)),
-    raySegmentEpoch: 1,
-    rayCellMarks: new Uint32Array(Math.max(1, cellCount)),
-    rayCellEpoch: 1,
-    raySegmentIds: [],
-    rayVisitedCells: [],
-    rayTraceCache: new Map(),
-  };
-}
-
-function ensureQueryScratch(index) {
-  if (index.queryScratch) return index.queryScratch;
-  index.queryScratch = createQueryScratch(index);
-  return index.queryScratch;
-}
-
-function ensureScratchArray(scratch, key, minimumLength) {
-  if (!scratch[key] || scratch[key].length < minimumLength) {
-    scratch[key] = new Uint32Array(Math.max(1, minimumLength));
-  }
-  return scratch[key];
-}
-
-function nextScratchEpoch(scratch, key, marks) {
-  let epoch = (scratch[key] ?? 0) + 1;
-  if (epoch >= 0xFFFFFFFF) {
-    marks.fill(0);
-    epoch = 1;
-  }
-  scratch[key] = epoch;
-  return epoch;
-}
-
 function seedRayTraceFromNearbyCache(
   index,
   grid,