murow 0.0.60 → 0.0.71

package/src/core/navmesh/navmesh.ts

@@ -1,1047 +0,0 @@
-type ObstacleId = number;
-
-export type Obstacle =
-  | CircleObstacle
-  | RectObstacle
-  | PolygonObstacle;
-
-/**
- * NavMesh configuration options
- */
-export interface NavMeshOptions<TWorkers extends boolean | 'auto' = false> {
-  /**
-   * Enable Web Workers for pathfinding
-   *
-   * - `false` (default): Synchronous pathfinding on main thread
-   * - `true`: Always use worker pool (4 workers)
-   * - `'auto'`: Automatically use workers when beneficial (>= 20 pending paths)
-   *
-   * @default false
-   *
-   * @remarks
-   * Workers provide 3-4.5x speedup for parallel pathfinding (20+ concurrent requests).
-   * For single/sequential pathfinding, sync is faster due to message passing overhead (~0.5ms).
-   *
-   * Use 'auto' for games where pathfinding load varies (e.g., RTS with unit groups).
-   */
-  workers?: TWorkers;
-
-  /**
-   * Number of workers to spawn (only used when workers = true)
-   * @default 4
-   */
-  workerPoolSize?: number;
-
-  /**
-   * Path to worker script (required if workers = true and running in browser)
-   * For Node.js/Bun, this is handled automatically
-   * @example './navmesh.worker.js'
-   */
-  workerPath?: string;
-}
-
-/**
- * Helper type to determine return type based on worker configuration
- */
-type PathResult<TWorkers extends boolean | 'auto' | undefined> =
-  TWorkers extends false | undefined
-    ? Vec2[]  // Sync only
-    : TWorkers extends true
-      ? Promise<Vec2[]>  // Always async
-      : Vec2[] | Promise<Vec2[]>;  // Auto: can be either
-
-export type ObstacleInput =
-  | Omit<CircleObstacle, 'id'>
-  | Omit<RectObstacle, 'id'>
-  | Omit<PolygonObstacle, 'id'>;
-
-interface Vec2 {
-  x: number;
-  y: number;
-}
-
-interface BaseObstacle {
-  id: ObstacleId;
-  type: 'circle' | 'rect' | 'polygon';
-  solid?: boolean; // default true
-}
-
-export interface CircleObstacle extends BaseObstacle {
-  type: 'circle';
-  pos: Vec2;
-  radius: number;
-}
-
-export interface RectObstacle extends BaseObstacle {
-  type: 'rect';
-  pos: Vec2; // bottom-left corner
-  size: Vec2;
-  rotation?: number; // radians, around center
-}
-
-/**
- * Polygon obstacle.
- * IMPORTANT: `points` must be defined relative to local origin (0,0).
- * The polygon will be rotated around (0,0) then translated to `pos`.
- * Do NOT define points in world space.
- */
-export interface PolygonObstacle extends BaseObstacle {
-  type: 'polygon';
-  points: Vec2[]; // MUST be relative to (0,0)
-  pos: Vec2; // world position
-  rotation?: number; // radians, around local origin (0,0)
-}
-
-/* ---------------------------------- */
-/* Utils                              */
-/* ---------------------------------- */
-
-const dirs = [
-  { x: 1, y: 0 },
-  { x: -1, y: 0 },
-  { x: 0, y: 1 },
-  { x: 0, y: -1 },
-];
-
-/**
- * Converts world coordinates to grid cell coordinates (floor).
- */
-const toCell = (v: Vec2): Vec2 => ({
-  x: Math.floor(v.x),
-  y: Math.floor(v.y),
-});
-
-/**
- * Converts grid cell coordinates to world coordinates (cell center).
- */
-const fromCell = (v: Vec2): Vec2 => ({ 
-  x: v.x + 0.5, 
-  y: v.y + 0.5 
-});
-
-/**
- * Generates unique sequential IDs for obstacles.
- */
-const genId = (() => {
-  let i = 1;
-  return () => i++;
-})();
-
-/**
- * Encodes grid coordinates as a single integer for use as Map/Set keys.
- * Uses 32-bit safe packing: lower 16 bits = x, upper 16 bits = y.
- * Supports coordinates in range [-32768, 32767].
- */
-const encodeCell = (x: number, y: number): number =>
-  (x & 0xffff) | ((y & 0xffff) << 16);
-
-/**
- * Decodes an encoded cell back to {x, y}.
- * Properly handles sign extension for negative coordinates.
- */
-const decodeCell = (n: number): Vec2 => ({
-  x: (n << 16) >> 16,
-  y: n >> 16,
-});
-
-/* ---------------------------------- */
-/* Binary Heap (Priority Queue)      */
-/* ---------------------------------- */
-
-/**
- * Min-heap priority queue for A*.
- * Supports O(log n) insert and extract-min operations.
- */
-class BinaryHeap<T> {
-  private heap: T[] = [];
-  
-  constructor(private scoreFn: (item: T) => number) {}
-
-  push(item: T) {
-    this.heap.push(item);
-    this.bubbleUp(this.heap.length - 1);
-  }
-
-  pop(): T | undefined {
-    const result = this.heap[0];
-    const end = this.heap.pop();
-    
-    if (this.heap.length > 0 && end !== undefined) {
-      this.heap[0] = end;
-      this.sinkDown(0);
-    }
-    
-    return result;
-  }
-
-  get size(): number {
-    return this.heap.length;
-  }
-
-  private bubbleUp(n: number) {
-    const element = this.heap[n];
-    const score = this.scoreFn(element);
-    
-    while (n > 0) {
-      const parentN = ((n + 1) >> 1) - 1;
-      const parent = this.heap[parentN];
-      
-      if (score >= this.scoreFn(parent)) break;
-      
-      this.heap[parentN] = element;
-      this.heap[n] = parent;
-      n = parentN;
-    }
-  }
-
-  private sinkDown(n: number) {
-    const length = this.heap.length;
-    const element = this.heap[n];
-    const elemScore = this.scoreFn(element);
-
-    while (true) {
-      const child2N = (n + 1) << 1;
-      const child1N = child2N - 1;
-      let swap: number | null = null;
-      let child1Score: number;
-
-      if (child1N < length) {
-        const child1 = this.heap[child1N];
-        child1Score = this.scoreFn(child1);
-        if (child1Score < elemScore) {
-          swap = child1N;
-        }
-      }
-
-      if (child2N < length) {
-        const child2 = this.heap[child2N];
-        const child2Score = this.scoreFn(child2);
-        if (child2Score < (swap === null ? elemScore : child1Score!)) {
-          swap = child2N;
-        }
-      }
-
-      if (swap === null) break;
-
-      this.heap[n] = this.heap[swap];
-      this.heap[swap] = element;
-      n = swap;
-    }
-  }
-}
-
-/* ---------------------------------- */
-/* Spatial Hash                       */
-/* ---------------------------------- */
-
-/**
- * Spatial hash for fast obstacle queries.
- * Divides space into fixed-size cells and indexes obstacles by cell.
- * Provides O(1) average case lookup instead of O(n) linear scan.
- * 
- * Cell size = 1 matches grid pathfinding unit cells.
- */
-class SpatialHash {
-  private cellSize: number;
-  private grid = new Map<number, Set<ObstacleId>>();
-  private obstacleCells = new Map<ObstacleId, Set<number>>();
-
-  constructor(cellSize = 1) {
-    this.cellSize = cellSize;
-  }
-
-  /**
-   * Returns hash key for a world position.
-   */
-  private hash(x: number, y: number): number {
-    const cx = Math.floor(x / this.cellSize);
-    const cy = Math.floor(y / this.cellSize);
-    return encodeCell(cx, cy);
-  }
-
-  /**
-   * Adds an obstacle to the spatial hash.
-   */
-  add(id: ObstacleId, obstacle: Obstacle) {
-    const cells = this.getCellsForObstacle(obstacle);
-    
-    for (const cell of cells) {
-      if (!this.grid.has(cell)) {
-        this.grid.set(cell, new Set());
-      }
-      this.grid.get(cell)!.add(id);
-    }
-    
-    this.obstacleCells.set(id, cells);
-  }
-
-  /**
-   * Removes an obstacle from the spatial hash.
-   */
-  remove(id: ObstacleId) {
-    const cells = this.obstacleCells.get(id);
-    if (!cells) return;
-    
-    for (const cell of cells) {
-      const bucket = this.grid.get(cell);
-      if (bucket) {
-        bucket.delete(id);
-        if (bucket.size === 0) {
-          this.grid.delete(cell);
-        }
-      }
-    }
-    
-    this.obstacleCells.delete(id);
-  }
-
-  /**
-   * Returns obstacle IDs that might contain the given point.
-   */
-  query(pos: Vec2): Set<ObstacleId> {
-    const cell = this.hash(pos.x, pos.y);
-    return this.grid.get(cell) || new Set();
-  }
-
-  /**
-   * Clears the entire spatial hash.
-   */
-  clear() {
-    this.grid.clear();
-    this.obstacleCells.clear();
-  }
-
-  /**
-   * Determines which cells an obstacle overlaps.
-   */
-  private getCellsForObstacle(o: Obstacle): Set<number> {
-    const cells = new Set<number>();
-    
-    if (o.type === 'circle') {
-      const r = o.radius;
-      const minX = Math.floor((o.pos.x - r) / this.cellSize);
-      const maxX = Math.floor((o.pos.x + r) / this.cellSize);
-      const minY = Math.floor((o.pos.y - r) / this.cellSize);
-      const maxY = Math.floor((o.pos.y + r) / this.cellSize);
-      
-      for (let x = minX; x <= maxX; x++) {
-        for (let y = minY; y <= maxY; y++) {
-          cells.add(encodeCell(x, y));
-        }
-      }
-    } else if (o.type === 'rect') {
-      const cx = o.pos.x + o.size.x / 2;
-      const cy = o.pos.y + o.size.y / 2;
-      const hw = o.size.x / 2;
-      const hh = o.size.y / 2;
-      const diagonal = Math.sqrt(hw * hw + hh * hh);
-      
-      const minX = Math.floor((cx - diagonal) / this.cellSize);
-      const maxX = Math.floor((cx + diagonal) / this.cellSize);
-      const minY = Math.floor((cy - diagonal) / this.cellSize);
-      const maxY = Math.floor((cy + diagonal) / this.cellSize);
-      
-      for (let x = minX; x <= maxX; x++) {
-        for (let y = minY; y <= maxY; y++) {
-          cells.add(encodeCell(x, y));
-        }
-      }
-    } else if (o.type === 'polygon') {
-      const bounds = getPolygonBounds(o);
-      const minX = Math.floor(bounds.minX / this.cellSize);
-      const maxX = Math.floor(bounds.maxX / this.cellSize);
-      const minY = Math.floor(bounds.minY / this.cellSize);
-      const maxY = Math.floor(bounds.maxY / this.cellSize);
-      
-      for (let x = minX; x <= maxX; x++) {
-        for (let y = minY; y <= maxY; y++) {
-          cells.add(encodeCell(x, y));
-        }
-      }
-    }
-    
-    return cells;
-  }
-}
-
-/* ---------------------------------- */
-/* Geometry helpers                   */
-/* ---------------------------------- */
-
-/**
- * Tests if a point is inside a circle obstacle.
- */
-function pointInCircle(p: Vec2, c: CircleObstacle): boolean {
-  const dx = p.x - c.pos.x;
-  const dy = p.y - c.pos.y;
-  return dx * dx + dy * dy <= c.radius * c.radius;
-}
-
-/**
- * Tests if a point is inside a rectangle obstacle.
- * Handles rotation around the rectangle's center.
- */
-function pointInRect(p: Vec2, r: RectObstacle): boolean {
-  const cx = r.pos.x + r.size.x / 2;
-  const cy = r.pos.y + r.size.y / 2;
-  
-  if (r.rotation) {
-    const cos = Math.cos(-r.rotation);
-    const sin = Math.sin(-r.rotation);
-    const dx = p.x - cx;
-    const dy = p.y - cy;
-    const localX = dx * cos - dy * sin;
-    const localY = dx * sin + dy * cos;
-    
-    return Math.abs(localX) <= r.size.x / 2 && 
-           Math.abs(localY) <= r.size.y / 2;
-  }
-  
-  return (
-    p.x >= r.pos.x &&
-    p.y >= r.pos.y &&
-    p.x <= r.pos.x + r.size.x &&
-    p.y <= r.pos.y + r.size.y
-  );
-}
-
-/**
- * Tests if a point is inside a polygon obstacle using ray casting.
- * REQUIRES: polygon.points are defined relative to local origin (0,0).
- * Uses numerically stable intersection test.
- */
-function pointInPolygon(p: Vec2, poly: PolygonObstacle): boolean {
-  let inside = false;
-  const pts = poly.points;
-  const cos = poly.rotation ? Math.cos(poly.rotation) : 1;
-  const sin = poly.rotation ? Math.sin(poly.rotation) : 0;
-
-  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
-    let xi = pts[i].x;
-    let yi = pts[i].y;
-    let xj = pts[j].x;
-    let yj = pts[j].y;
-
-    if (poly.rotation) {
-      const tempXi = xi * cos - yi * sin;
-      const tempYi = xi * sin + yi * cos;
-      const tempXj = xj * cos - yj * sin;
-      const tempYj = xj * sin + yj * cos;
-      xi = tempXi;
-      yi = tempYi;
-      xj = tempXj;
-      yj = tempYj;
-    }
-
-    xi += poly.pos.x;
-    yi += poly.pos.y;
-    xj += poly.pos.x;
-    yj += poly.pos.y;
-
-    // Stable ray casting test
-    const intersect =
-      (yi > p.y) !== (yj > p.y) &&
-      p.x < ((xj - xi) * (p.y - yi)) / (yj - yi) + xi;
-
-    if (intersect) inside = !inside;
-  }
-
-  return inside;
-}
-
-/**
- * Computes axis-aligned bounding box for a transformed polygon.
- */
-function getPolygonBounds(poly: PolygonObstacle): {
-  minX: number;
-  minY: number;
-  maxX: number;
-  maxY: number;
-} {
-  let minX = Infinity, minY = Infinity;
-  let maxX = -Infinity, maxY = -Infinity;
-  
-  const cos = poly.rotation ? Math.cos(poly.rotation) : 1;
-  const sin = poly.rotation ? Math.sin(poly.rotation) : 0;
-  
-  for (const p of poly.points) {
-    let x = p.x;
-    let y = p.y;
-    
-    if (poly.rotation) {
-      const tx = x * cos - y * sin;
-      const ty = x * sin + y * cos;
-      x = tx;
-      y = ty;
-    }
-    
-    x += poly.pos.x;
-    y += poly.pos.y;
-    
-    minX = Math.min(minX, x);
-    minY = Math.min(minY, y);
-    maxX = Math.max(maxX, x);
-    maxY = Math.max(maxY, y);
-  }
-  
-  return { minX, minY, maxX, maxY };
-}
-
-/* ---------------------------------- */
-/* Obstacles                          */
-/* ---------------------------------- */
-
-/**
- * Manages obstacles with spatial hashing for fast queries.
- * Version tracking prevents unnecessary rebuilds.
- */
-class Obstacles {
-  private items = new Map<ObstacleId, Obstacle>();
-  private spatial = new SpatialHash(1); // Match grid cell size
-  private _cachedItems: Obstacle[] = [];
-  dirty = true;
-  version = 0;
-
-  add(obstacle: ObstacleInput): ObstacleId {
-    const id = genId();
-    const newObstacle = { ...obstacle, id } as Obstacle;
-    this.items.set(id, newObstacle);
-    this.spatial.add(id, newObstacle);
-    this.dirty = true;
-    this.version++;
-    return id;
-  }
-
-  move(id: ObstacleId, pos: Vec2) {
-    const o = this.items.get(id);
-    if (!o) return;
-    
-    // Remove from old position in spatial hash
-    this.spatial.remove(id);
-    
-    // Create updated obstacle
-    const updated = {
-      ...o,
-      pos: { ...pos },
-    };
-    
-    this.items.set(id, updated as Obstacle);
-    this.spatial.add(id, updated as Obstacle);
-    this.dirty = true;
-    this.version++;
-  }
-
-  remove(id: ObstacleId) {
-    this.spatial.remove(id);
-    this.items.delete(id);
-    this.dirty = true;
-    this.version++;
-  }
-
-  /**
-   * Fast spatial query using hash grid.
-   * O(1) average case instead of O(n) linear scan.
-   */
-  at(pos: Vec2): Obstacle | undefined {
-    const candidates = this.spatial.query(pos);
-    
-    for (const id of candidates) {
-      const o = this.items.get(id);
-      if (!o || o.solid === false) continue;
-
-      if (o.type === 'circle' && pointInCircle(pos, o)) return o;
-      if (o.type === 'rect' && pointInRect(pos, o)) return o;
-      if (o.type === 'polygon' && pointInPolygon(pos, o)) return o;
-    }
-  }
-
-  get values(): Obstacle[] {
-    if (!this.dirty) return this._cachedItems;
-    this._cachedItems = [...this.items.values()];
-    this.dirty = false;
-    return this._cachedItems;
-  }
-}
-
-/* ---------------------------------- */
-/* Grid Nav                           */
-/* ---------------------------------- */
-
-/**
- * Grid navigation with simple full rebuild.
- * Fast enough for most games (< 1000 obstacles).
- * 
- * Performance: O(n * area) where n = obstacle count.
- * Typical rebuild time: < 1ms for 100 obstacles on 100x100 grid.
- */
-class GridNav {
-  private blocked = new Set<number>();
-
-  constructor(private obstacles: Obstacles) {}
-
-  /**
-   * Rebuilds the entire blocked cell set.
-   * Simple and correct - no incremental complexity.
-   */
-  rebuild() {
-    this.blocked.clear();
-
-    for (const o of this.obstacles.values) {
-      if (o.solid === false) continue;
-
-      if (o.type === 'circle') {
-        const r = Math.ceil(o.radius);
-        const cx = Math.floor(o.pos.x);
-        const cy = Math.floor(o.pos.y);
-        
-        for (let dx = -r; dx <= r; dx++) {
-          for (let dy = -r; dy <= r; dy++) {
-            const cellX = cx + dx;
-            const cellY = cy + dy;
-            const cellCenter = { x: cellX + 0.5, y: cellY + 0.5 };
-            if (pointInCircle(cellCenter, o)) {
-              this.blocked.add(encodeCell(cellX, cellY));
-            }
-          }
-        }
-      } else if (o.type === 'rect') {
-        const cx = o.pos.x + o.size.x / 2;
-        const cy = o.pos.y + o.size.y / 2;
-        const hw = o.size.x / 2;
-        const hh = o.size.y / 2;
-        const diagonal = Math.sqrt(hw * hw + hh * hh);
-        
-        const minX = Math.floor(cx - diagonal);
-        const maxX = Math.ceil(cx + diagonal);
-        const minY = Math.floor(cy - diagonal);
-        const maxY = Math.ceil(cy + diagonal);
-        
-        for (let x = minX; x <= maxX; x++) {
-          for (let y = minY; y <= maxY; y++) {
-            const cellCenter = { x: x + 0.5, y: y + 0.5 };
-            if (pointInRect(cellCenter, o)) {
-              this.blocked.add(encodeCell(x, y));
-            }
-          }
-        }
-      } else if (o.type === 'polygon') {
-        const bounds = getPolygonBounds(o);
-        const minX = Math.floor(bounds.minX);
-        const maxX = Math.ceil(bounds.maxX);
-        const minY = Math.floor(bounds.minY);
-        const maxY = Math.ceil(bounds.maxY);
-        
-        for (let x = minX; x <= maxX; x++) {
-          for (let y = minY; y <= maxY; y++) {
-            const cellCenter = { x: x + 0.5, y: y + 0.5 };
-            if (pointInPolygon(cellCenter, o)) {
-              this.blocked.add(encodeCell(x, y));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  findPath(from: Vec2, to: Vec2): Vec2[] {
-    return aStar(
-      toCell(from),
-      toCell(to),
-      (x, y) => !this.blocked.has(encodeCell(x, y))
-    ).map(fromCell);
-  }
-}
-
-/* ---------------------------------- */
-/* Graph Nav                          */
-/* ---------------------------------- */
-
-/**
- * Line-of-sight navigation with grid fallback.
- * Not a true navmesh - use GridNav for production.
- */
-class GraphNav {
-  constructor(private obstacles: Obstacles) {}
-
-  rebuild() {}
-
-  findPath(from: Vec2, to: Vec2): Vec2[] {
-    // Uniform sampling along path for LOS check
-    const steps = Math.ceil(
-      Math.hypot(to.x - from.x, to.y - from.y) * 2
-    );
-    
-    let blocked = false;
-    
-    for (let i = 1; i <= steps; i++) {
-      const t = i / steps;
-      const p = {
-        x: from.x + (to.x - from.x) * t,
-        y: from.y + (to.y - from.y) * t,
-      };
-      
-      if (this.obstacles.at(p)) {
-        blocked = true;
-        break;
-      }
-    }
-    
-    if (!blocked) {
-      return [from, to];
-    }
-    
-    // Fallback to grid A*
-    const cellPath = aStar(
-      toCell(from), 
-      toCell(to), 
-      (x, y) => {
-        const p = { x: x + 0.5, y: y + 0.5 };
-        return !this.obstacles.at(p);
-      }
-    );
-    
-    return cellPath.map(fromCell);
-  }
-}
-
-/* ---------------------------------- */
-/* NavMesh                            */
-/* ---------------------------------- */
-
-type NavType = 'grid' | 'graph';
-
-/**
- * Navigation mesh with spatial hashing and smart rebuild.
- *
- * Features:
- * - Spatial hash: O(1) obstacle queries
- * - Version tracking: zero unnecessary rebuilds
- * - Binary heap A*: handles 10k+ node searches
- * - Simple full rebuild: correct and fast enough
- * - Optional Web Workers: 3-4.5x speedup for parallel pathfinding
- *
- * Performance characteristics:
- * - Obstacle query: O(1) average via spatial hash
- * - Grid rebuild: O(n * area), < 1ms for typical games
- * - Pathfinding: O(b^d * log n) with binary heap
- * - Worker overhead: ~0.5ms per request (use for 20+ concurrent paths)
- *
- * Production ready for:
- * - Grid-based games
- * - RTS with < 1000 dynamic obstacles
- * - Turn-based games
- * - Moderate map sizes (< 1M cells)
- *
- * @example
- * ```ts
- * // Simple usage (synchronous) - typed as Vec2[]
- * const navmesh = new NavMesh('grid');
- * const path = navmesh.findPath({ from: {x:0, y:0}, to: {x:10, y:10} });
- *
- * // With workers (automatic) - typed as Vec2[] | Promise<Vec2[]>
- * const navmesh = new NavMesh('grid', { workers: 'auto' });
- * const path = await navmesh.findPath({ from: {x:0, y:0}, to: {x:10, y:10} });
- *
- * // With workers (always) - typed as Promise<Vec2[]>
- * const navmesh = new NavMesh('grid', { workers: true });
- * const path = await navmesh.findPath({ from: {x:0, y:0}, to: {x:10, y:10} });
- * ```
- */
-export class NavMesh<TWorkers extends boolean | 'auto' = false> {
-  private grid?: GridNav;
-  private graph?: GraphNav;
-  private lastVersion = -1;
-  obstacles: Obstacles;
-
-  // Worker support
-  private options: Required<NavMeshOptions<TWorkers>>;
-  private workerPool?: any; // Lazy-loaded NavMeshWorkerPool
-  private pendingPaths = 0;
-  private readonly AUTO_WORKER_THRESHOLD = 20; // Use workers when >= 20 pending paths
-
-  constructor(
-    private type: NavType,
-    options?: NavMeshOptions<TWorkers>
-  ) {
-    this.obstacles = new Obstacles();
-
-    // Set defaults - cast to any to avoid complex type gymnastics
-    this.options = {
-      workers: (options?.workers ?? false) as any,
-      workerPoolSize: options?.workerPoolSize ?? 4,
-      workerPath: options?.workerPath ?? './navmesh.worker.js',
-    };
-
-    // Initialize sync navigation
-    if (type === 'grid') this.grid = new GridNav(this.obstacles);
-    if (type === 'graph') this.graph = new GraphNav(this.obstacles);
-
-    // Initialize worker pool if workers = true
-    if (this.options.workers === true) {
-      this.initWorkerPool();
-    }
-  }
-
-  /**
-   * Lazy initialize worker pool
-   */
-  private async initWorkerPool() {
-    if (this.workerPool) return;
-
-    try {
-      // Dynamic import to avoid bundling worker pool if not needed
-      const { NavMeshWorkerPool } = await import('./navmesh-worker-pool');
-
-      this.workerPool = new NavMeshWorkerPool(
-        this.options.workerPoolSize,
-        this.options.workerPath,
-        this.type,
-        this.obstacles.values
-      );
-
-      await this.workerPool.init();
-    } catch (error) {
-      console.warn('Failed to initialize worker pool, falling back to sync:', error);
-      this.options.workers = false as any; // Disable workers on failure
-    }
-  }
-
-  /**
-   * Check if we should use workers for this request
-   */
-  private shouldUseWorkers(): boolean {
-    if (this.options.workers === false) return false;
-    if (this.options.workers === true) return true;
-
-    // Auto mode: use workers if we have many pending paths
-    return this.pendingPaths >= this.AUTO_WORKER_THRESHOLD;
-  }
-
-  /**
-   * Adds an obstacle and returns its unique ID.
-   * For polygons: ensure points are defined relative to (0,0).
-   */
-  addObstacle(obstacle: ObstacleInput): ObstacleId {
-    return this.obstacles.add(obstacle);
-  }
-
-  /**
-   * Moves an existing obstacle to a new position.
-   */
-  moveObstacle(id: ObstacleId, pos: Vec2) {
-    this.obstacles.move(id, pos);
-  }
-
-  /**
-   * Removes an obstacle by ID.
-   */
-  removeObstacle(id: ObstacleId) {
-    this.obstacles.remove(id);
-  }
-
-  /**
-   * Returns all current obstacles.
-   */
-  getObstacles(): Obstacle[] {
-    return this.obstacles.values;
-  }
-
-  /**
-   * Finds a path from start to goal.
-   * Automatically rebuilds navigation data if obstacles changed.
-   * Returns empty array if no path exists.
-   *
-   * @remarks
-   * - If workers are disabled (false): Returns Vec2[] synchronously
-   * - If workers are enabled (true): Returns Promise<Vec2[]>
-   * - If workers are 'auto': Returns Vec2[] | Promise<Vec2[]> based on load
-   *
-   * @example
-   * ```ts
-   * // Synchronous (no workers) - typed as Vec2[]
-   * const navmesh = new NavMesh('grid');
-   * const path = navmesh.findPath({ from, to });
-   *
-   * // Asynchronous (with workers) - typed as Promise<Vec2[]>
-   * const navmesh = new NavMesh('grid', { workers: true });
-   * const path = await navmesh.findPath({ from, to });
-   *
-   * // Auto mode - typed as Vec2[] | Promise<Vec2[]>
-   * const navmesh = new NavMesh('grid', { workers: 'auto' });
-   * const result = navmesh.findPath({ from, to });
-   * const path = result instanceof Promise ? await result : result;
-   * ```
-   */
-  findPath({ from, to }: { from: Vec2; to: Vec2 }): PathResult<TWorkers> {
-    // Check if we should use workers
-    if (this.shouldUseWorkers() && this.workerPool) {
-      // Async path (with workers)
-      this.pendingPaths++;
-      return this.findPathAsync(from, to).finally(() => {
-        this.pendingPaths--;
-      }) as PathResult<TWorkers>;
-    }
-
-    // Sync path (no workers)
-    this.rebuild();
-    return (this.type === 'grid'
-      ? this.grid!.findPath(from, to)
-      : this.graph!.findPath(from, to)) as PathResult<TWorkers>;
-  }
-
-  /**
-   * Async pathfinding using worker pool
-   */
-  private async findPathAsync(from: Vec2, to: Vec2): Promise<Vec2[]> {
-    // Lazy init for 'auto' mode
-    if (this.options.workers === 'auto' && !this.workerPool) {
-      await this.initWorkerPool();
-    }
-
-    if (!this.workerPool) {
-      // Fallback to sync if workers failed to init
-      this.rebuild();
-      return this.type === 'grid'
-        ? this.grid!.findPath(from, to)
-        : this.graph!.findPath(from, to);
-    }
-
-    return this.workerPool.findPath(from, to);
-  }
-
-  /**
-   * Smart rebuild - only rebuilds if obstacles changed.
-   * Version checking eliminates unnecessary work.
-   */
-  rebuild() {
-    if (this.lastVersion === this.obstacles.version) return;
-
-    this.grid?.rebuild();
-    this.graph?.rebuild();
-
-    this.lastVersion = this.obstacles.version;
-  }
-
-  /**
-   * Cleanup resources (terminate worker pool if active)
-   * Call this when you're done with the NavMesh instance.
-   *
-   * @example
-   * ```ts
-   * const navmesh = new NavMesh('grid', { workers: true });
-   * // ... use navmesh ...
-   * navmesh.dispose(); // Cleanup workers
-   * ```
-   */
-  dispose() {
-    if (this.workerPool) {
-      this.workerPool.terminate();
-      this.workerPool = undefined;
-    }
-  }
-
-  /**
-   * Get current worker status for debugging/monitoring
-   */
-  getWorkerStatus() {
-    return {
-      workersEnabled: this.options.workers,
-      workerPoolActive: !!this.workerPool,
-      pendingPaths: this.pendingPaths,
-      usingWorkersNow: this.shouldUseWorkers(),
-    };
-  }
-}
-
-/* ---------------------------------- */
-/* A*                                 */
-/* ---------------------------------- */
-
-/**
- * A* pathfinding with binary heap and proper open set tracking.
- * 
- * Optimizations:
- * - Binary heap: O(log n) operations
- * - Open set tracking: prevents duplicate nodes
- * - Integer cell encoding: eliminates string allocation
- * - Closed set: avoids reprocessing
- * 
- * Performance: Handles 10k+ node searches efficiently.
- * Time: O(b^d * log n) where b = branching, d = depth, n = nodes.
- */
-function aStar(
-  start: Vec2,
-  goal: Vec2,
-  walkable: (x: number, y: number) => boolean
-): Vec2[] {
-  const cameFrom = new Map<number, number>();
-  const g = new Map<number, number>();
-  const closed = new Set<number>();
-  const openSet = new Set<number>();
-
-  const key = (p: Vec2): number => encodeCell(p.x, p.y);
-  const h = (a: Vec2, b: Vec2): number =>
-    Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-
-  const open = new BinaryHeap<number>((nodeKey) => {
-    const pos = decodeCell(nodeKey);
-    return g.get(nodeKey)! + h(pos, goal);
-  });
-
-  const startKey = key(start);
-  g.set(startKey, 0);
-  open.push(startKey);
-  openSet.add(startKey);
-
-  while (open.size > 0) {
-    const currentKey = open.pop()!;
-    openSet.delete(currentKey);
-    const current = decodeCell(currentKey);
-
-    if (current.x === goal.x && current.y === goal.y) {
-      return reconstruct(cameFrom, current);
-    }
-
-    closed.add(currentKey);
-
-    for (const d of dirs) {
-      const n = { x: current.x + d.x, y: current.y + d.y };
-      if (!walkable(n.x, n.y)) continue;
-
-      const nk = key(n);
-      if (closed.has(nk)) continue;
-
-      const ng = g.get(currentKey)! + 1;
-
-      if (ng < (g.get(nk) ?? Infinity)) {
-        g.set(nk, ng);
-        cameFrom.set(nk, currentKey);
-
-        if (!openSet.has(nk)) {
-          open.push(nk);
-          openSet.add(nk);
-        }
-      }
-    }
-  }
-
-  return [];
-}
-
-/**
- * Reconstructs path from A* came-from map.
- */
-function reconstruct(
-  cameFrom: Map<number, number>,
-  current: Vec2
-): Vec2[] {
-  const path = [current];
-  let k = encodeCell(current.x, current.y);
-
-  while (cameFrom.has(k)) {
-    k = cameFrom.get(k)!;
-    path.push(decodeCell(k));
-  }
-
-  return path.reverse();
-}