@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/nav/flow.js

@@ -0,0 +1,193 @@
+import { edgeCostOf, NEIGHBOUR_X, NEIGHBOUR_Y, stepLength } from './grid.js';
+import { CellHeap } from './heap.js';
+const NX = NEIGHBOUR_X;
+const NY = NEIGHBOUR_Y;
+class Field {
+    grid;
+    distances;
+    directions;
+    stepCosts;
+    goals;
+    goalCount = 0;
+    version = -1;
+    key;
+    heap;
+    constructor(grid) {
+        this.grid = grid;
+        const n = grid.size;
+        this.distances = new Float32Array(n).fill(Infinity);
+        this.directions = new Float32Array(n * 2);
+        this.stepCosts = new Float32Array(n).fill(Infinity);
+        this.goals = new Int32Array(n);
+        this.key = new Float64Array(n);
+        this.heap = new CellHeap(n, this.key);
+    }
+    get stale() {
+        return this.version !== this.grid.version;
+    }
+    build(goals) {
+        const grid = this.grid;
+        let count = 0;
+        for (let i = 0; i < goals.length && count < this.goals.length; i++) {
+            const c = goals[i];
+            if (!grid.inBounds(c.x, c.y))
+                continue;
+            this.goals[count++] = c.y * grid.width + c.x;
+        }
+        this.goalCount = count;
+        this.update();
+    }
+    setGoals(goals) {
+        const size = this.grid.size;
+        let count = 0;
+        for (let i = 0; i < goals.length && count < this.goals.length; i++) {
+            const gi = goals[i];
+            if (!(gi >= 0 && gi < size))
+                continue;
+            this.goals[count++] = gi;
+        }
+        this.goalCount = count;
+        this.update();
+    }
+    update() {
+        const grid = this.grid;
+        const width = grid.width;
+        const height = grid.height;
+        const costs = grid.costs;
+        const dirs8 = grid.neighbours;
+        const dist = this.key;
+        const heap = this.heap;
+        const hooked = grid.edgeCost !== undefined;
+        dist.fill(Infinity);
+        heap.clear();
+        for (let i = 0; i < this.goalCount; i++) {
+            const gi = this.goals[i];
+            if (costs[gi] <= 0)
+                continue;
+            dist[gi] = 0;
+            heap.pushOrDecrease(gi);
+        }
+        while (heap.size > 0) {
+            const cur = heap.pop();
+            const cx = cur % width;
+            const cy = (cur - cx) / width;
+            const dc = dist[cur];
+            // The search runs from the goals outward, so the edge is walked the other way: from the
+            // neighbour into `cur`. The hook sees it in that order, so a one-way ledge works.
+            for (let d = 0; d < dirs8; d++) {
+                const len = stepLength(grid, cx, cy, d);
+                if (len === Infinity)
+                    continue;
+                const ni = (cy + NY[d]) * width + cx + NX[d];
+                const nd = dc + len * costs[ni] + (hooked ? edgeCostOf(grid, ni, cur) : 0);
+                if (nd >= dist[ni])
+                    continue;
+                dist[ni] = nd;
+                heap.pushOrDecrease(ni);
+            }
+        }
+        // Directions: towards the lowest neighbour (a diagonal only when its corners are open).
+        // With an edge-cost hook the step itself counts, so a one-way ledge is never pointed at:
+        // the neighbour minimising step + distance, which equals the cell's own distance.
+        const dirs = this.directions;
+        const steps = this.stepCosts;
+        const out = this.distances;
+        for (let cy = 0; cy < height; cy++) {
+            for (let cx = 0; cx < width; cx++) {
+                const i = cy * width + cx;
+                const own = dist[i];
+                out[i] = own;
+                let best = own;
+                let bd = -1;
+                if (own > 0 && own < Infinity) {
+                    const own0 = costs[i];
+                    for (let d = 0; d < dirs8; d++) {
+                        const nx = cx + NX[d];
+                        const ny = cy + NY[d];
+                        if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                            continue;
+                        const ni = ny * width + nx;
+                        if (costs[ni] <= 0)
+                            continue;
+                        if (d >= 4 && (costs[cy * width + nx] <= 0 || costs[ny * width + cx] <= 0))
+                            continue;
+                        if (hooked) {
+                            const e = edgeCostOf(grid, i, ni);
+                            if (e === Infinity)
+                                continue;
+                            const nd = dist[ni] + (d < 4 ? own0 : own0 * Math.SQRT2) + e;
+                            // The minimum equals `own` exactly (same sum Dijkstra made); first tie wins.
+                            if (nd < best || (bd < 0 && nd <= own)) {
+                                best = nd;
+                                bd = d;
+                            }
+                        }
+                        else {
+                            const nd = dist[ni];
+                            if (nd < best) {
+                                best = nd;
+                                bd = d;
+                            }
+                        }
+                    }
+                }
+                if (bd < 0) {
+                    dirs[i * 2] = 0;
+                    dirs[i * 2 + 1] = 0;
+                    steps[i] = own === 0 ? 0 : Infinity;
+                }
+                else {
+                    const ni = (cy + NY[bd]) * width + cx + NX[bd];
+                    // What A* charges for this step: its length × the destination's cost, plus the hook.
+                    steps[i] =
+                        (bd < 4 ? 1 : Math.SQRT2) * costs[ni] + (hooked ? edgeCostOf(grid, i, ni) : 0);
+                    if (bd < 4) {
+                        dirs[i * 2] = NX[bd];
+                        dirs[i * 2 + 1] = NY[bd];
+                    }
+                    else {
+                        dirs[i * 2] = NX[bd] * Math.SQRT1_2;
+                        dirs[i * 2 + 1] = NY[bd] * Math.SQRT1_2;
+                    }
+                }
+            }
+        }
+        this.version = grid.version;
+    }
+    direction(cx, cy, out) {
+        if (!this.grid.inBounds(cx, cy)) {
+            out.x = 0;
+            out.z = 0;
+            if ('cost' in out)
+                out.cost = Infinity;
+            return out;
+        }
+        const i = cy * this.grid.width + cx;
+        out.x = this.directions[i * 2];
+        out.z = this.directions[i * 2 + 1];
+        if ('cost' in out)
+            out.cost = this.stepCosts[i];
+        return out;
+    }
+    directionAt(worldX, worldZ, out) {
+        const g = this.grid;
+        const cx = Math.floor((worldX - g.origin.x) / g.cellSize);
+        const cy = Math.floor((worldZ - g.origin.z) / g.cellSize);
+        return this.direction(cx, cy, out);
+    }
+    distance(cx, cy) {
+        if (!this.grid.inBounds(cx, cy))
+            return Infinity;
+        return this.distances[cy * this.grid.width + cx];
+    }
+}
+/**
+ * A flow field over `grid`: unbuilt (every distance `Infinity`, `version` -1) until
+ * `build(goals)` or `setGoals(goals)`, or built at once from `opts.goals`.
+ */
+export function createFlowField(grid, opts = {}) {
+    const f = new Field(grid);
+    if (opts.goals)
+        f.setGoals(opts.goals);
+    return f;
+}

package/dist/nav/grid.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The navigation grid: a field of cells over the XZ plane, each walkable or not and with a cost
+ * multiplier. The grid is the one thing every query reads; `version` increments on every edit so
+ * a cached path or flow field can tell it is stale. No game nouns: cells, costs, world points.
+ */
+/** A cell coordinate (`x` across, `y` down the grid; integers inside the grid). Mutable, reused. */
+export interface NavCell {
+    x: number;
+    y: number;
+}
+/** A point on the world XZ plane. `y` (height) is the game's or `geom`'s job. Mutable, reused. */
+export interface NavPoint {
+    x: number;
+    z: number;
+}
+export interface NavGridOptions {
+    /** Cells across. */
+    width: number;
+    /** Cells down. */
+    height: number;
+    /** World units per cell side. */
+    cellSize: number;
+    /** World XZ of the grid's corner (cell 0,0's min corner). Default the origin. */
+    origin?: Readonly<NavPoint>;
+    /** Initial walkability per cell. Default: every cell walkable. */
+    walkable?: (x: number, y: number) => boolean;
+    /** Initial cost multiplier per cell (≥ 0; 1 is plain ground). Default 1. */
+    cost?: (x: number, y: number) => number;
+    /**
+     * An extra cost for the step between two cells (row-major indices), added to the step's
+     * length × destination cost: a climb penalty, a one-way ledge. `Infinity` blocks the edge in
+     * that direction only; negative values are clamped to 0. Honoured by `findPath`,
+     * `createFlowField` and `reachable`; absent, a step costs its length × destination cost.
+     * Called per expanded edge, so keep it a lookup. Call `grid.touch()` when its inputs change.
+     */
+    edgeCost?: EdgeCost;
+    /** Moves per cell: 8 (king moves, √2 diagonals; default) or 4 (orthogonal only). */
+    neighbours?: 4 | 8;
+}
+/** The step-cost hook: `(fromIndex, toIndex, grid) => cost ≥ 0`, `Infinity` to block. */
+export type EdgeCost = (fromIndex: number, toIndex: number, grid: NavGrid) => number;
+export interface NavGrid {
+    readonly width: number;
+    readonly height: number;
+    readonly cellSize: number;
+    readonly origin: Readonly<NavPoint>;
+    /** Increments on every `setWalkable`, `setCost` or `touch` that changes the grid. */
+    readonly version: number;
+    /** The step-cost hook given at creation, or undefined. */
+    readonly edgeCost: EdgeCost | undefined;
+    /** Moves per cell, 4 or 8; every query defaults to it. */
+    readonly neighbours: 4 | 8;
+    /** Cell count (`width * height`). */
+    readonly size: number;
+    /**
+     * Cost multiplier per cell, row-major (`y * width + x`); 0 marks an unwalkable cell. Read it
+     * directly in hot loops; write through `setWalkable` and `setCost` so `version` moves.
+     */
+    readonly costs: Float32Array;
+    /** Sets walkability by cell or by row-major index; a cell made walkable gets cost 1. */
+    setWalkable(x: number, y: number, walkable: boolean): void;
+    setWalkable(index: number, walkable: boolean): void;
+    /** Sets the cost multiplier (clamped to ≥ 0) by cell or by index; 0 makes it unwalkable. */
+    setCost(x: number, y: number, cost: number): void;
+    setCost(index: number, cost: number): void;
+    /**
+     * Bumps `version` without changing a cell: for when what `edgeCost` reads has changed, so
+     * cached paths, fields and reaches read as stale.
+     */
+    touch(): void;
+    /** False outside the grid. */
+    isWalkable(x: number, y: number): boolean;
+    /** The cost multiplier, or 0 outside the grid. */
+    costAt(x: number, y: number): number;
+    inBounds(x: number, y: number): boolean;
+    /** Row-major index of a cell (no bounds check). */
+    index(x: number, y: number): number;
+    /** The cell under a world point (clamped into the grid). Returns `out`. */
+    toCell(worldX: number, worldZ: number, out: NavCell): NavCell;
+    /** The world centre of a cell. Returns `out`. */
+    toWorld(cx: number, cy: number, out: NavPoint): NavPoint;
+}
+/** Neighbour offsets shared by every query: the four orthogonal first, then the four diagonal. */
+export declare const NEIGHBOUR_X: readonly [1, -1, 0, 0, 1, 1, -1, -1];
+export declare const NEIGHBOUR_Y: readonly [0, 0, 1, -1, 1, -1, 1, -1];
+/**
+ * The cost of stepping from cell `from` to its neighbour `to` in direction `d` (an index into
+ * `NEIGHBOUR_X`): the step's length (1 or √2) × the destination's cost multiplier, plus the
+ * grid's `edgeCost` if any. `Infinity` when the step is blocked: an unwalkable destination, a
+ * diagonal whose two orthogonal neighbours are not both walkable (no corner cutting), or an
+ * edge the hook blocks. `from` and `to` are row-major indices; `fx`, `fy` are `from`'s cell.
+ */
+export declare function stepCost(grid: NavGrid, from: number, fx: number, fy: number, d: number): number;
+/**
+ * The length of the step from cell `fx, fy` in direction `d`: 1, √2, or `Infinity` when the
+ * destination is outside the grid or unwalkable, or the diagonal would cut a corner.
+ */
+export declare function stepLength(grid: NavGrid, fx: number, fy: number, d: number): number;
+/** The hook's term for the edge `from → to`: 0 without a hook or below zero, `Infinity` to block. */
+export declare function edgeCostOf(grid: NavGrid, from: number, to: number): number;
+/** Builds a grid; every cell walkable at cost 1 unless the callbacks say otherwise. */
+export declare function createNavGrid(opts: NavGridOptions): NavGrid;
+/**
+ * True when a straight segment between the centres of two cells crosses walkable cells only
+ * (a supercover walk: a segment through a corner needs both cells beside the corner walkable,
+ * so it never slips between two diagonal walls). Both endpoints must be walkable.
+ */
+export declare function hasLineOfWalkable(grid: NavGrid, x0: number, y0: number, x1: number, y1: number): boolean;

package/dist/nav/grid.js

@@ -0,0 +1,210 @@
+/**
+ * The navigation grid: a field of cells over the XZ plane, each walkable or not and with a cost
+ * multiplier. The grid is the one thing every query reads; `version` increments on every edit so
+ * a cached path or flow field can tell it is stale. No game nouns: cells, costs, world points.
+ */
+class Grid {
+    width;
+    height;
+    cellSize;
+    origin;
+    size;
+    costs;
+    edgeCost;
+    neighbours;
+    version = 0;
+    constructor(opts) {
+        if (opts.neighbours !== undefined && opts.neighbours !== 4 && opts.neighbours !== 8) {
+            throw new Error('nav: neighbours must be 4 or 8');
+        }
+        this.edgeCost = opts.edgeCost;
+        this.neighbours = opts.neighbours ?? 8;
+        const width = Math.floor(opts.width);
+        const height = Math.floor(opts.height);
+        if (!(width > 0) || !(height > 0))
+            throw new Error('nav: grid width and height must be ≥ 1');
+        if (!(opts.cellSize > 0) || !Number.isFinite(opts.cellSize)) {
+            throw new Error('nav: cellSize must be a positive number');
+        }
+        this.width = width;
+        this.height = height;
+        this.cellSize = opts.cellSize;
+        this.origin = { x: opts.origin?.x ?? 0, z: opts.origin?.z ?? 0 };
+        this.size = width * height;
+        this.costs = new Float32Array(this.size);
+        const walkable = opts.walkable;
+        const cost = opts.cost;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const w = walkable ? walkable(x, y) : true;
+                const c = cost ? clampCost(cost(x, y)) : 1;
+                this.costs[y * width + x] = w ? c : 0;
+            }
+        }
+    }
+    inBounds(x, y) {
+        return x >= 0 && y >= 0 && x < this.width && y < this.height;
+    }
+    index(x, y) {
+        return y * this.width + x;
+    }
+    isWalkable(x, y) {
+        return this.inBounds(x, y) && this.costs[y * this.width + x] > 0;
+    }
+    costAt(x, y) {
+        return this.inBounds(x, y) ? this.costs[y * this.width + x] : 0;
+    }
+    setWalkable(a, b, c) {
+        let i;
+        let walkable;
+        if (c === undefined) {
+            i = a;
+            walkable = b;
+            if (!(i >= 0 && i < this.size))
+                return;
+        }
+        else {
+            if (!this.inBounds(a, b))
+                return;
+            i = b * this.width + a;
+            walkable = c;
+        }
+        const was = this.costs[i] > 0;
+        if (was === walkable)
+            return;
+        this.costs[i] = walkable ? 1 : 0;
+        this.version++;
+    }
+    setCost(a, b, c) {
+        let i;
+        let cost;
+        if (c === undefined) {
+            i = a;
+            cost = b;
+            if (!(i >= 0 && i < this.size))
+                return;
+        }
+        else {
+            if (!this.inBounds(a, b))
+                return;
+            i = b * this.width + a;
+            cost = c;
+        }
+        const v = clampCost(cost);
+        if (this.costs[i] === v)
+            return;
+        this.costs[i] = v;
+        this.version++;
+    }
+    touch() {
+        this.version++;
+    }
+    toCell(worldX, worldZ, out) {
+        const cx = Math.floor((worldX - this.origin.x) / this.cellSize);
+        const cy = Math.floor((worldZ - this.origin.z) / this.cellSize);
+        out.x = cx < 0 ? 0 : cx >= this.width ? this.width - 1 : cx;
+        out.y = cy < 0 ? 0 : cy >= this.height ? this.height - 1 : cy;
+        return out;
+    }
+    toWorld(cx, cy, out) {
+        out.x = this.origin.x + (cx + 0.5) * this.cellSize;
+        out.z = this.origin.z + (cy + 0.5) * this.cellSize;
+        return out;
+    }
+}
+function clampCost(c) {
+    return Number.isFinite(c) && c > 0 ? c : 0;
+}
+/** Neighbour offsets shared by every query: the four orthogonal first, then the four diagonal. */
+export const NEIGHBOUR_X = [1, -1, 0, 0, 1, 1, -1, -1];
+export const NEIGHBOUR_Y = [0, 0, 1, -1, 1, -1, 1, -1];
+/**
+ * The cost of stepping from cell `from` to its neighbour `to` in direction `d` (an index into
+ * `NEIGHBOUR_X`): the step's length (1 or √2) × the destination's cost multiplier, plus the
+ * grid's `edgeCost` if any. `Infinity` when the step is blocked: an unwalkable destination, a
+ * diagonal whose two orthogonal neighbours are not both walkable (no corner cutting), or an
+ * edge the hook blocks. `from` and `to` are row-major indices; `fx`, `fy` are `from`'s cell.
+ */
+export function stepCost(grid, from, fx, fy, d) {
+    const len = stepLength(grid, fx, fy, d);
+    if (len === Infinity)
+        return Infinity;
+    const to = (fy + NEIGHBOUR_Y[d]) * grid.width + fx + NEIGHBOUR_X[d];
+    return len * grid.costs[to] + edgeCostOf(grid, from, to);
+}
+/**
+ * The length of the step from cell `fx, fy` in direction `d`: 1, √2, or `Infinity` when the
+ * destination is outside the grid or unwalkable, or the diagonal would cut a corner.
+ */
+export function stepLength(grid, fx, fy, d) {
+    const width = grid.width;
+    const nx = fx + NEIGHBOUR_X[d];
+    const ny = fy + NEIGHBOUR_Y[d];
+    if (nx < 0 || ny < 0 || nx >= width || ny >= grid.height)
+        return Infinity;
+    const costs = grid.costs;
+    if (costs[ny * width + nx] <= 0)
+        return Infinity;
+    if (d < 4)
+        return 1;
+    if (costs[fy * width + nx] <= 0 || costs[ny * width + fx] <= 0)
+        return Infinity;
+    return Math.SQRT2;
+}
+/** The hook's term for the edge `from → to`: 0 without a hook or below zero, `Infinity` to block. */
+export function edgeCostOf(grid, from, to) {
+    const hook = grid.edgeCost;
+    if (!hook)
+        return 0;
+    const e = hook(from, to, grid);
+    if (e === Infinity || Number.isNaN(e))
+        return Infinity;
+    return Math.max(e, 0);
+}
+/** Builds a grid; every cell walkable at cost 1 unless the callbacks say otherwise. */
+export function createNavGrid(opts) {
+    return new Grid(opts);
+}
+/**
+ * True when a straight segment between the centres of two cells crosses walkable cells only
+ * (a supercover walk: a segment through a corner needs both cells beside the corner walkable,
+ * so it never slips between two diagonal walls). Both endpoints must be walkable.
+ */
+export function hasLineOfWalkable(grid, x0, y0, x1, y1) {
+    if (!grid.isWalkable(x0, y0) || !grid.isWalkable(x1, y1))
+        return false;
+    let x = x0;
+    let y = y0;
+    const dx = Math.abs(x1 - x0);
+    const dy = Math.abs(y1 - y0);
+    const sx = x1 > x0 ? 1 : -1;
+    const sy = y1 > y0 ? 1 : -1;
+    // Integer DDA: the next vertical boundary is crossed at t = (ix + 0.5) / dx, the next
+    // horizontal one at (iy + 0.5) / dy; both scaled by 2·dx·dy so the comparison is exact.
+    let ix = 0;
+    let iy = 0;
+    while (ix < dx || iy < dy) {
+        const tx = (2 * ix + 1) * dy;
+        const ty = (2 * iy + 1) * dx;
+        if (ix < dx && (iy >= dy || tx < ty)) {
+            x += sx;
+            ix++;
+        }
+        else if (iy < dy && (ix >= dx || ty < tx)) {
+            y += sy;
+            iy++;
+        }
+        else {
+            // Exactly through a corner: both cells beside it must be open, then step diagonally.
+            if (!grid.isWalkable(x + sx, y) || !grid.isWalkable(x, y + sy))
+                return false;
+            x += sx;
+            y += sy;
+            ix++;
+            iy++;
+        }
+        if (!grid.isWalkable(x, y))
+            return false;
+    }
+    return true;
+}

package/dist/nav/heap.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A binary min-heap of cell indices keyed by a caller-owned float array, with decrease-key
+ * through a position table. Sized to the grid once; nothing allocates afterwards. Internal to
+ * A*, the flow field and `reachable`.
+ */
+export declare class CellHeap {
+    private readonly items;
+    /** Heap slot of each cell, or -1 when not in the heap. */
+    private readonly where;
+    private readonly key;
+    private count;
+    constructor(cells: number, key: Float64Array | Float32Array);
+    get size(): number;
+    clear(): void;
+    has(cell: number): boolean;
+    /** Inserts `cell`, or moves it up after its key decreased. */
+    pushOrDecrease(cell: number): void;
+    /** Removes and returns the cell with the smallest key (-1 when empty). */
+    pop(): number;
+    private up;
+    private down;
+}

package/dist/nav/heap.js

@@ -0,0 +1,92 @@
+/**
+ * A binary min-heap of cell indices keyed by a caller-owned float array, with decrease-key
+ * through a position table. Sized to the grid once; nothing allocates afterwards. Internal to
+ * A*, the flow field and `reachable`.
+ */
+export class CellHeap {
+    items;
+    /** Heap slot of each cell, or -1 when not in the heap. */
+    where;
+    key;
+    count = 0;
+    constructor(cells, key) {
+        this.items = new Int32Array(cells);
+        this.where = new Int32Array(cells).fill(-1);
+        this.key = key;
+    }
+    get size() {
+        return this.count;
+    }
+    clear() {
+        for (let i = 0; i < this.count; i++)
+            this.where[this.items[i]] = -1;
+        this.count = 0;
+    }
+    has(cell) {
+        return this.where[cell] >= 0;
+    }
+    /** Inserts `cell`, or moves it up after its key decreased. */
+    pushOrDecrease(cell) {
+        let i = this.where[cell];
+        if (i < 0) {
+            i = this.count++;
+            this.items[i] = cell;
+            this.where[cell] = i;
+        }
+        this.up(i);
+    }
+    /** Removes and returns the cell with the smallest key (-1 when empty). */
+    pop() {
+        if (this.count === 0)
+            return -1;
+        const top = this.items[0];
+        this.where[top] = -1;
+        const last = this.items[--this.count];
+        if (this.count > 0) {
+            this.items[0] = last;
+            this.where[last] = 0;
+            this.down(0);
+        }
+        return top;
+    }
+    up(i) {
+        const items = this.items;
+        const key = this.key;
+        const cell = items[i];
+        const k = key[cell];
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            const pc = items[parent];
+            if (key[pc] <= k)
+                break;
+            items[i] = pc;
+            this.where[pc] = i;
+            i = parent;
+        }
+        items[i] = cell;
+        this.where[cell] = i;
+    }
+    down(i) {
+        const items = this.items;
+        const key = this.key;
+        const n = this.count;
+        const cell = items[i];
+        const k = key[cell];
+        for (;;) {
+            let child = i * 2 + 1;
+            if (child >= n)
+                break;
+            const right = child + 1;
+            if (right < n && key[items[right]] < key[items[child]])
+                child = right;
+            const cc = items[child];
+            if (key[cc] >= k)
+                break;
+            items[i] = cc;
+            this.where[cc] = i;
+            i = child;
+        }
+        items[i] = cell;
+        this.where[cell] = i;
+    }
+}

package/dist/nav/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@thunderclap-engine/engine/nav`: grid navigation on the XZ plane. A `NavGrid` of walkable cells with
+ * costs (and an edge-cost hook, 4 or 8 neighbours), A* (`findPath`) and string pulling
+ * (`smoothPath`) into a reusable `NavPath`, a flow field one build serves every agent with,
+ * budget-bounded reachability with parents (`reachable`, on a grid or a `NavMesh`, with
+ * `reachableOutline` for a mesh range's boundary), a path follower and local steering.
+ * Pure CPU, no imports from other engine modules, no allocation per query after warm-up.
+ */
+export type { FindPathOptions } from './astar.js';
+export { findPath } from './astar.js';
+export { type Corridor, createCorridor } from './corridor.js';
+export type { Crowd, CrowdAgent, CrowdAgentOptions, CrowdAttachOptions, CrowdOptions, } from './crowd.js';
+export { createCrowd } from './crowd.js';
+export type { FlowDirection, FlowField, FlowFieldOptions } from './flow.js';
+export { createFlowField } from './flow.js';
+export type { EdgeCost, NavCell, NavGrid, NavGridOptions, NavPoint } from './grid.js';
+export { createNavGrid } from './grid.js';
+export { type AreaBox, type AreaPolygon, type AreaShape, type AreaStamp, areaShapeContains, createAreaCosts, createAreaMask, markArea, OBSTACLE_AREA, } from './mesh/areas.js';
+export { NAV_BAKE_DEFAULTS, NavBakeError, type ResolvedNavBakeOptions, resolveNavBakeOptions, } from './mesh/bake-options.js';
+export { createFlowField3, type FlowField3, type FlowField3Options } from './mesh/flow3.js';
+export type { OffMeshLink, OffMeshLinkOptions } from './mesh/links.js';
+export { addOffMeshLink, getOffMeshLink, removeOffMeshLink } from './mesh/links.js';
+export type { FindMeshPathOptions, NavPath3, NavPathLink } from './mesh/mesh-path.js';
+export { type AreaQueryOptions, areaAllowed, clearPath3, createNavPath3, findMeshPath, followPath3, MeshSearch, type MeshSearchState, pathDistance3, pathPoint3, pullString, reservePath3, reservePolys3, } from './mesh/mesh-path.js';
+export { createMeshReach, createReachOutline, type MeshReach, type MeshReachOptions, type ReachOutline, reachableOutline, } from './mesh/mesh-reach.js';
+export type { NavBakeAreaOptions, NavBounds, NavPoint3 } from './mesh/navmesh.js';
+export { bakeNavMesh, NavMesh } from './mesh/navmesh.js';
+export { exportNavMesh, importNavMesh, loadNavMesh } from './mesh/serialize.js';
+export type { NavBakeOptions, NavBakeSource } from './mesh/voxelize.js';
+export { createObstacleSet, type Obstacle, type ObstacleBox, type ObstacleDisc, type ObstacleSet, type ObstacleSetOptions, type ObstacleShape, } from './obstacles.js';
+export type { FollowResult, LineOfWalkableOptions, NavPath } from './path.js';
+export { clearPath, createNavPath, followPath, hasLineOfWalkable, pathDistance, pathPoint, reservePath, smoothPath, } from './path.js';
+export { createPathQueue, type PathQueue, type PathQueueOptions, type PathRequestOptions, type PathStatus, } from './query-queue.js';
+export type { Reach } from './reach.js';
+export { createReach, reachable } from './reach.js';
+export type { Disc } from './steer.js';
+export { arrive, avoidDisc, separate, steer } from './steer.js';

package/dist/nav/index.js

@@ -0,0 +1,19 @@
+export { findPath } from './astar.js';
+export { createCorridor } from './corridor.js';
+export { createCrowd } from './crowd.js';
+export { createFlowField } from './flow.js';
+export { createNavGrid } from './grid.js';
+// ws/nav-4: areas, obstacles, queue, corridors, mesh flow field.
+export { areaShapeContains, createAreaCosts, createAreaMask, markArea, OBSTACLE_AREA, } from './mesh/areas.js';
+export { NAV_BAKE_DEFAULTS, NavBakeError, resolveNavBakeOptions, } from './mesh/bake-options.js';
+export { createFlowField3 } from './mesh/flow3.js';
+export { addOffMeshLink, getOffMeshLink, removeOffMeshLink } from './mesh/links.js';
+export { areaAllowed, clearPath3, createNavPath3, findMeshPath, followPath3, MeshSearch, pathDistance3, pathPoint3, pullString, reservePath3, reservePolys3, } from './mesh/mesh-path.js';
+export { createMeshReach, createReachOutline, reachableOutline, } from './mesh/mesh-reach.js';
+export { bakeNavMesh, NavMesh } from './mesh/navmesh.js';
+export { exportNavMesh, importNavMesh, loadNavMesh } from './mesh/serialize.js';
+export { createObstacleSet, } from './obstacles.js';
+export { clearPath, createNavPath, followPath, hasLineOfWalkable, pathDistance, pathPoint, reservePath, smoothPath, } from './path.js';
+export { createPathQueue, } from './query-queue.js';
+export { createReach, reachable } from './reach.js';
+export { arrive, avoidDisc, separate, steer } from './steer.js';