@esengine/pathfinding 11.0.0 → 12.1.0

package/dist/index.js

@@ -1,50 +1,43 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/core/IPathfinding.ts
-function createPoint(x, y) {
-  return {
-    x,
-    y
-  };
-}
-__name(createPoint, "createPoint");
-var EMPTY_PATH_RESULT = {
-  found: false,
-  path: [],
-  cost: 0,
-  nodesSearched: 0
-};
-function manhattanDistance(a, b) {
-  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-}
-__name(manhattanDistance, "manhattanDistance");
-function euclideanDistance(a, b) {
-  const dx = a.x - b.x;
-  const dy = a.y - b.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-__name(euclideanDistance, "euclideanDistance");
-function chebyshevDistance(a, b) {
-  return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
-}
-__name(chebyshevDistance, "chebyshevDistance");
-function octileDistance(a, b) {
-  const dx = Math.abs(a.x - b.x);
-  const dy = Math.abs(a.y - b.y);
-  const D = 1;
-  const D2 = Math.SQRT2;
-  return D * (dx + dy) + (D2 - 2 * D) * Math.min(dx, dy);
-}
-__name(octileDistance, "octileDistance");
-var DEFAULT_PATHFINDING_OPTIONS = {
-  maxNodes: 1e4,
-  heuristicWeight: 1,
-  allowDiagonal: true,
-  avoidCorners: true
-};
+import {
+  CatmullRomSmoother,
+  CombinedSmoother,
+  DEFAULT_GRID_OPTIONS,
+  DEFAULT_PATHFINDING_OPTIONS,
+  DEFAULT_PATH_CACHE_CONFIG,
+  DIRECTIONS_4,
+  DIRECTIONS_8,
+  EMPTY_PATH_RESULT,
+  GridMap,
+  GridNode,
+  IncrementalAStarPathfinder,
+  IndexedBinaryHeap,
+  LineOfSightSmoother,
+  ObstacleChangeManager,
+  PathCache,
+  PathValidator,
+  bresenhamLineOfSight,
+  chebyshevDistance,
+  createCatmullRomSmoother,
+  createCombinedSmoother,
+  createGridMap,
+  createIncrementalAStarPathfinder,
+  createLineOfSightSmoother,
+  createObstacleChangeManager,
+  createPathCache,
+  createPathValidator,
+  createPoint,
+  euclideanDistance,
+  manhattanDistance,
+  octileDistance,
+  raycastLineOfSight
+} from "./chunk-TPT7Q3E3.js";
+import {
+  DEFAULT_REPLANNING_CONFIG,
+  EMPTY_PROGRESS,
+  PathfindingState,
+  __name,
+  __publicField
+} from "./chunk-GTFFYRZM.js";
 
 // src/core/BinaryHeap.ts
 var _BinaryHeap = class _BinaryHeap {
@@ -182,7 +175,7 @@ var _AStarPathfinder = class _AStarPathfinder {
     __publicField(this, "nodeCache", /* @__PURE__ */ new Map());
     __publicField(this, "openList");
     this.map = map;
-    this.openList = new BinaryHeap((a, b) => a.f - b.f);
+    this.openList = new IndexedBinaryHeap((a, b) => a.f - b.f);
   }
   /**
    * @zh 查找路径
@@ -282,7 +275,8 @@ var _AStarPathfinder = class _AStarPathfinder {
         f: Infinity,
         parent: null,
         closed: false,
-        opened: false
+        opened: false,
+        heapIndex: -1
       };
       this.nodeCache.set(node.id, astarNode);
     }
@@ -296,9 +290,10 @@ var _AStarPathfinder = class _AStarPathfinder {
     const path = [];
     let current = endNode;
     while (current) {
-      path.unshift(current.node.position);
+      path.push(current.node.position);
       current = current.parent;
     }
+    path.reverse();
     return {
       found: true,
       path,
@@ -314,283 +309,1643 @@ function createAStarPathfinder(map) {
 }
 __name(createAStarPathfinder, "createAStarPathfinder");
 
-// src/grid/GridMap.ts
-var _GridNode = class _GridNode {
-  constructor(x, y, walkable = true, cost = 1) {
-    __publicField(this, "id");
-    __publicField(this, "position");
-    __publicField(this, "x");
-    __publicField(this, "y");
-    __publicField(this, "cost");
-    __publicField(this, "walkable");
-    this.x = x;
-    this.y = y;
-    this.id = `${x},${y}`;
-    this.position = createPoint(x, y);
-    this.walkable = walkable;
-    this.cost = cost;
+// src/core/GridPathfinder.ts
+var CLOSED_FLAG = 1;
+var OPENED_FLAG = 2;
+var BACKWARD_CLOSED = 4;
+var BACKWARD_OPENED = 8;
+var _a;
+var GridState = (_a = class {
+  constructor(width, height, bidirectional = false) {
+    __publicField(this, "size");
+    __publicField(this, "width");
+    __publicField(this, "g");
+    __publicField(this, "f");
+    __publicField(this, "flags");
+    __publicField(this, "parent");
+    __publicField(this, "heapIndex");
+    __publicField(this, "version");
+    __publicField(this, "currentVersion", 1);
+    // 双向搜索额外状态
+    __publicField(this, "gBack", null);
+    __publicField(this, "fBack", null);
+    __publicField(this, "parentBack", null);
+    __publicField(this, "heapIndexBack", null);
+    this.width = width;
+    this.size = width * height;
+    this.g = new Float32Array(this.size);
+    this.f = new Float32Array(this.size);
+    this.flags = new Uint8Array(this.size);
+    this.parent = new Int32Array(this.size);
+    this.heapIndex = new Int32Array(this.size);
+    this.version = new Uint32Array(this.size);
+    if (bidirectional) {
+      this.gBack = new Float32Array(this.size);
+      this.fBack = new Float32Array(this.size);
+      this.parentBack = new Int32Array(this.size);
+      this.heapIndexBack = new Int32Array(this.size);
+    }
+  }
+  reset() {
+    this.currentVersion++;
+    if (this.currentVersion > 4294967295) {
+      this.version.fill(0);
+      this.currentVersion = 1;
+    }
+  }
+  isInit(i) {
+    return this.version[i] === this.currentVersion;
+  }
+  init(i) {
+    if (!this.isInit(i)) {
+      this.g[i] = Infinity;
+      this.f[i] = Infinity;
+      this.flags[i] = 0;
+      this.parent[i] = -1;
+      this.heapIndex[i] = -1;
+      if (this.gBack) {
+        this.gBack[i] = Infinity;
+        this.fBack[i] = Infinity;
+        this.parentBack[i] = -1;
+        this.heapIndexBack[i] = -1;
+      }
+      this.version[i] = this.currentVersion;
+    }
+  }
+  // Forward
+  getG(i) {
+    return this.isInit(i) ? this.g[i] : Infinity;
+  }
+  setG(i, v) {
+    this.init(i);
+    this.g[i] = v;
+  }
+  getF(i) {
+    return this.isInit(i) ? this.f[i] : Infinity;
+  }
+  setF(i, v) {
+    this.init(i);
+    this.f[i] = v;
+  }
+  getParent(i) {
+    return this.isInit(i) ? this.parent[i] : -1;
+  }
+  setParent(i, v) {
+    this.init(i);
+    this.parent[i] = v;
+  }
+  getHeapIndex(i) {
+    return this.isInit(i) ? this.heapIndex[i] : -1;
+  }
+  setHeapIndex(i, v) {
+    this.init(i);
+    this.heapIndex[i] = v;
+  }
+  isClosed(i) {
+    return this.isInit(i) && (this.flags[i] & CLOSED_FLAG) !== 0;
+  }
+  setClosed(i) {
+    this.init(i);
+    this.flags[i] |= CLOSED_FLAG;
+  }
+  isOpened(i) {
+    return this.isInit(i) && (this.flags[i] & OPENED_FLAG) !== 0;
+  }
+  setOpened(i) {
+    this.init(i);
+    this.flags[i] |= OPENED_FLAG;
+  }
+  // Backward
+  getGBack(i) {
+    return this.isInit(i) ? this.gBack[i] : Infinity;
+  }
+  setGBack(i, v) {
+    this.init(i);
+    this.gBack[i] = v;
+  }
+  getFBack(i) {
+    return this.isInit(i) ? this.fBack[i] : Infinity;
+  }
+  setFBack(i, v) {
+    this.init(i);
+    this.fBack[i] = v;
+  }
+  getParentBack(i) {
+    return this.isInit(i) ? this.parentBack[i] : -1;
+  }
+  setParentBack(i, v) {
+    this.init(i);
+    this.parentBack[i] = v;
+  }
+  getHeapIndexBack(i) {
+    return this.isInit(i) ? this.heapIndexBack[i] : -1;
+  }
+  setHeapIndexBack(i, v) {
+    this.init(i);
+    this.heapIndexBack[i] = v;
+  }
+  isClosedBack(i) {
+    return this.isInit(i) && (this.flags[i] & BACKWARD_CLOSED) !== 0;
+  }
+  setClosedBack(i) {
+    this.init(i);
+    this.flags[i] |= BACKWARD_CLOSED;
+  }
+  isOpenedBack(i) {
+    return this.isInit(i) && (this.flags[i] & BACKWARD_OPENED) !== 0;
+  }
+  setOpenedBack(i) {
+    this.init(i);
+    this.flags[i] |= BACKWARD_OPENED;
+  }
+}, __name(_a, "GridState"), _a);
+var _a2;
+var GridHeap = (_a2 = class {
+  constructor(state, isBack = false) {
+    __publicField(this, "heap", []);
+    __publicField(this, "state");
+    __publicField(this, "isBack");
+    this.state = state;
+    this.isBack = isBack;
+  }
+  get size() {
+    return this.heap.length;
+  }
+  get isEmpty() {
+    return this.heap.length === 0;
+  }
+  getF(i) {
+    return this.isBack ? this.state.getFBack(i) : this.state.getF(i);
+  }
+  getHeapIndex(i) {
+    return this.isBack ? this.state.getHeapIndexBack(i) : this.state.getHeapIndex(i);
+  }
+  setHeapIndex(i, v) {
+    if (this.isBack) this.state.setHeapIndexBack(i, v);
+    else this.state.setHeapIndex(i, v);
+  }
+  push(i) {
+    this.setHeapIndex(i, this.heap.length);
+    this.heap.push(i);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  pop() {
+    if (this.heap.length === 0) return -1;
+    const result = this.heap[0];
+    this.setHeapIndex(result, -1);
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.setHeapIndex(last, 0);
+      this.sinkDown(0);
+    }
+    return result;
+  }
+  update(i) {
+    const pos = this.getHeapIndex(i);
+    if (pos >= 0 && pos < this.heap.length) {
+      this.bubbleUp(pos);
+      this.sinkDown(this.getHeapIndex(i));
+    }
+  }
+  clear() {
+    this.heap.length = 0;
+  }
+  bubbleUp(pos) {
+    const idx = this.heap[pos];
+    const f = this.getF(idx);
+    while (pos > 0) {
+      const pp = pos - 1 >> 1;
+      const pi = this.heap[pp];
+      if (f >= this.getF(pi)) break;
+      this.heap[pos] = pi;
+      this.setHeapIndex(pi, pos);
+      pos = pp;
+    }
+    this.heap[pos] = idx;
+    this.setHeapIndex(idx, pos);
+  }
+  sinkDown(pos) {
+    const len = this.heap.length;
+    const idx = this.heap[pos];
+    const f = this.getF(idx);
+    const half = len >> 1;
+    while (pos < half) {
+      const left = (pos << 1) + 1;
+      const right = left + 1;
+      let smallest = pos, smallestF = f;
+      const lf = this.getF(this.heap[left]);
+      if (lf < smallestF) {
+        smallest = left;
+        smallestF = lf;
+      }
+      if (right < len) {
+        const rf = this.getF(this.heap[right]);
+        if (rf < smallestF) smallest = right;
+      }
+      if (smallest === pos) break;
+      const si = this.heap[smallest];
+      this.heap[pos] = si;
+      this.setHeapIndex(si, pos);
+      pos = smallest;
+    }
+    this.heap[pos] = idx;
+    this.setHeapIndex(idx, pos);
+  }
+}, __name(_a2, "GridHeap"), _a2);
+var _GridPathfinder = class _GridPathfinder {
+  constructor(map, config) {
+    __publicField(this, "map");
+    __publicField(this, "mode");
+    __publicField(this, "state");
+    __publicField(this, "openList");
+    __publicField(this, "openListBack");
+    this.map = map;
+    this.mode = config?.mode ?? "fast";
+    const isBidir = this.mode === "bidirectional";
+    this.state = new GridState(map.width, map.height, isBidir);
+    this.openList = new GridHeap(this.state, false);
+    this.openListBack = isBidir ? new GridHeap(this.state, true) : null;
+  }
+  findPath(startX, startY, endX, endY, options) {
+    if (this.mode === "bidirectional") {
+      return this.findPathBidirectional(startX, startY, endX, endY, options);
+    }
+    return this.findPathUnidirectional(startX, startY, endX, endY, options);
+  }
+  findPathUnidirectional(startX, startY, endX, endY, options) {
+    const opts = options ? {
+      ...DEFAULT_PATHFINDING_OPTIONS,
+      ...options
+    } : DEFAULT_PATHFINDING_OPTIONS;
+    const { width, height } = this.map;
+    this.state.reset();
+    this.openList.clear();
+    if (!this.validate(startX, startY, endX, endY)) return EMPTY_PATH_RESULT;
+    const startIdx = startY * width + startX;
+    const endIdx = endY * width + endX;
+    if (startIdx === endIdx) {
+      return {
+        found: true,
+        path: [
+          {
+            x: startX,
+            y: startY
+          }
+        ],
+        cost: 0,
+        nodesSearched: 1
+      };
+    }
+    const hw = opts.heuristicWeight;
+    const h0 = this.map.heuristic({
+      x: startX,
+      y: startY
+    }, {
+      x: endX,
+      y: endY
+    }) * hw;
+    this.state.setG(startIdx, 0);
+    this.state.setF(startIdx, h0);
+    this.state.setOpened(startIdx);
+    this.openList.push(startIdx);
+    let searched = 0;
+    const maxNodes = opts.maxNodes;
+    const { allowDiagonal, avoidCorners, diagonalCost } = this.map["options"];
+    const nodes = this.map["nodes"];
+    const dx = allowDiagonal ? [
+      0,
+      1,
+      1,
+      1,
+      0,
+      -1,
+      -1,
+      -1
+    ] : [
+      0,
+      1,
+      0,
+      -1
+    ];
+    const dy = allowDiagonal ? [
+      -1,
+      -1,
+      0,
+      1,
+      1,
+      1,
+      0,
+      -1
+    ] : [
+      -1,
+      0,
+      1,
+      0
+    ];
+    const dirCount = dx.length;
+    while (!this.openList.isEmpty && searched < maxNodes) {
+      const cur = this.openList.pop();
+      this.state.setClosed(cur);
+      searched++;
+      if (cur === endIdx) {
+        return this.buildPath(startIdx, endIdx, searched);
+      }
+      const cx = cur % width, cy = cur / width | 0;
+      const curG = this.state.getG(cur);
+      for (let d = 0; d < dirCount; d++) {
+        const nx = cx + dx[d], ny = cy + dy[d];
+        if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+        const neighbor = nodes[ny][nx];
+        if (!neighbor.walkable) continue;
+        if (avoidCorners && dx[d] !== 0 && dy[d] !== 0) {
+          if (!nodes[cy][cx + dx[d]].walkable || !nodes[cy + dy[d]][cx].walkable) continue;
+        }
+        const ni = ny * width + nx;
+        if (this.state.isClosed(ni)) continue;
+        const isDiag = dx[d] !== 0 && dy[d] !== 0;
+        const cost = isDiag ? neighbor.cost * diagonalCost : neighbor.cost;
+        const tentG = curG + cost;
+        if (!this.state.isOpened(ni)) {
+          const h = this.map.heuristic({
+            x: nx,
+            y: ny
+          }, {
+            x: endX,
+            y: endY
+          }) * hw;
+          this.state.setG(ni, tentG);
+          this.state.setF(ni, tentG + h);
+          this.state.setParent(ni, cur);
+          this.state.setOpened(ni);
+          this.openList.push(ni);
+        } else if (tentG < this.state.getG(ni)) {
+          const h = this.state.getF(ni) - this.state.getG(ni);
+          this.state.setG(ni, tentG);
+          this.state.setF(ni, tentG + h);
+          this.state.setParent(ni, cur);
+          this.openList.update(ni);
+        }
+      }
+    }
+    return {
+      found: false,
+      path: [],
+      cost: 0,
+      nodesSearched: searched
+    };
+  }
+  findPathBidirectional(startX, startY, endX, endY, options) {
+    const opts = options ? {
+      ...DEFAULT_PATHFINDING_OPTIONS,
+      ...options
+    } : DEFAULT_PATHFINDING_OPTIONS;
+    const { width, height } = this.map;
+    this.state.reset();
+    this.openList.clear();
+    this.openListBack.clear();
+    if (!this.validate(startX, startY, endX, endY)) return EMPTY_PATH_RESULT;
+    const startIdx = startY * width + startX;
+    const endIdx = endY * width + endX;
+    if (startIdx === endIdx) {
+      return {
+        found: true,
+        path: [
+          {
+            x: startX,
+            y: startY
+          }
+        ],
+        cost: 0,
+        nodesSearched: 1
+      };
+    }
+    const hw = opts.heuristicWeight;
+    const startPos = {
+      x: startX,
+      y: startY
+    };
+    const endPos = {
+      x: endX,
+      y: endY
+    };
+    const hf = this.map.heuristic(startPos, endPos) * hw;
+    this.state.setG(startIdx, 0);
+    this.state.setF(startIdx, hf);
+    this.state.setOpened(startIdx);
+    this.openList.push(startIdx);
+    const hb = this.map.heuristic(endPos, startPos) * hw;
+    this.state.setGBack(endIdx, 0);
+    this.state.setFBack(endIdx, hb);
+    this.state.setOpenedBack(endIdx);
+    this.openListBack.push(endIdx);
+    let searched = 0;
+    const maxNodes = opts.maxNodes;
+    let meetIdx = -1, bestCost = Infinity;
+    const { allowDiagonal, avoidCorners, diagonalCost } = this.map["options"];
+    const nodes = this.map["nodes"];
+    const dx = allowDiagonal ? [
+      0,
+      1,
+      1,
+      1,
+      0,
+      -1,
+      -1,
+      -1
+    ] : [
+      0,
+      1,
+      0,
+      -1
+    ];
+    const dy = allowDiagonal ? [
+      -1,
+      -1,
+      0,
+      1,
+      1,
+      1,
+      0,
+      -1
+    ] : [
+      -1,
+      0,
+      1,
+      0
+    ];
+    const dirCount = dx.length;
+    while ((!this.openList.isEmpty || !this.openListBack.isEmpty) && searched < maxNodes) {
+      if (!this.openList.isEmpty) {
+        const cur = this.openList.pop();
+        this.state.setClosed(cur);
+        searched++;
+        const curG = this.state.getG(cur);
+        if (this.state.isClosedBack(cur)) {
+          const total = curG + this.state.getGBack(cur);
+          if (total < bestCost) {
+            bestCost = total;
+            meetIdx = cur;
+          }
+        }
+        if (meetIdx !== -1 && curG >= bestCost) break;
+        const cx = cur % width, cy = cur / width | 0;
+        for (let d = 0; d < dirCount; d++) {
+          const nx = cx + dx[d], ny = cy + dy[d];
+          if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+          const neighbor = nodes[ny][nx];
+          if (!neighbor.walkable) continue;
+          if (avoidCorners && dx[d] !== 0 && dy[d] !== 0) {
+            if (!nodes[cy][cx + dx[d]].walkable || !nodes[cy + dy[d]][cx].walkable) continue;
+          }
+          const ni = ny * width + nx;
+          if (this.state.isClosed(ni)) continue;
+          const isDiag = dx[d] !== 0 && dy[d] !== 0;
+          const cost = isDiag ? neighbor.cost * diagonalCost : neighbor.cost;
+          const tentG = curG + cost;
+          if (!this.state.isOpened(ni)) {
+            const h = this.map.heuristic({
+              x: nx,
+              y: ny
+            }, endPos) * hw;
+            this.state.setG(ni, tentG);
+            this.state.setF(ni, tentG + h);
+            this.state.setParent(ni, cur);
+            this.state.setOpened(ni);
+            this.openList.push(ni);
+          } else if (tentG < this.state.getG(ni)) {
+            const h = this.state.getF(ni) - this.state.getG(ni);
+            this.state.setG(ni, tentG);
+            this.state.setF(ni, tentG + h);
+            this.state.setParent(ni, cur);
+            this.openList.update(ni);
+          }
+        }
+      }
+      if (!this.openListBack.isEmpty) {
+        const cur = this.openListBack.pop();
+        this.state.setClosedBack(cur);
+        searched++;
+        const curG = this.state.getGBack(cur);
+        if (this.state.isClosed(cur)) {
+          const total = curG + this.state.getG(cur);
+          if (total < bestCost) {
+            bestCost = total;
+            meetIdx = cur;
+          }
+        }
+        if (meetIdx !== -1 && curG >= bestCost) break;
+        const cx = cur % width, cy = cur / width | 0;
+        for (let d = 0; d < dirCount; d++) {
+          const nx = cx + dx[d], ny = cy + dy[d];
+          if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+          const neighbor = nodes[ny][nx];
+          if (!neighbor.walkable) continue;
+          if (avoidCorners && dx[d] !== 0 && dy[d] !== 0) {
+            if (!nodes[cy][cx + dx[d]].walkable || !nodes[cy + dy[d]][cx].walkable) continue;
+          }
+          const ni = ny * width + nx;
+          if (this.state.isClosedBack(ni)) continue;
+          const isDiag = dx[d] !== 0 && dy[d] !== 0;
+          const cost = isDiag ? neighbor.cost * diagonalCost : neighbor.cost;
+          const tentG = curG + cost;
+          if (!this.state.isOpenedBack(ni)) {
+            const h = this.map.heuristic({
+              x: nx,
+              y: ny
+            }, startPos) * hw;
+            this.state.setGBack(ni, tentG);
+            this.state.setFBack(ni, tentG + h);
+            this.state.setParentBack(ni, cur);
+            this.state.setOpenedBack(ni);
+            this.openListBack.push(ni);
+          } else if (tentG < this.state.getGBack(ni)) {
+            const h = this.state.getFBack(ni) - this.state.getGBack(ni);
+            this.state.setGBack(ni, tentG);
+            this.state.setFBack(ni, tentG + h);
+            this.state.setParentBack(ni, cur);
+            this.openListBack.update(ni);
+          }
+        }
+      }
+    }
+    if (meetIdx === -1) {
+      return {
+        found: false,
+        path: [],
+        cost: 0,
+        nodesSearched: searched
+      };
+    }
+    return this.buildPathBidirectional(startIdx, endIdx, meetIdx, searched);
+  }
+  validate(startX, startY, endX, endY) {
+    const { width, height } = this.map;
+    if (startX < 0 || startX >= width || startY < 0 || startY >= height) return false;
+    if (endX < 0 || endX >= width || endY < 0 || endY >= height) return false;
+    return this.map.isWalkable(startX, startY) && this.map.isWalkable(endX, endY);
+  }
+  buildPath(startIdx, endIdx, searched) {
+    const w = this.state.width;
+    const path = [];
+    let cur = endIdx;
+    while (cur !== -1) {
+      path.push({
+        x: cur % w,
+        y: cur / w | 0
+      });
+      cur = cur === startIdx ? -1 : this.state.getParent(cur);
+    }
+    path.reverse();
+    return {
+      found: true,
+      path,
+      cost: this.state.getG(endIdx),
+      nodesSearched: searched
+    };
+  }
+  buildPathBidirectional(startIdx, endIdx, meetIdx, searched) {
+    const w = this.state.width;
+    const path = [];
+    let cur = meetIdx;
+    while (cur !== -1 && cur !== startIdx) {
+      path.push({
+        x: cur % w,
+        y: cur / w | 0
+      });
+      cur = this.state.getParent(cur);
+    }
+    path.push({
+      x: startIdx % w,
+      y: startIdx / w | 0
+    });
+    path.reverse();
+    cur = this.state.getParentBack(meetIdx);
+    while (cur !== -1 && cur !== endIdx) {
+      path.push({
+        x: cur % w,
+        y: cur / w | 0
+      });
+      cur = this.state.getParentBack(cur);
+    }
+    if (meetIdx !== endIdx) {
+      path.push({
+        x: endIdx % w,
+        y: endIdx / w | 0
+      });
+    }
+    const cost = this.state.getG(meetIdx) + this.state.getGBack(meetIdx);
+    return {
+      found: true,
+      path,
+      cost,
+      nodesSearched: searched
+    };
+  }
+  clear() {
+    this.state.reset();
+    this.openList.clear();
+    this.openListBack?.clear();
+  }
+};
+__name(_GridPathfinder, "GridPathfinder");
+var GridPathfinder = _GridPathfinder;
+function createGridPathfinder(map, config) {
+  return new GridPathfinder(map, config);
+}
+__name(createGridPathfinder, "createGridPathfinder");
+
+// src/core/JPSPathfinder.ts
+var _JPSPathfinder = class _JPSPathfinder {
+  constructor(map) {
+    __publicField(this, "map");
+    __publicField(this, "width");
+    __publicField(this, "height");
+    __publicField(this, "openList");
+    __publicField(this, "nodeGrid");
+    this.map = map;
+    const bounds = this.getMapBounds();
+    this.width = bounds.width;
+    this.height = bounds.height;
+    this.openList = new BinaryHeap((a, b) => a.f - b.f);
+    this.nodeGrid = [];
+  }
+  /**
+   * @zh 寻找路径
+   * @en Find path
+   */
+  findPath(startX, startY, endX, endY, options) {
+    const opts = {
+      ...DEFAULT_PATHFINDING_OPTIONS,
+      ...options
+    };
+    if (!this.map.isWalkable(startX, startY) || !this.map.isWalkable(endX, endY)) {
+      return EMPTY_PATH_RESULT;
+    }
+    if (startX === endX && startY === endY) {
+      return {
+        found: true,
+        path: [
+          {
+            x: startX,
+            y: startY
+          }
+        ],
+        cost: 0,
+        nodesSearched: 1
+      };
+    }
+    this.initGrid();
+    this.openList.clear();
+    const startNode = this.getOrCreateNode(startX, startY);
+    startNode.g = 0;
+    startNode.h = this.heuristic(startX, startY, endX, endY) * opts.heuristicWeight;
+    startNode.f = startNode.h;
+    this.openList.push(startNode);
+    let nodesSearched = 0;
+    while (!this.openList.isEmpty && nodesSearched < opts.maxNodes) {
+      const current = this.openList.pop();
+      current.closed = true;
+      nodesSearched++;
+      if (current.x === endX && current.y === endY) {
+        return {
+          found: true,
+          path: this.buildPath(current),
+          cost: current.g,
+          nodesSearched
+        };
+      }
+      this.identifySuccessors(current, endX, endY, opts);
+    }
+    return {
+      found: false,
+      path: [],
+      cost: 0,
+      nodesSearched
+    };
+  }
+  /**
+   * @zh 清理状态
+   * @en Clear state
+   */
+  clear() {
+    this.openList.clear();
+    this.nodeGrid = [];
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  /**
+   * @zh 获取地图边界
+   * @en Get map bounds
+   */
+  getMapBounds() {
+    const mapAny = this.map;
+    if (typeof mapAny.width === "number" && typeof mapAny.height === "number") {
+      return {
+        width: mapAny.width,
+        height: mapAny.height
+      };
+    }
+    return {
+      width: 1e3,
+      height: 1e3
+    };
+  }
+  /**
+   * @zh 初始化节点网格
+   * @en Initialize node grid
+   */
+  initGrid() {
+    this.nodeGrid = [];
+    for (let i = 0; i < this.width; i++) {
+      this.nodeGrid[i] = [];
+    }
+  }
+  /**
+   * @zh 获取或创建节点
+   * @en Get or create node
+   */
+  getOrCreateNode(x, y) {
+    const xi = x | 0;
+    const yi = y | 0;
+    if (xi < 0 || xi >= this.width || yi < 0 || yi >= this.height) {
+      throw new Error("[JPSPathfinder] Invalid grid coordinates");
+    }
+    if (!this.nodeGrid[xi]) {
+      this.nodeGrid[xi] = [];
+    }
+    if (!this.nodeGrid[xi][yi]) {
+      this.nodeGrid[xi][yi] = {
+        x: xi,
+        y: yi,
+        g: Infinity,
+        h: 0,
+        f: Infinity,
+        parent: null,
+        closed: false
+      };
+    }
+    return this.nodeGrid[xi][yi];
+  }
+  /**
+   * @zh 启发式函数（八方向距离）
+   * @en Heuristic function (octile distance)
+   */
+  heuristic(x1, y1, x2, y2) {
+    const dx = Math.abs(x1 - x2);
+    const dy = Math.abs(y1 - y2);
+    return dx + dy + (Math.SQRT2 - 2) * Math.min(dx, dy);
+  }
+  /**
+   * @zh 识别后继节点（跳跃点）
+   * @en Identify successors (jump points)
+   */
+  identifySuccessors(node, endX, endY, opts) {
+    const neighbors = this.findNeighbors(node);
+    for (const neighbor of neighbors) {
+      const jumpPoint = this.jump(neighbor.x, neighbor.y, node.x, node.y, endX, endY);
+      if (jumpPoint) {
+        const jx = jumpPoint.x;
+        const jy = jumpPoint.y;
+        const jpNode = this.getOrCreateNode(jx, jy);
+        if (jpNode.closed) continue;
+        const dx = Math.abs(jx - node.x);
+        const dy = Math.abs(jy - node.y);
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const tentativeG = node.g + distance;
+        if (tentativeG < jpNode.g) {
+          jpNode.g = tentativeG;
+          jpNode.h = this.heuristic(jx, jy, endX, endY) * opts.heuristicWeight;
+          jpNode.f = jpNode.g + jpNode.h;
+          jpNode.parent = node;
+          if (!this.openList.contains(jpNode)) {
+            this.openList.push(jpNode);
+          } else {
+            this.openList.update(jpNode);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * @zh 查找邻居（根据父节点方向剪枝）
+   * @en Find neighbors (pruned based on parent direction)
+   */
+  findNeighbors(node) {
+    const { x, y, parent } = node;
+    const neighbors = [];
+    if (!parent) {
+      for (let dx2 = -1; dx2 <= 1; dx2++) {
+        for (let dy2 = -1; dy2 <= 1; dy2++) {
+          if (dx2 === 0 && dy2 === 0) continue;
+          const nx = x + dx2;
+          const ny = y + dy2;
+          if (this.isWalkableAt(nx, ny)) {
+            if (dx2 !== 0 && dy2 !== 0) {
+              if (this.isWalkableAt(x + dx2, y) || this.isWalkableAt(x, y + dy2)) {
+                neighbors.push({
+                  x: nx,
+                  y: ny
+                });
+              }
+            } else {
+              neighbors.push({
+                x: nx,
+                y: ny
+              });
+            }
+          }
+        }
+      }
+      return neighbors;
+    }
+    const dx = Math.sign(x - parent.x);
+    const dy = Math.sign(y - parent.y);
+    if (dx !== 0 && dy !== 0) {
+      if (this.isWalkableAt(x, y + dy)) {
+        neighbors.push({
+          x,
+          y: y + dy
+        });
+      }
+      if (this.isWalkableAt(x + dx, y)) {
+        neighbors.push({
+          x: x + dx,
+          y
+        });
+      }
+      if (this.isWalkableAt(x, y + dy) || this.isWalkableAt(x + dx, y)) {
+        if (this.isWalkableAt(x + dx, y + dy)) {
+          neighbors.push({
+            x: x + dx,
+            y: y + dy
+          });
+        }
+      }
+      if (!this.isWalkableAt(x - dx, y) && this.isWalkableAt(x, y + dy)) {
+        if (this.isWalkableAt(x - dx, y + dy)) {
+          neighbors.push({
+            x: x - dx,
+            y: y + dy
+          });
+        }
+      }
+      if (!this.isWalkableAt(x, y - dy) && this.isWalkableAt(x + dx, y)) {
+        if (this.isWalkableAt(x + dx, y - dy)) {
+          neighbors.push({
+            x: x + dx,
+            y: y - dy
+          });
+        }
+      }
+    } else if (dx !== 0) {
+      if (this.isWalkableAt(x + dx, y)) {
+        neighbors.push({
+          x: x + dx,
+          y
+        });
+        if (!this.isWalkableAt(x, y + 1) && this.isWalkableAt(x + dx, y + 1)) {
+          neighbors.push({
+            x: x + dx,
+            y: y + 1
+          });
+        }
+        if (!this.isWalkableAt(x, y - 1) && this.isWalkableAt(x + dx, y - 1)) {
+          neighbors.push({
+            x: x + dx,
+            y: y - 1
+          });
+        }
+      }
+    } else if (dy !== 0) {
+      if (this.isWalkableAt(x, y + dy)) {
+        neighbors.push({
+          x,
+          y: y + dy
+        });
+        if (!this.isWalkableAt(x + 1, y) && this.isWalkableAt(x + 1, y + dy)) {
+          neighbors.push({
+            x: x + 1,
+            y: y + dy
+          });
+        }
+        if (!this.isWalkableAt(x - 1, y) && this.isWalkableAt(x - 1, y + dy)) {
+          neighbors.push({
+            x: x - 1,
+            y: y + dy
+          });
+        }
+      }
+    }
+    return neighbors;
+  }
+  /**
+   * @zh 跳跃函数（迭代版本，避免递归开销）
+   * @en Jump function (iterative version to avoid recursion overhead)
+   */
+  jump(startX, startY, px, py, endX, endY) {
+    const dx = startX - px;
+    const dy = startY - py;
+    let x = startX;
+    let y = startY;
+    while (true) {
+      if (!this.isWalkableAt(x, y)) {
+        return null;
+      }
+      if (x === endX && y === endY) {
+        return {
+          x,
+          y
+        };
+      }
+      if (dx !== 0 && dy !== 0) {
+        if (this.isWalkableAt(x - dx, y + dy) && !this.isWalkableAt(x - dx, y) || this.isWalkableAt(x + dx, y - dy) && !this.isWalkableAt(x, y - dy)) {
+          return {
+            x,
+            y
+          };
+        }
+        if (this.jumpStraight(x + dx, y, dx, 0, endX, endY) || this.jumpStraight(x, y + dy, 0, dy, endX, endY)) {
+          return {
+            x,
+            y
+          };
+        }
+        if (!this.isWalkableAt(x + dx, y) && !this.isWalkableAt(x, y + dy)) {
+          return null;
+        }
+      } else if (dx !== 0) {
+        if (this.isWalkableAt(x + dx, y + 1) && !this.isWalkableAt(x, y + 1) || this.isWalkableAt(x + dx, y - 1) && !this.isWalkableAt(x, y - 1)) {
+          return {
+            x,
+            y
+          };
+        }
+      } else if (dy !== 0) {
+        if (this.isWalkableAt(x + 1, y + dy) && !this.isWalkableAt(x + 1, y) || this.isWalkableAt(x - 1, y + dy) && !this.isWalkableAt(x - 1, y)) {
+          return {
+            x,
+            y
+          };
+        }
+      }
+      x += dx;
+      y += dy;
+    }
+  }
+  /**
+   * @zh 直线跳跃（水平或垂直方向）
+   * @en Straight jump (horizontal or vertical direction)
+   */
+  jumpStraight(startX, startY, dx, dy, endX, endY) {
+    let x = startX;
+    let y = startY;
+    while (true) {
+      if (!this.isWalkableAt(x, y)) {
+        return false;
+      }
+      if (x === endX && y === endY) {
+        return true;
+      }
+      if (dx !== 0) {
+        if (this.isWalkableAt(x + dx, y + 1) && !this.isWalkableAt(x, y + 1) || this.isWalkableAt(x + dx, y - 1) && !this.isWalkableAt(x, y - 1)) {
+          return true;
+        }
+      } else if (dy !== 0) {
+        if (this.isWalkableAt(x + 1, y + dy) && !this.isWalkableAt(x + 1, y) || this.isWalkableAt(x - 1, y + dy) && !this.isWalkableAt(x - 1, y)) {
+          return true;
+        }
+      }
+      x += dx;
+      y += dy;
+    }
+  }
+  /**
+   * @zh 检查位置是否可通行
+   * @en Check if position is walkable
+   */
+  isWalkableAt(x, y) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
+      return false;
+    }
+    return this.map.isWalkable(x, y);
+  }
+  /**
+   * @zh 构建路径
+   * @en Build path
+   */
+  buildPath(endNode) {
+    const path = [];
+    let current = endNode;
+    while (current) {
+      path.unshift({
+        x: current.x,
+        y: current.y
+      });
+      current = current.parent;
+    }
+    return this.interpolatePath(path);
+  }
+  /**
+   * @zh 插值路径（在跳跃点之间填充中间点）
+   * @en Interpolate path (fill intermediate points between jump points)
+   */
+  interpolatePath(jumpPoints) {
+    if (jumpPoints.length < 2) {
+      return jumpPoints;
+    }
+    const path = [
+      jumpPoints[0]
+    ];
+    for (let i = 1; i < jumpPoints.length; i++) {
+      const prev = jumpPoints[i - 1];
+      const curr = jumpPoints[i];
+      const dx = curr.x - prev.x;
+      const dy = curr.y - prev.y;
+      const steps = Math.max(Math.abs(dx), Math.abs(dy));
+      const stepX = dx === 0 ? 0 : dx / Math.abs(dx);
+      const stepY = dy === 0 ? 0 : dy / Math.abs(dy);
+      let x = prev.x;
+      let y = prev.y;
+      for (let j = 0; j < steps; j++) {
+        if (x !== curr.x && y !== curr.y) {
+          x += stepX;
+          y += stepY;
+        } else if (x !== curr.x) {
+          x += stepX;
+        } else if (y !== curr.y) {
+          y += stepY;
+        }
+        if (x !== prev.x || y !== prev.y) {
+          path.push({
+            x,
+            y
+          });
+        }
+      }
+    }
+    return path;
   }
 };
-__name(_GridNode, "GridNode");
-var GridNode = _GridNode;
-var DIRECTIONS_4 = [
-  {
-    dx: 0,
-    dy: -1
-  },
-  {
-    dx: 1,
-    dy: 0
-  },
-  {
-    dx: 0,
-    dy: 1
-  },
-  {
-    dx: -1,
-    dy: 0
-  }
-  // Left
-];
-var DIRECTIONS_8 = [
-  {
-    dx: 0,
-    dy: -1
-  },
-  {
-    dx: 1,
-    dy: -1
-  },
-  {
-    dx: 1,
-    dy: 0
-  },
-  {
-    dx: 1,
-    dy: 1
-  },
-  {
-    dx: 0,
-    dy: 1
-  },
-  {
-    dx: -1,
-    dy: 1
-  },
-  {
-    dx: -1,
-    dy: 0
-  },
-  {
-    dx: -1,
-    dy: -1
-  }
-  // Up-Left
-];
-var DEFAULT_GRID_OPTIONS = {
-  allowDiagonal: true,
-  diagonalCost: Math.SQRT2,
-  avoidCorners: true,
-  heuristic: octileDistance
+__name(_JPSPathfinder, "JPSPathfinder");
+var JPSPathfinder = _JPSPathfinder;
+function createJPSPathfinder(map) {
+  return new JPSPathfinder(map);
+}
+__name(createJPSPathfinder, "createJPSPathfinder");
+
+// src/core/HPAPathfinder.ts
+var DEFAULT_HPA_CONFIG = {
+  clusterSize: 10,
+  maxEntranceWidth: 6,
+  cacheInternalPaths: true
 };
-var _GridMap = class _GridMap {
-  constructor(width, height, options) {
+var _HPAPathfinder = class _HPAPathfinder {
+  constructor(map, config) {
+    __publicField(this, "map");
+    __publicField(this, "config");
     __publicField(this, "width");
     __publicField(this, "height");
-    __publicField(this, "nodes");
-    __publicField(this, "options");
-    this.width = width;
-    this.height = height;
-    this.options = {
-      ...DEFAULT_GRID_OPTIONS,
-      ...options
+    __publicField(this, "clusters", []);
+    __publicField(this, "entrances", []);
+    __publicField(this, "abstractNodes", /* @__PURE__ */ new Map());
+    __publicField(this, "clusterGrid", []);
+    __publicField(this, "nextEntranceId", 0);
+    __publicField(this, "nextNodeId", 0);
+    __publicField(this, "internalPathCache", /* @__PURE__ */ new Map());
+    __publicField(this, "localPathfinder");
+    __publicField(this, "preprocessed", false);
+    this.map = map;
+    this.config = {
+      ...DEFAULT_HPA_CONFIG,
+      ...config
     };
-    this.nodes = this.createNodes();
+    const bounds = this.getMapBounds();
+    this.width = bounds.width;
+    this.height = bounds.height;
+    this.localPathfinder = new AStarPathfinder(map);
   }
   /**
-   * @zh 创建网格节点
-   * @en Create grid nodes
+   * @zh 预处理地图（构建抽象图）
+   * @en Preprocess map (build abstract graph)
+   *
+   * @zh 在地图变化后需要重新调用
+   * @en Need to call again after map changes
    */
-  createNodes() {
-    const nodes = [];
-    for (let y = 0; y < this.height; y++) {
-      nodes[y] = [];
-      for (let x = 0; x < this.width; x++) {
-        nodes[y][x] = new GridNode(x, y, true, 1);
-      }
-    }
-    return nodes;
+  preprocess() {
+    this.clusters = [];
+    this.entrances = [];
+    this.abstractNodes.clear();
+    this.clusterGrid = [];
+    this.internalPathCache.clear();
+    this.nextEntranceId = 0;
+    this.nextNodeId = 0;
+    this.buildClusters();
+    this.findEntrances();
+    this.buildAbstractGraph();
+    this.preprocessed = true;
   }
   /**
-   * @zh 获取指定位置的节点
-   * @en Get node at position
+   * @zh 寻找路径
+   * @en Find path
    */
-  getNodeAt(x, y) {
-    if (!this.isInBounds(x, y)) {
-      return null;
+  findPath(startX, startY, endX, endY, options) {
+    if (!this.preprocessed) {
+      this.preprocess();
+    }
+    const opts = {
+      ...DEFAULT_PATHFINDING_OPTIONS,
+      ...options
+    };
+    if (!this.map.isWalkable(startX, startY) || !this.map.isWalkable(endX, endY)) {
+      return EMPTY_PATH_RESULT;
+    }
+    if (startX === endX && startY === endY) {
+      return {
+        found: true,
+        path: [
+          {
+            x: startX,
+            y: startY
+          }
+        ],
+        cost: 0,
+        nodesSearched: 1
+      };
+    }
+    const startCluster = this.getClusterAt(startX, startY);
+    const endCluster = this.getClusterAt(endX, endY);
+    if (!startCluster || !endCluster) {
+      return EMPTY_PATH_RESULT;
     }
-    return this.nodes[y][x];
+    if (startCluster.id === endCluster.id) {
+      return this.findLocalPath(startX, startY, endX, endY, opts);
+    }
+    const startNodes = this.insertTemporaryNode(startX, startY, startCluster);
+    const endNodes = this.insertTemporaryNode(endX, endY, endCluster);
+    const abstractPath = this.searchAbstractGraph(startNodes, endNodes, opts);
+    this.removeTemporaryNodes(startNodes);
+    this.removeTemporaryNodes(endNodes);
+    if (!abstractPath || abstractPath.length === 0) {
+      return EMPTY_PATH_RESULT;
+    }
+    return this.refinePath(abstractPath, startX, startY, endX, endY, opts);
   }
   /**
-   * @zh 检查坐标是否在边界内
-   * @en Check if coordinates are within bounds
+   * @zh 清理状态
+   * @en Clear state
    */
-  isInBounds(x, y) {
-    return x >= 0 && x < this.width && y >= 0 && y < this.height;
+  clear() {
+    this.clusters = [];
+    this.entrances = [];
+    this.abstractNodes.clear();
+    this.clusterGrid = [];
+    this.internalPathCache.clear();
+    this.preprocessed = false;
   }
   /**
-   * @zh 检查位置是否可通行
-   * @en Check if position is walkable
+   * @zh 通知地图区域变化
+   * @en Notify map region change
    */
-  isWalkable(x, y) {
-    const node = this.getNodeAt(x, y);
-    return node !== null && node.walkable;
+  notifyRegionChange(minX, minY, maxX, maxY) {
+    this.preprocessed = false;
+    this.internalPathCache.clear();
   }
   /**
-   * @zh 设置位置是否可通行
-   * @en Set position walkability
+   * @zh 获取预处理统计信息
+   * @en Get preprocessing statistics
    */
-  setWalkable(x, y, walkable) {
-    const node = this.getNodeAt(x, y);
-    if (node) {
-      node.walkable = walkable;
+  getStats() {
+    return {
+      clusters: this.clusters.length,
+      entrances: this.entrances.length,
+      abstractNodes: this.abstractNodes.size,
+      cacheSize: this.internalPathCache.size
+    };
+  }
+  // =========================================================================
+  // 预处理方法 | Preprocessing Methods
+  // =========================================================================
+  getMapBounds() {
+    const mapAny = this.map;
+    if (typeof mapAny.width === "number" && typeof mapAny.height === "number") {
+      return {
+        width: mapAny.width,
+        height: mapAny.height
+      };
     }
+    return {
+      width: 1e3,
+      height: 1e3
+    };
   }
-  /**
-   * @zh 设置位置的移动代价
-   * @en Set movement cost at position
-   */
-  setCost(x, y, cost) {
-    const node = this.getNodeAt(x, y);
-    if (node) {
-      node.cost = cost;
+  buildClusters() {
+    const clusterSize = this.config.clusterSize;
+    const clustersX = Math.ceil(this.width / clusterSize);
+    const clustersY = Math.ceil(this.height / clusterSize);
+    this.clusterGrid = [];
+    for (let x = 0; x < clustersX; x++) {
+      this.clusterGrid[x] = [];
+    }
+    let clusterId = 0;
+    for (let cy = 0; cy < clustersY; cy++) {
+      for (let cx = 0; cx < clustersX; cx++) {
+        const cluster = {
+          id: clusterId++,
+          x: cx * clusterSize,
+          y: cy * clusterSize,
+          width: Math.min(clusterSize, this.width - cx * clusterSize),
+          height: Math.min(clusterSize, this.height - cy * clusterSize),
+          entrances: []
+        };
+        this.clusters.push(cluster);
+        this.clusterGrid[cx][cy] = cluster;
+      }
     }
   }
-  /**
-   * @zh 获取节点的邻居
-   * @en Get neighbors of a node
-   */
-  getNeighbors(node) {
-    const neighbors = [];
-    const { x, y } = node.position;
-    const directions = this.options.allowDiagonal ? DIRECTIONS_8 : DIRECTIONS_4;
-    for (let i = 0; i < directions.length; i++) {
-      const dir = directions[i];
-      const nx = x + dir.dx;
-      const ny = y + dir.dy;
-      if (!this.isInBounds(nx, ny)) {
-        continue;
+  findEntrances() {
+    const clusterSize = this.config.clusterSize;
+    const clustersX = Math.ceil(this.width / clusterSize);
+    const clustersY = Math.ceil(this.height / clusterSize);
+    for (let cy = 0; cy < clustersY; cy++) {
+      for (let cx = 0; cx < clustersX; cx++) {
+        const cluster = this.clusterGrid[cx][cy];
+        if (!cluster) continue;
+        if (cx < clustersX - 1) {
+          const rightCluster = this.clusterGrid[cx + 1]?.[cy];
+          if (rightCluster) {
+            this.findEntrancesBetween(cluster, rightCluster, "horizontal");
+          }
+        }
+        if (cy < clustersY - 1) {
+          const bottomCluster = this.clusterGrid[cx]?.[cy + 1];
+          if (bottomCluster) {
+            this.findEntrancesBetween(cluster, bottomCluster, "vertical");
+          }
+        }
       }
-      const neighbor = this.nodes[ny][nx];
-      if (!neighbor.walkable) {
-        continue;
+    }
+  }
+  findEntrancesBetween(cluster1, cluster2, direction) {
+    const maxWidth = this.config.maxEntranceWidth;
+    let entranceStart = null;
+    let entranceLength = 0;
+    if (direction === "horizontal") {
+      const x1 = cluster1.x + cluster1.width - 1;
+      const x2 = cluster2.x;
+      const startY = Math.max(cluster1.y, cluster2.y);
+      const endY = Math.min(cluster1.y + cluster1.height, cluster2.y + cluster2.height);
+      for (let y = startY; y < endY; y++) {
+        const walkable1 = this.map.isWalkable(x1, y);
+        const walkable2 = this.map.isWalkable(x2, y);
+        if (walkable1 && walkable2) {
+          if (entranceStart === null) {
+            entranceStart = y;
+            entranceLength = 1;
+          } else {
+            entranceLength++;
+          }
+          if (entranceLength >= maxWidth || y === endY - 1) {
+            this.createEntrance(cluster1, cluster2, x1, x2, entranceStart, entranceStart + entranceLength - 1, "horizontal");
+            entranceStart = null;
+            entranceLength = 0;
+          }
+        } else if (entranceStart !== null) {
+          this.createEntrance(cluster1, cluster2, x1, x2, entranceStart, entranceStart + entranceLength - 1, "horizontal");
+          entranceStart = null;
+          entranceLength = 0;
+        }
       }
-      if (this.options.avoidCorners && dir.dx !== 0 && dir.dy !== 0) {
-        const horizontal = this.getNodeAt(x + dir.dx, y);
-        const vertical = this.getNodeAt(x, y + dir.dy);
-        if (!horizontal?.walkable || !vertical?.walkable) {
-          continue;
+    } else {
+      const y1 = cluster1.y + cluster1.height - 1;
+      const y2 = cluster2.y;
+      const startX = Math.max(cluster1.x, cluster2.x);
+      const endX = Math.min(cluster1.x + cluster1.width, cluster2.x + cluster2.width);
+      for (let x = startX; x < endX; x++) {
+        const walkable1 = this.map.isWalkable(x, y1);
+        const walkable2 = this.map.isWalkable(x, y2);
+        if (walkable1 && walkable2) {
+          if (entranceStart === null) {
+            entranceStart = x;
+            entranceLength = 1;
+          } else {
+            entranceLength++;
+          }
+          if (entranceLength >= maxWidth || x === endX - 1) {
+            this.createEntrance(cluster1, cluster2, entranceStart, entranceStart + entranceLength - 1, y1, y2, "vertical");
+            entranceStart = null;
+            entranceLength = 0;
+          }
+        } else if (entranceStart !== null) {
+          this.createEntrance(cluster1, cluster2, entranceStart, entranceStart + entranceLength - 1, y1, y2, "vertical");
+          entranceStart = null;
+          entranceLength = 0;
         }
       }
-      neighbors.push(neighbor);
     }
-    return neighbors;
-  }
-  /**
-   * @zh 计算启发式距离
-   * @en Calculate heuristic distance
-   */
-  heuristic(a, b) {
-    return this.options.heuristic(a, b);
   }
-  /**
-   * @zh 计算移动代价
-   * @en Calculate movement cost
-   */
-  getMovementCost(from, to) {
-    const dx = Math.abs(from.position.x - to.position.x);
-    const dy = Math.abs(from.position.y - to.position.y);
-    if (dx !== 0 && dy !== 0) {
-      return to.cost * this.options.diagonalCost;
+  createEntrance(cluster1, cluster2, coord1Start, coord1End, coord2Start, coord2End, direction) {
+    let point1;
+    let point2;
+    let center;
+    if (direction === "horizontal") {
+      const midY = Math.floor((coord1Start + coord1End) / 2);
+      point1 = {
+        x: coord1Start,
+        y: midY
+      };
+      point2 = {
+        x: coord2Start,
+        y: midY
+      };
+      center = {
+        x: coord1Start,
+        y: midY
+      };
+    } else {
+      const midX = Math.floor((coord1Start + coord1End) / 2);
+      point1 = {
+        x: midX,
+        y: coord2Start
+      };
+      point2 = {
+        x: midX,
+        y: coord2End
+      };
+      center = {
+        x: midX,
+        y: coord2Start
+      };
+    }
+    const entrance = {
+      id: this.nextEntranceId++,
+      cluster1Id: cluster1.id,
+      cluster2Id: cluster2.id,
+      point1,
+      point2,
+      center
+    };
+    this.entrances.push(entrance);
+    cluster1.entrances.push(entrance);
+    cluster2.entrances.push(entrance);
+  }
+  buildAbstractGraph() {
+    for (const entrance of this.entrances) {
+      const node1 = this.createAbstractNode(entrance.point1, entrance.cluster1Id, entrance.id);
+      const node2 = this.createAbstractNode(entrance.point2, entrance.cluster2Id, entrance.id);
+      node1.edges.push({
+        targetNodeId: node2.id,
+        cost: 1,
+        isInterEdge: true
+      });
+      node2.edges.push({
+        targetNodeId: node1.id,
+        cost: 1,
+        isInterEdge: true
+      });
+    }
+    for (const cluster of this.clusters) {
+      this.connectIntraClusterNodes(cluster);
+    }
+  }
+  createAbstractNode(position, clusterId, entranceId) {
+    const node = {
+      id: this.nextNodeId++,
+      position,
+      clusterId,
+      entranceId,
+      edges: []
+    };
+    this.abstractNodes.set(node.id, node);
+    return node;
+  }
+  connectIntraClusterNodes(cluster) {
+    const nodesInCluster = [];
+    for (const node of this.abstractNodes.values()) {
+      if (node.clusterId === cluster.id) {
+        nodesInCluster.push(node);
+      }
+    }
+    for (let i = 0; i < nodesInCluster.length; i++) {
+      for (let j = i + 1; j < nodesInCluster.length; j++) {
+        const node1 = nodesInCluster[i];
+        const node2 = nodesInCluster[j];
+        const cost = this.heuristic(node1.position, node2.position);
+        node1.edges.push({
+          targetNodeId: node2.id,
+          cost,
+          isInterEdge: false
+        });
+        node2.edges.push({
+          targetNodeId: node1.id,
+          cost,
+          isInterEdge: false
+        });
+      }
     }
-    return to.cost;
   }
-  /**
-   * @zh 从二维数组加载地图
-   * @en Load map from 2D array
-   *
-   * @param data - @zh 0=可通行，非0=不可通行 @en 0=walkable, non-0=blocked
-   */
-  loadFromArray(data) {
-    for (let y = 0; y < Math.min(data.length, this.height); y++) {
-      for (let x = 0; x < Math.min(data[y].length, this.width); x++) {
-        this.nodes[y][x].walkable = data[y][x] === 0;
+  // =========================================================================
+  // 搜索方法 | Search Methods
+  // =========================================================================
+  getClusterAt(x, y) {
+    const clusterSize = this.config.clusterSize;
+    const cx = Math.floor(x / clusterSize);
+    const cy = Math.floor(y / clusterSize);
+    return this.clusterGrid[cx]?.[cy] ?? null;
+  }
+  insertTemporaryNode(x, y, cluster) {
+    const tempNodes = [];
+    const tempNode = this.createAbstractNode({
+      x,
+      y
+    }, cluster.id, -1);
+    tempNodes.push(tempNode);
+    for (const node of this.abstractNodes.values()) {
+      if (node.clusterId === cluster.id && node.id !== tempNode.id) {
+        const cost = this.heuristic({
+          x,
+          y
+        }, node.position);
+        tempNode.edges.push({
+          targetNodeId: node.id,
+          cost,
+          isInterEdge: false
+        });
+        node.edges.push({
+          targetNodeId: tempNode.id,
+          cost,
+          isInterEdge: false
+        });
       }
     }
+    return tempNodes;
   }
-  /**
-   * @zh 从字符串加载地图
-   * @en Load map from string
-   *
-   * @param str - @zh 地图字符串，'.'=可通行，'#'=障碍 @en Map string, '.'=walkable, '#'=blocked
-   */
-  loadFromString(str) {
-    const lines = str.trim().split("\n");
-    for (let y = 0; y < Math.min(lines.length, this.height); y++) {
-      const line = lines[y];
-      for (let x = 0; x < Math.min(line.length, this.width); x++) {
-        this.nodes[y][x].walkable = line[x] !== "#";
+  removeTemporaryNodes(nodes) {
+    for (const node of nodes) {
+      for (const edge of node.edges) {
+        const targetNode = this.abstractNodes.get(edge.targetNodeId);
+        if (targetNode) {
+          targetNode.edges = targetNode.edges.filter((e) => e.targetNodeId !== node.id);
+        }
       }
+      this.abstractNodes.delete(node.id);
     }
   }
-  /**
-   * @zh 导出为字符串
-   * @en Export to string
-   */
-  toString() {
-    let result = "";
-    for (let y = 0; y < this.height; y++) {
-      for (let x = 0; x < this.width; x++) {
-        result += this.nodes[y][x].walkable ? "." : "#";
+  searchAbstractGraph(startNodes, endNodes, opts) {
+    if (startNodes.length === 0 || endNodes.length === 0) {
+      return null;
+    }
+    const endNodeIds = new Set(endNodes.map((n) => n.id));
+    const openList = new BinaryHeap((a, b) => a.f - b.f);
+    const closedSet = /* @__PURE__ */ new Set();
+    for (const startNode of startNodes) {
+      const h = this.heuristic(startNode.position, endNodes[0].position);
+      openList.push({
+        abstractNode: startNode,
+        g: 0,
+        h: h * opts.heuristicWeight,
+        f: h * opts.heuristicWeight,
+        parent: null
+      });
+    }
+    let nodesSearched = 0;
+    while (!openList.isEmpty && nodesSearched < opts.maxNodes) {
+      const current = openList.pop();
+      nodesSearched++;
+      if (endNodeIds.has(current.abstractNode.id)) {
+        return this.reconstructAbstractPath(current);
+      }
+      if (closedSet.has(current.abstractNode.id)) {
+        continue;
+      }
+      closedSet.add(current.abstractNode.id);
+      for (const edge of current.abstractNode.edges) {
+        if (closedSet.has(edge.targetNodeId)) {
+          continue;
+        }
+        const neighbor = this.abstractNodes.get(edge.targetNodeId);
+        if (!neighbor) continue;
+        const tentativeG = current.g + edge.cost;
+        const h = this.heuristic(neighbor.position, endNodes[0].position) * opts.heuristicWeight;
+        openList.push({
+          abstractNode: neighbor,
+          g: tentativeG,
+          h,
+          f: tentativeG + h,
+          parent: current
+        });
       }
-      result += "\n";
     }
-    return result;
+    return null;
   }
-  /**
-   * @zh 重置所有节点为可通行
-   * @en Reset all nodes to walkable
-   */
-  reset() {
-    for (let y = 0; y < this.height; y++) {
-      for (let x = 0; x < this.width; x++) {
-        this.nodes[y][x].walkable = true;
-        this.nodes[y][x].cost = 1;
+  reconstructAbstractPath(endNode) {
+    const path = [];
+    let current = endNode;
+    while (current) {
+      path.unshift(current.abstractNode);
+      current = current.parent;
+    }
+    return path;
+  }
+  refinePath(abstractPath, startX, startY, endX, endY, opts) {
+    const fullPath = [];
+    let totalCost = 0;
+    let nodesSearched = abstractPath.length;
+    let currentX = startX;
+    let currentY = startY;
+    for (let i = 0; i < abstractPath.length; i++) {
+      const node = abstractPath[i];
+      const targetX = i === abstractPath.length - 1 ? endX : node.position.x;
+      const targetY = i === abstractPath.length - 1 ? endY : node.position.y;
+      if (currentX !== targetX || currentY !== targetY) {
+        const segment = this.localPathfinder.findPath(currentX, currentY, targetX, targetY, opts);
+        if (!segment.found) {
+          if (fullPath.length > 0) {
+            return {
+              found: true,
+              path: fullPath,
+              cost: totalCost,
+              nodesSearched
+            };
+          }
+          return EMPTY_PATH_RESULT;
+        }
+        for (let j = fullPath.length === 0 ? 0 : 1; j < segment.path.length; j++) {
+          fullPath.push(segment.path[j]);
+        }
+        totalCost += segment.cost;
+        nodesSearched += segment.nodesSearched;
+      }
+      currentX = targetX;
+      currentY = targetY;
+    }
+    if (currentX !== endX || currentY !== endY) {
+      const finalSegment = this.localPathfinder.findPath(currentX, currentY, endX, endY, opts);
+      if (finalSegment.found) {
+        for (let j = 1; j < finalSegment.path.length; j++) {
+          fullPath.push(finalSegment.path[j]);
+        }
+        totalCost += finalSegment.cost;
+        nodesSearched += finalSegment.nodesSearched;
       }
     }
+    return {
+      found: fullPath.length > 0,
+      path: fullPath,
+      cost: totalCost,
+      nodesSearched
+    };
   }
-  /**
-   * @zh 设置矩形区域的通行性
-   * @en Set walkability for a rectangle region
-   */
-  setRectWalkable(x, y, width, height, walkable) {
-    for (let dy = 0; dy < height; dy++) {
-      for (let dx = 0; dx < width; dx++) {
-        this.setWalkable(x + dx, y + dy, walkable);
+  // =========================================================================
+  // 辅助方法 | Helper Methods
+  // =========================================================================
+  findLocalPath(startX, startY, endX, endY, opts) {
+    return this.localPathfinder.findPath(startX, startY, endX, endY, opts);
+  }
+  findInternalPath(startX, startY, endX, endY, cluster) {
+    const cacheKey = `${cluster.id}:${startX},${startY}->${endX},${endY}`;
+    if (this.config.cacheInternalPaths) {
+      const cached = this.internalPathCache.get(cacheKey);
+      if (cached) {
+        return cached;
       }
     }
+    const result = this.localPathfinder.findPath(startX, startY, endX, endY);
+    if (result.found && this.config.cacheInternalPaths) {
+      this.internalPathCache.set(cacheKey, [
+        ...result.path
+      ]);
+    }
+    return result.found ? [
+      ...result.path
+    ] : null;
+  }
+  calculatePathCost(path) {
+    let cost = 0;
+    for (let i = 1; i < path.length; i++) {
+      const dx = Math.abs(path[i].x - path[i - 1].x);
+      const dy = Math.abs(path[i].y - path[i - 1].y);
+      cost += dx !== 0 && dy !== 0 ? Math.SQRT2 : 1;
+    }
+    return cost;
+  }
+  heuristic(a, b) {
+    const dx = Math.abs(a.x - b.x);
+    const dy = Math.abs(a.y - b.y);
+    return dx + dy + (Math.SQRT2 - 2) * Math.min(dx, dy);
   }
 };
-__name(_GridMap, "GridMap");
-var GridMap = _GridMap;
-function createGridMap(width, height, options) {
-  return new GridMap(width, height, options);
+__name(_HPAPathfinder, "HPAPathfinder");
+var HPAPathfinder = _HPAPathfinder;
+function createHPAPathfinder(map, config) {
+  return new HPAPathfinder(map, config);
 }
-__name(createGridMap, "createGridMap");
+__name(createHPAPathfinder, "createHPAPathfinder");
 
 // src/navmesh/NavMesh.ts
-var _a;
-var NavMeshNode = (_a = class {
+var _a3;
+var NavMeshNode = (_a3 = class {
   constructor(polygon) {
     __publicField(this, "id");
     __publicField(this, "position");
@@ -603,7 +1958,7 @@ var NavMeshNode = (_a = class {
     this.walkable = true;
     this.polygon = polygon;
   }
-}, __name(_a, "NavMeshNode"), _a);
+}, __name(_a3, "NavMeshNode"), _a3);
 var _NavMesh = class _NavMesh {
   constructor() {
     __publicField(this, "polygons", /* @__PURE__ */ new Map());
@@ -1004,819 +2359,48 @@ function createNavMesh() {
   return new NavMesh();
 }
 __name(createNavMesh, "createNavMesh");
-
-// src/smoothing/PathSmoother.ts
-function bresenhamLineOfSight(x1, y1, x2, y2, map) {
-  let ix1 = Math.floor(x1);
-  let iy1 = Math.floor(y1);
-  const ix2 = Math.floor(x2);
-  const iy2 = Math.floor(y2);
-  const dx = Math.abs(ix2 - ix1);
-  const dy = Math.abs(iy2 - iy1);
-  const sx = ix1 < ix2 ? 1 : -1;
-  const sy = iy1 < iy2 ? 1 : -1;
-  let err = dx - dy;
-  while (true) {
-    if (!map.isWalkable(ix1, iy1)) {
-      return false;
-    }
-    if (ix1 === ix2 && iy1 === iy2) {
-      break;
-    }
-    const e2 = 2 * err;
-    if (e2 > -dy) {
-      err -= dy;
-      ix1 += sx;
-    }
-    if (e2 < dx) {
-      err += dx;
-      iy1 += sy;
-    }
-  }
-  return true;
-}
-__name(bresenhamLineOfSight, "bresenhamLineOfSight");
-function raycastLineOfSight(x1, y1, x2, y2, map, stepSize = 0.5) {
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  const distance = Math.sqrt(dx * dx + dy * dy);
-  if (distance === 0) {
-    return map.isWalkable(Math.floor(x1), Math.floor(y1));
-  }
-  const steps = Math.ceil(distance / stepSize);
-  const stepX = dx / steps;
-  const stepY = dy / steps;
-  let x = x1;
-  let y = y1;
-  for (let i = 0; i <= steps; i++) {
-    if (!map.isWalkable(Math.floor(x), Math.floor(y))) {
-      return false;
-    }
-    x += stepX;
-    y += stepY;
-  }
-  return true;
-}
-__name(raycastLineOfSight, "raycastLineOfSight");
-var _LineOfSightSmoother = class _LineOfSightSmoother {
-  constructor(lineOfSight = bresenhamLineOfSight) {
-    __publicField(this, "lineOfSight");
-    this.lineOfSight = lineOfSight;
-  }
-  smooth(path, map) {
-    if (path.length <= 2) {
-      return [
-        ...path
-      ];
-    }
-    const result = [
-      path[0]
-    ];
-    let current = 0;
-    while (current < path.length - 1) {
-      let furthest = current + 1;
-      for (let i = path.length - 1; i > current + 1; i--) {
-        if (this.lineOfSight(path[current].x, path[current].y, path[i].x, path[i].y, map)) {
-          furthest = i;
-          break;
-        }
-      }
-      result.push(path[furthest]);
-      current = furthest;
-    }
-    return result;
-  }
-};
-__name(_LineOfSightSmoother, "LineOfSightSmoother");
-var LineOfSightSmoother = _LineOfSightSmoother;
-var _CatmullRomSmoother = class _CatmullRomSmoother {
-  /**
-   * @param segments - @zh 每段之间的插值点数 @en Number of interpolation points per segment
-   * @param tension - @zh 张力 (0-1) @en Tension (0-1)
-   */
-  constructor(segments = 5, tension = 0.5) {
-    __publicField(this, "segments");
-    __publicField(this, "tension");
-    this.segments = segments;
-    this.tension = tension;
-  }
-  smooth(path, _map) {
-    if (path.length <= 2) {
-      return [
-        ...path
-      ];
-    }
-    const result = [];
-    const points = [
-      path[0],
-      ...path,
-      path[path.length - 1]
-    ];
-    for (let i = 1; i < points.length - 2; i++) {
-      const p0 = points[i - 1];
-      const p1 = points[i];
-      const p2 = points[i + 1];
-      const p3 = points[i + 2];
-      for (let j = 0; j < this.segments; j++) {
-        const t = j / this.segments;
-        const point = this.interpolate(p0, p1, p2, p3, t);
-        result.push(point);
-      }
-    }
-    result.push(path[path.length - 1]);
-    return result;
-  }
-  /**
-   * @zh Catmull-Rom 插值
-   * @en Catmull-Rom interpolation
-   */
-  interpolate(p0, p1, p2, p3, t) {
-    const t2 = t * t;
-    const t3 = t2 * t;
-    const tension = this.tension;
-    const x = 0.5 * (2 * p1.x + (-p0.x + p2.x) * t * tension + (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 * tension + (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3 * tension);
-    const y = 0.5 * (2 * p1.y + (-p0.y + p2.y) * t * tension + (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 * tension + (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3 * tension);
-    return createPoint(x, y);
-  }
-};
-__name(_CatmullRomSmoother, "CatmullRomSmoother");
-var CatmullRomSmoother = _CatmullRomSmoother;
-var _CombinedSmoother = class _CombinedSmoother {
-  constructor(curveSegments = 5, tension = 0.5) {
-    __publicField(this, "simplifier");
-    __publicField(this, "curveSmoother");
-    this.simplifier = new LineOfSightSmoother();
-    this.curveSmoother = new CatmullRomSmoother(curveSegments, tension);
-  }
-  smooth(path, map) {
-    const simplified = this.simplifier.smooth(path, map);
-    return this.curveSmoother.smooth(simplified, map);
-  }
-};
-__name(_CombinedSmoother, "CombinedSmoother");
-var CombinedSmoother = _CombinedSmoother;
-function createLineOfSightSmoother(lineOfSight) {
-  return new LineOfSightSmoother(lineOfSight);
-}
-__name(createLineOfSightSmoother, "createLineOfSightSmoother");
-function createCatmullRomSmoother(segments, tension) {
-  return new CatmullRomSmoother(segments, tension);
-}
-__name(createCatmullRomSmoother, "createCatmullRomSmoother");
-function createCombinedSmoother(curveSegments, tension) {
-  return new CombinedSmoother(curveSegments, tension);
-}
-__name(createCombinedSmoother, "createCombinedSmoother");
-
-// src/nodes/PathfindingNodes.ts
-var FindPathTemplate = {
-  type: "FindPath",
-  title: "Find Path",
-  category: "custom",
-  description: "Find path from start to end / \u4ECE\u8D77\u70B9\u5230\u7EC8\u70B9\u5BFB\u8DEF",
-  keywords: [
-    "path",
-    "pathfinding",
-    "astar",
-    "navigate",
-    "route"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Find Path"
-  ],
-  inputs: [
-    {
-      name: "exec",
-      displayName: "",
-      type: "exec"
-    },
-    {
-      name: "startX",
-      displayName: "Start X",
-      type: "float"
-    },
-    {
-      name: "startY",
-      displayName: "Start Y",
-      type: "float"
-    },
-    {
-      name: "endX",
-      displayName: "End X",
-      type: "float"
-    },
-    {
-      name: "endY",
-      displayName: "End Y",
-      type: "float"
-    }
-  ],
-  outputs: [
-    {
-      name: "exec",
-      displayName: "",
-      type: "exec"
-    },
-    {
-      name: "found",
-      displayName: "Found",
-      type: "bool"
-    },
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    },
-    {
-      name: "cost",
-      displayName: "Cost",
-      type: "float"
-    }
-  ],
-  color: "#4caf50"
-};
-var _FindPathExecutor = class _FindPathExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const startX = ctx.evaluateInput(node.id, "startX", 0);
-    const startY = ctx.evaluateInput(node.id, "startY", 0);
-    const endX = ctx.evaluateInput(node.id, "endX", 0);
-    const endY = ctx.evaluateInput(node.id, "endY", 0);
-    const result = ctx.findPath(startX, startY, endX, endY);
-    return {
-      outputs: {
-        found: result.found,
-        path: result.path,
-        cost: result.cost
-      },
-      nextExec: "exec"
-    };
-  }
-};
-__name(_FindPathExecutor, "FindPathExecutor");
-var FindPathExecutor = _FindPathExecutor;
-var FindPathSmoothTemplate = {
-  type: "FindPathSmooth",
-  title: "Find Path (Smooth)",
-  category: "custom",
-  description: "Find path with smoothing / \u5BFB\u8DEF\u5E76\u5E73\u6ED1\u8DEF\u5F84",
-  keywords: [
-    "path",
-    "pathfinding",
-    "smooth",
-    "navigate"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Find Path (Smooth)"
-  ],
-  inputs: [
-    {
-      name: "exec",
-      displayName: "",
-      type: "exec"
-    },
-    {
-      name: "startX",
-      displayName: "Start X",
-      type: "float"
-    },
-    {
-      name: "startY",
-      displayName: "Start Y",
-      type: "float"
-    },
-    {
-      name: "endX",
-      displayName: "End X",
-      type: "float"
-    },
-    {
-      name: "endY",
-      displayName: "End Y",
-      type: "float"
-    }
-  ],
-  outputs: [
-    {
-      name: "exec",
-      displayName: "",
-      type: "exec"
-    },
-    {
-      name: "found",
-      displayName: "Found",
-      type: "bool"
-    },
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    },
-    {
-      name: "cost",
-      displayName: "Cost",
-      type: "float"
-    }
-  ],
-  color: "#4caf50"
-};
-var _FindPathSmoothExecutor = class _FindPathSmoothExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const startX = ctx.evaluateInput(node.id, "startX", 0);
-    const startY = ctx.evaluateInput(node.id, "startY", 0);
-    const endX = ctx.evaluateInput(node.id, "endX", 0);
-    const endY = ctx.evaluateInput(node.id, "endY", 0);
-    const result = ctx.findPathSmooth(startX, startY, endX, endY);
-    return {
-      outputs: {
-        found: result.found,
-        path: result.path,
-        cost: result.cost
-      },
-      nextExec: "exec"
-    };
-  }
-};
-__name(_FindPathSmoothExecutor, "FindPathSmoothExecutor");
-var FindPathSmoothExecutor = _FindPathSmoothExecutor;
-var IsWalkableTemplate = {
-  type: "IsWalkable",
-  title: "Is Walkable",
-  category: "custom",
-  description: "Check if position is walkable / \u68C0\u67E5\u4F4D\u7F6E\u662F\u5426\u53EF\u901A\u884C",
-  keywords: [
-    "walkable",
-    "obstacle",
-    "blocked",
-    "terrain"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Is Walkable"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "x",
-      displayName: "X",
-      type: "float"
-    },
-    {
-      name: "y",
-      displayName: "Y",
-      type: "float"
-    }
-  ],
-  outputs: [
-    {
-      name: "walkable",
-      displayName: "Walkable",
-      type: "bool"
-    }
-  ],
-  color: "#4caf50"
-};
-var _IsWalkableExecutor = class _IsWalkableExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const x = ctx.evaluateInput(node.id, "x", 0);
-    const y = ctx.evaluateInput(node.id, "y", 0);
-    const walkable = ctx.isWalkable(x, y);
-    return {
-      outputs: {
-        walkable
-      }
-    };
-  }
-};
-__name(_IsWalkableExecutor, "IsWalkableExecutor");
-var IsWalkableExecutor = _IsWalkableExecutor;
-var GetPathLengthTemplate = {
-  type: "GetPathLength",
-  title: "Get Path Length",
-  category: "custom",
-  description: "Get the number of points in path / \u83B7\u53D6\u8DEF\u5F84\u70B9\u6570\u91CF",
-  keywords: [
-    "path",
-    "length",
-    "count",
-    "waypoints"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Get Path Length"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    }
-  ],
-  outputs: [
-    {
-      name: "length",
-      displayName: "Length",
-      type: "int"
-    }
-  ],
-  color: "#4caf50"
-};
-var _GetPathLengthExecutor = class _GetPathLengthExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const path = ctx.evaluateInput(node.id, "path", []);
-    return {
-      outputs: {
-        length: path.length
-      }
-    };
-  }
-};
-__name(_GetPathLengthExecutor, "GetPathLengthExecutor");
-var GetPathLengthExecutor = _GetPathLengthExecutor;
-var GetPathDistanceTemplate = {
-  type: "GetPathDistance",
-  title: "Get Path Distance",
-  category: "custom",
-  description: "Get total path distance / \u83B7\u53D6\u8DEF\u5F84\u603B\u8DDD\u79BB",
-  keywords: [
-    "path",
-    "distance",
-    "length",
-    "travel"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Get Path Distance"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    }
-  ],
-  outputs: [
-    {
-      name: "distance",
-      displayName: "Distance",
-      type: "float"
-    }
-  ],
-  color: "#4caf50"
-};
-var _GetPathDistanceExecutor = class _GetPathDistanceExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const path = ctx.evaluateInput(node.id, "path", []);
-    const distance = ctx.getPathDistance(path);
-    return {
-      outputs: {
-        distance
-      }
-    };
-  }
-};
-__name(_GetPathDistanceExecutor, "GetPathDistanceExecutor");
-var GetPathDistanceExecutor = _GetPathDistanceExecutor;
-var GetPathPointTemplate = {
-  type: "GetPathPoint",
-  title: "Get Path Point",
-  category: "custom",
-  description: "Get point at index in path / \u83B7\u53D6\u8DEF\u5F84\u4E2D\u6307\u5B9A\u7D22\u5F15\u7684\u70B9",
-  keywords: [
-    "path",
-    "point",
-    "waypoint",
-    "index"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Get Path Point"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    },
-    {
-      name: "index",
-      displayName: "Index",
-      type: "int"
-    }
-  ],
-  outputs: [
-    {
-      name: "x",
-      displayName: "X",
-      type: "float"
-    },
-    {
-      name: "y",
-      displayName: "Y",
-      type: "float"
-    },
-    {
-      name: "valid",
-      displayName: "Valid",
-      type: "bool"
-    }
-  ],
-  color: "#4caf50"
-};
-var _GetPathPointExecutor = class _GetPathPointExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const path = ctx.evaluateInput(node.id, "path", []);
-    const index = ctx.evaluateInput(node.id, "index", 0);
-    if (index >= 0 && index < path.length) {
-      return {
-        outputs: {
-          x: path[index].x,
-          y: path[index].y,
-          valid: true
-        }
-      };
-    }
-    return {
-      outputs: {
-        x: 0,
-        y: 0,
-        valid: false
-      }
-    };
-  }
-};
-__name(_GetPathPointExecutor, "GetPathPointExecutor");
-var GetPathPointExecutor = _GetPathPointExecutor;
-var MoveAlongPathTemplate = {
-  type: "MoveAlongPath",
-  title: "Move Along Path",
-  category: "custom",
-  description: "Get position along path at progress / \u83B7\u53D6\u8DEF\u5F84\u4E0A\u6307\u5B9A\u8FDB\u5EA6\u7684\u4F4D\u7F6E",
-  keywords: [
-    "path",
-    "move",
-    "lerp",
-    "progress",
-    "interpolate"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Move Along Path"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "path",
-      displayName: "Path",
-      type: "array"
-    },
-    {
-      name: "progress",
-      displayName: "Progress (0-1)",
-      type: "float"
-    }
-  ],
-  outputs: [
-    {
-      name: "x",
-      displayName: "X",
-      type: "float"
-    },
-    {
-      name: "y",
-      displayName: "Y",
-      type: "float"
-    }
-  ],
-  color: "#4caf50"
-};
-var _MoveAlongPathExecutor = class _MoveAlongPathExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const path = ctx.evaluateInput(node.id, "path", []);
-    let progress = ctx.evaluateInput(node.id, "progress", 0);
-    if (path.length === 0) {
-      return {
-        outputs: {
-          x: 0,
-          y: 0
-        }
-      };
-    }
-    if (path.length === 1) {
-      return {
-        outputs: {
-          x: path[0].x,
-          y: path[0].y
-        }
-      };
-    }
-    progress = Math.max(0, Math.min(1, progress));
-    let totalDistance = 0;
-    const segmentDistances = [];
-    for (let i = 1; i < path.length; i++) {
-      const dx = path[i].x - path[i - 1].x;
-      const dy = path[i].y - path[i - 1].y;
-      const dist = Math.sqrt(dx * dx + dy * dy);
-      segmentDistances.push(dist);
-      totalDistance += dist;
-    }
-    if (totalDistance === 0) {
-      return {
-        outputs: {
-          x: path[0].x,
-          y: path[0].y
-        }
-      };
-    }
-    const targetDistance = progress * totalDistance;
-    let accumulatedDistance = 0;
-    for (let i = 0; i < segmentDistances.length; i++) {
-      const segmentDist = segmentDistances[i];
-      if (accumulatedDistance + segmentDist >= targetDistance) {
-        const segmentProgress = (targetDistance - accumulatedDistance) / segmentDist;
-        const x = path[i].x + (path[i + 1].x - path[i].x) * segmentProgress;
-        const y = path[i].y + (path[i + 1].y - path[i].y) * segmentProgress;
-        return {
-          outputs: {
-            x,
-            y
-          }
-        };
-      }
-      accumulatedDistance += segmentDist;
-    }
-    const last = path[path.length - 1];
-    return {
-      outputs: {
-        x: last.x,
-        y: last.y
-      }
-    };
-  }
-};
-__name(_MoveAlongPathExecutor, "MoveAlongPathExecutor");
-var MoveAlongPathExecutor = _MoveAlongPathExecutor;
-var HasLineOfSightTemplate = {
-  type: "HasLineOfSight",
-  title: "Has Line of Sight",
-  category: "custom",
-  description: "Check if there is a clear line between two points / \u68C0\u67E5\u4E24\u70B9\u4E4B\u95F4\u662F\u5426\u6709\u6E05\u6670\u7684\u89C6\u7EBF",
-  keywords: [
-    "line",
-    "sight",
-    "los",
-    "visibility",
-    "raycast"
-  ],
-  menuPath: [
-    "Pathfinding",
-    "Has Line of Sight"
-  ],
-  isPure: true,
-  inputs: [
-    {
-      name: "startX",
-      displayName: "Start X",
-      type: "float"
-    },
-    {
-      name: "startY",
-      displayName: "Start Y",
-      type: "float"
-    },
-    {
-      name: "endX",
-      displayName: "End X",
-      type: "float"
-    },
-    {
-      name: "endY",
-      displayName: "End Y",
-      type: "float"
-    }
-  ],
-  outputs: [
-    {
-      name: "hasLOS",
-      displayName: "Has LOS",
-      type: "bool"
-    }
-  ],
-  color: "#4caf50"
-};
-var _HasLineOfSightExecutor = class _HasLineOfSightExecutor {
-  execute(node, context) {
-    const ctx = context;
-    const startX = ctx.evaluateInput(node.id, "startX", 0);
-    const startY = ctx.evaluateInput(node.id, "startY", 0);
-    const endX = ctx.evaluateInput(node.id, "endX", 0);
-    const endY = ctx.evaluateInput(node.id, "endY", 0);
-    const hasLOS = ctx.hasLineOfSight?.(startX, startY, endX, endY) ?? true;
-    return {
-      outputs: {
-        hasLOS
-      }
-    };
-  }
-};
-__name(_HasLineOfSightExecutor, "HasLineOfSightExecutor");
-var HasLineOfSightExecutor = _HasLineOfSightExecutor;
-var PathfindingNodeDefinitions = {
-  templates: [
-    FindPathTemplate,
-    FindPathSmoothTemplate,
-    IsWalkableTemplate,
-    GetPathLengthTemplate,
-    GetPathDistanceTemplate,
-    GetPathPointTemplate,
-    MoveAlongPathTemplate,
-    HasLineOfSightTemplate
-  ],
-  executors: /* @__PURE__ */ new Map([
-    [
-      "FindPath",
-      new FindPathExecutor()
-    ],
-    [
-      "FindPathSmooth",
-      new FindPathSmoothExecutor()
-    ],
-    [
-      "IsWalkable",
-      new IsWalkableExecutor()
-    ],
-    [
-      "GetPathLength",
-      new GetPathLengthExecutor()
-    ],
-    [
-      "GetPathDistance",
-      new GetPathDistanceExecutor()
-    ],
-    [
-      "GetPathPoint",
-      new GetPathPointExecutor()
-    ],
-    [
-      "MoveAlongPath",
-      new MoveAlongPathExecutor()
-    ],
-    [
-      "HasLineOfSight",
-      new HasLineOfSightExecutor()
-    ]
-  ])
-};
 export {
   AStarPathfinder,
   BinaryHeap,
   CatmullRomSmoother,
   CombinedSmoother,
   DEFAULT_GRID_OPTIONS,
+  DEFAULT_HPA_CONFIG,
   DEFAULT_PATHFINDING_OPTIONS,
+  DEFAULT_PATH_CACHE_CONFIG,
+  DEFAULT_REPLANNING_CONFIG,
   DIRECTIONS_4,
   DIRECTIONS_8,
   EMPTY_PATH_RESULT,
-  FindPathExecutor,
-  FindPathSmoothExecutor,
-  FindPathSmoothTemplate,
-  FindPathTemplate,
-  GetPathDistanceExecutor,
-  GetPathDistanceTemplate,
-  GetPathLengthExecutor,
-  GetPathLengthTemplate,
-  GetPathPointExecutor,
-  GetPathPointTemplate,
+  EMPTY_PROGRESS,
   GridMap,
   GridNode,
-  HasLineOfSightExecutor,
-  HasLineOfSightTemplate,
-  IsWalkableExecutor,
-  IsWalkableTemplate,
+  GridPathfinder,
+  HPAPathfinder,
+  IncrementalAStarPathfinder,
+  IndexedBinaryHeap,
+  JPSPathfinder,
   LineOfSightSmoother,
-  MoveAlongPathExecutor,
-  MoveAlongPathTemplate,
   NavMesh,
-  PathfindingNodeDefinitions,
+  ObstacleChangeManager,
+  PathCache,
+  PathValidator,
+  PathfindingState,
   bresenhamLineOfSight,
   chebyshevDistance,
   createAStarPathfinder,
   createCatmullRomSmoother,
   createCombinedSmoother,
   createGridMap,
+  createGridPathfinder,
+  createHPAPathfinder,
+  createIncrementalAStarPathfinder,
+  createJPSPathfinder,
   createLineOfSightSmoother,
   createNavMesh,
+  createObstacleChangeManager,
+  createPathCache,
+  createPathValidator,
   createPoint,
   euclideanDistance,
   manhattanDistance,