@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/nav/mesh/mesh-reach.d.ts

@@ -0,0 +1,78 @@
+import { type NavPath3 } from './mesh-path.js';
+import type { NavMesh, NavPoint3 } from './navmesh.js';
+export interface MeshReachOptions {
+    /** Path cost a polygon may cost to reach, inclusive (world units × area cost). */
+    budget: number;
+    /** A cost multiplier per area byte (256 entries, `createAreaCosts`); `Infinity` excludes an area. */
+    areaCost?: Float32Array;
+    /** Per area byte (256 entries, `createAreaMask`): 0 excludes the area. */
+    areaMask?: Uint8Array;
+    /** Stop once this many polygons are in (the start counts). Default: no cap. */
+    maxPolys?: number;
+    /** How far `from` may be from the mesh to snap onto it. Default: any distance. */
+    snapRadius?: number;
+}
+export interface MeshReach {
+    readonly mesh: NavMesh;
+    /** Polygons reached (the start included); 0 when `from` is off the mesh. */
+    readonly count: number;
+    /** The reached polygons in the order they came within budget, the start first; `count` valid. */
+    readonly polys: Int32Array;
+    /**
+     * Cost to reach each polygon's centre (`polyCenter`), the value `findMeshPath(mesh, from,
+     * centre).cost` gives; 0 at the start polygon, `Infinity` off the reach. One per polygon.
+     */
+    readonly costs: Float32Array;
+    /** The polygon each reached polygon is entered from on its cheapest route; -1 at the start or off the reach. */
+    readonly parents: Int32Array;
+    /** The polygon `from` snapped to, or -1. */
+    readonly startPoly: number;
+    /** Where `from` snapped to on the mesh. */
+    readonly start: Readonly<NavPoint3>;
+    /** The budget of the last query. */
+    readonly budget: number;
+    /** `mesh.version` at the last query, or -1 before the first. */
+    readonly version: number;
+    /** True when the mesh changed (a link, an area, an obstacle) since the last query. */
+    readonly stale: boolean;
+    /** True when polygon `p` was reached within the budget. */
+    has(p: number): boolean;
+    /**
+     * The route from the start to polygon `p`'s centre into `out`: the corridor in `out.polys`,
+     * the pulled string in `out.points`, `out.cost` the reach's cost. False, with `out` empty,
+     * when `p` is not reached.
+     */
+    pathTo(p: number, out: NavPath3): boolean;
+    /** Calls `fn` for every reached polygon, in `polys` order. */
+    forEach(fn: (poly: number, cost: number) => void): void;
+}
+/** A reusable mesh reachability result sized to `mesh`; pass it to `reachable` as `out`. */
+export declare function createMeshReach(mesh: NavMesh): MeshReach;
+/**
+ * The polygons whose centre is within path cost `opts.budget` of `from`, with their cost to
+ * reach. Legs are priced as `findMeshPath` prices them; the search expands only polygons it can
+ * enter within the budget and stops there (or at `maxPolys`). Writes into `out`, or a `MeshReach`
+ * kept per mesh; nothing allocates after the first query on a mesh.
+ */
+export declare function reachableMesh(mesh: NavMesh, from: Readonly<NavPoint3>, opts: MeshReachOptions, out?: MeshReach): MeshReach;
+export interface ReachOutline {
+    /** Loop vertices as world `x, y, z` triples; `pointCount` are valid. Grows in place. */
+    points: Float32Array;
+    pointCount: number;
+    /**
+     * Loop `k` is points `loopStart[k]` to `loopStart[k + 1] - 1` (closed: the last joins the
+     * first); `loopCount + 1` entries are valid. Outer loops run counter-clockwise seen from above,
+     * holes clockwise.
+     */
+    loopStart: Int32Array;
+    loopCount: number;
+}
+/** An empty outline (buffers grow on demand); pass it to `reachableOutline` as `out`. */
+export declare function createReachOutline(capacity?: number): ReachOutline;
+/**
+ * The boundary of a reach as closed loops of mesh vertices: every edge of a reached polygon whose
+ * other side is off the mesh or not reached, chained end to end. Writes into `out`, or one
+ * outline kept per reach; nothing allocates once the buffers have grown to the largest outline.
+ * The boundary follows polygon edges, so its resolution is the mesh's.
+ */
+export declare function reachableOutline(reach: MeshReach, out?: ReachOutline): ReachOutline;

package/dist/nav/mesh/mesh-reach.js

@@ -0,0 +1,450 @@
+/**
+ * Budget-bounded reachability on a `NavMesh` (ws/nav-5): "where can this unit get to with N
+ * metres of movement", cheap enough to ask every frame. A Dijkstra over the polygon graph that
+ * prices legs exactly as `findMeshPath` does (portal midpoints as nodes, each leg × the area cost
+ * of the polygon it crosses, off-mesh links at their cost) and stops at the budget, then
+ * `reachableOutline` traces the reached set's boundary into loops for drawing a movement range.
+ * Scratch is sized to the mesh once (per mesh, in a `WeakMap`) and reused: no allocation per
+ * query after the first.
+ */
+import { CellHeap } from '../heap.js';
+import { OBSTACLE_AREA } from './areas.js';
+import { areaAllowed, pullString, reservePolys3 } from './mesh-path.js';
+/** Per-mesh Dijkstra scratch, shared by every `MeshReach` of the mesh. */
+class ReachScratch {
+    g;
+    px;
+    py;
+    pz;
+    /** Polygon centres, `x, y, z` per polygon (computed once). */
+    centres;
+    /** Edge midpoints, `x, y, z` per polygon edge slot (`p * nvp + e`; computed once). */
+    mids;
+    /** The node parent (entry) chain, for `pathTo`. */
+    nodeParent;
+    seen;
+    closed;
+    heap;
+    corridor;
+    stamp = 0;
+    constructor(mesh) {
+        const n = Math.max(1, mesh.polyCount);
+        this.g = new Float64Array(n);
+        this.px = new Float64Array(n);
+        this.py = new Float64Array(n);
+        this.pz = new Float64Array(n);
+        this.centres = new Float64Array(n * 3);
+        const c = { x: 0, y: 0, z: 0 };
+        for (let p = 0; p < mesh.polyCount; p++) {
+            mesh.polyCenter(p, c);
+            this.centres[p * 3] = c.x;
+            this.centres[p * 3 + 1] = c.y;
+            this.centres[p * 3 + 2] = c.z;
+        }
+        const nvp = mesh.maxVertsPerPoly;
+        this.mids = new Float64Array(n * nvp * 3);
+        for (let p = 0; p < mesh.polyCount; p++) {
+            const k = mesh.polyVertexCount(p);
+            for (let e = 0; e < k; e++) {
+                const a = mesh.polys[p * nvp + e] * 3;
+                const b = mesh.polys[p * nvp + (e + 1 === k ? 0 : e + 1)] * 3;
+                const m = (p * nvp + e) * 3;
+                this.mids[m] = (mesh.verts[a] + mesh.verts[b]) * 0.5;
+                this.mids[m + 1] = (mesh.verts[a + 1] + mesh.verts[b + 1]) * 0.5;
+                this.mids[m + 2] = (mesh.verts[a + 2] + mesh.verts[b + 2]) * 0.5;
+            }
+        }
+        this.nodeParent = new Int32Array(n).fill(-1);
+        this.seen = new Uint32Array(n);
+        this.closed = new Uint32Array(n);
+        this.heap = new CellHeap(n, this.g);
+        this.corridor = new Int32Array(n + 1);
+    }
+    next() {
+        this.stamp = (this.stamp + 1) >>> 0;
+        if (this.stamp === 0) {
+            this.seen.fill(0);
+            this.closed.fill(0);
+            this.stamp = 1;
+        }
+        this.heap.clear();
+        return this.stamp;
+    }
+}
+const scratchFor = new WeakMap();
+function scratchOf(mesh) {
+    let s = scratchFor.get(mesh);
+    if (!s) {
+        s = new ReachScratch(mesh);
+        scratchFor.set(mesh, s);
+    }
+    return s;
+}
+const pathCentre = { x: 0, y: 0, z: 0 };
+class MeshReachImpl {
+    mesh;
+    polys;
+    costs;
+    parents;
+    start = { x: 0, y: 0, z: 0 };
+    count = 0;
+    startPoly = -1;
+    budget = 0;
+    version = -1;
+    constructor(mesh) {
+        this.mesh = mesh;
+        const n = Math.max(1, mesh.polyCount);
+        this.polys = new Int32Array(n);
+        this.costs = new Float32Array(n).fill(Infinity);
+        this.parents = new Int32Array(n).fill(-1);
+    }
+    get stale() {
+        return this.version !== this.mesh.version;
+    }
+    has(p) {
+        return p >= 0 && p < this.mesh.polyCount && this.costs[p] < Infinity;
+    }
+    pathTo(p, out) {
+        const mesh = this.mesh;
+        if (!this.has(p)) {
+            out.length = 0;
+            out.cursor = 0;
+            out.linkCount = 0;
+            out.polyCount = 0;
+            out.cost = 0;
+            out.version = this.version;
+            return false;
+        }
+        const s = scratchOf(mesh);
+        const corridor = s.corridor;
+        // The centre's parent, then the node chain back to the start.
+        let len = 0;
+        corridor[len++] = p;
+        for (let q = this.parents[p]; q >= 0; q = s.nodeParent[q])
+            corridor[len++] = q;
+        for (let i = 0, j = len - 1; i < j; i++, j--) {
+            const t = corridor[i];
+            corridor[i] = corridor[j];
+            corridor[j] = t;
+        }
+        pathCentre.x = s.centres[p * 3];
+        pathCentre.y = s.centres[p * 3 + 1];
+        pathCentre.z = s.centres[p * 3 + 2];
+        pullString(mesh, corridor, 0, len, this.start, pathCentre, out);
+        reservePolys3(out, len);
+        out.polys.set(corridor.subarray(0, len));
+        out.polyCount = len;
+        out.cost = this.costs[p];
+        out.version = this.version;
+        return true;
+    }
+    forEach(fn) {
+        for (let i = 0; i < this.count; i++) {
+            const p = this.polys[i];
+            fn(p, this.costs[p]);
+        }
+    }
+    reset() {
+        for (let i = 0; i < this.count; i++) {
+            const p = this.polys[i];
+            this.costs[p] = Infinity;
+            this.parents[p] = -1;
+        }
+        this.count = 0;
+        this.startPoly = -1;
+    }
+    add(p, cost, parent) {
+        if (this.costs[p] === Infinity)
+            this.polys[this.count++] = p;
+        this.costs[p] = cost;
+        this.parents[p] = parent;
+    }
+}
+/** A reusable mesh reachability result sized to `mesh`; pass it to `reachable` as `out`. */
+export function createMeshReach(mesh) {
+    return new MeshReachImpl(mesh);
+}
+const reachFor = new WeakMap();
+/**
+ * `findNearestPoly`, but an unbounded snap first looks near the point: the nearest polygon within
+ * a radius is the nearest overall, and the whole-mesh scan costs more than the search itself on a
+ * large mesh.
+ */
+function snap(mesh, from, out, radius) {
+    if (radius === Number.POSITIVE_INFINITY) {
+        const near = mesh.findNearestPoly(from.x, from.y, from.z, out, mesh.cellSize * 8);
+        if (near >= 0)
+            return near;
+    }
+    return mesh.findNearestPoly(from.x, from.y, from.z, out, radius);
+}
+function dist3(ax, ay, az, bx, by, bz) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    const dz = bz - az;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+/**
+ * The polygons whose centre is within path cost `opts.budget` of `from`, with their cost to
+ * reach. Legs are priced as `findMeshPath` prices them; the search expands only polygons it can
+ * enter within the budget and stops there (or at `maxPolys`). Writes into `out`, or a `MeshReach`
+ * kept per mesh; nothing allocates after the first query on a mesh.
+ */
+export function reachableMesh(mesh, from, opts, out) {
+    let r;
+    if (out) {
+        if (out.mesh !== mesh)
+            throw new Error('nav: reach belongs to another mesh');
+        r = out;
+    }
+    else {
+        const cached = reachFor.get(mesh);
+        if (cached) {
+            r = cached;
+        }
+        else {
+            r = new MeshReachImpl(mesh);
+            reachFor.set(mesh, r);
+        }
+    }
+    r.reset();
+    const budget = opts.budget;
+    r.budget = budget;
+    r.version = mesh.version;
+    if (mesh.polyCount === 0 || !(budget >= 0))
+        return r;
+    const startPoly = snap(mesh, from, r.start, opts.snapRadius ?? Number.POSITIVE_INFINITY);
+    if (startPoly < 0)
+        return r;
+    const areaCost = opts.areaCost;
+    const areaMask = opts.areaMask;
+    const maxPolys = opts.maxPolys ?? Number.POSITIVE_INFINITY;
+    const s = scratchOf(mesh);
+    const stamp = s.next();
+    const { g, px, py, pz, centres, nodeParent, seen, closed, heap } = s;
+    const costs = r.costs;
+    const nvp = mesh.maxVertsPerPoly;
+    const adjacency = mesh.adjacency;
+    const area = mesh.area;
+    const mids = s.mids;
+    const plain = areaCost === undefined && areaMask === undefined;
+    r.startPoly = startPoly;
+    r.add(startPoly, 0, -1);
+    g[startPoly] = 0;
+    px[startPoly] = r.start.x;
+    py[startPoly] = r.start.y;
+    pz[startPoly] = r.start.z;
+    nodeParent[startPoly] = -1;
+    seen[startPoly] = stamp;
+    heap.pushOrDecrease(startPoly);
+    while (heap.size > 0 && r.count < maxPolys) {
+        const cur = heap.pop();
+        closed[cur] = stamp;
+        const cx = px[cur];
+        const cy = py[cur];
+        const cz = pz[cur];
+        const gc = g[cur];
+        // As in `findMeshPath`: the polygon a leg crosses prices it.
+        const mul = areaCost === undefined ? 1 : areaCost[area[cur]];
+        const n = mesh.polyVertexCount(cur);
+        for (let e = 0; e < n; e++) {
+            const next = adjacency[cur * nvp + e];
+            if (next < 0)
+                continue;
+            if (plain ? area[next] === OBSTACLE_AREA : !areaAllowed(area[next], areaCost, areaMask))
+                continue;
+            // The centre: what a search with the centre as its goal would charge. A closed polygon
+            // still takes a cheaper centre (a goal polygon is never expanded through).
+            const nc = gc +
+                dist3(cx, cy, cz, centres[next * 3], centres[next * 3 + 1], centres[next * 3 + 2]) * mul;
+            if (nc <= budget && nc < costs[next] && r.count < maxPolys)
+                r.add(next, nc, cur);
+            if (closed[next] === stamp)
+                continue;
+            const m = (cur * nvp + e) * 3;
+            const nx = mids[m];
+            const ny = mids[m + 1];
+            const nz = mids[m + 2];
+            const ng = gc + dist3(cx, cy, cz, nx, ny, nz) * mul;
+            if (ng > budget)
+                continue;
+            if (seen[next] === stamp && ng >= g[next])
+                continue;
+            seen[next] = stamp;
+            g[next] = ng;
+            px[next] = nx;
+            py[next] = ny;
+            pz[next] = nz;
+            nodeParent[next] = cur;
+            heap.pushOrDecrease(next);
+        }
+        const lend = mesh.linkStart[cur + 1];
+        for (let li = mesh.linkStart[cur]; li < lend; li++) {
+            const rec = mesh.linkItems[li];
+            const link = mesh.links[rec >> 1];
+            if (!link)
+                continue;
+            const end = rec & 1;
+            const src = end === 0 ? link.from : link.to;
+            const dst = end === 0 ? link.to : link.from;
+            const next = end === 0 ? link.toPoly : link.fromPoly;
+            if (next < 0)
+                continue;
+            const na = area[next];
+            if (!areaAllowed(na, areaCost, areaMask))
+                continue;
+            const linkCost = link.cost ?? dist3(src.x, src.y, src.z, dst.x, dst.y, dst.z);
+            const ng = gc + dist3(cx, cy, cz, src.x, src.y, src.z) * mul + linkCost;
+            if (ng > budget)
+                continue;
+            // From the landing to the centre, priced by the polygon landed in.
+            const nmul = areaCost === undefined ? 1 : areaCost[na];
+            const nc = ng +
+                dist3(dst.x, dst.y, dst.z, centres[next * 3], centres[next * 3 + 1], centres[next * 3 + 2]) *
+                    nmul;
+            if (nc <= budget && nc < costs[next] && r.count < maxPolys)
+                r.add(next, nc, cur);
+            if (closed[next] === stamp)
+                continue;
+            if (seen[next] === stamp && ng >= g[next])
+                continue;
+            seen[next] = stamp;
+            g[next] = ng;
+            px[next] = dst.x;
+            py[next] = dst.y;
+            pz[next] = dst.z;
+            nodeParent[next] = cur;
+            heap.pushOrDecrease(next);
+        }
+    }
+    return r;
+}
+/** An empty outline (buffers grow on demand); pass it to `reachableOutline` as `out`. */
+export function createReachOutline(capacity = 64) {
+    return {
+        points: new Float32Array(Math.max(1, capacity) * 3),
+        pointCount: 0,
+        loopStart: new Int32Array(8),
+        loopCount: 0,
+    };
+}
+/** Per-mesh outline scratch: boundary edges and a per-vertex list of the edges leaving it. */
+class OutlineScratch {
+    edgeA;
+    edgeB;
+    edgeNext;
+    used;
+    head;
+    headStamp;
+    stamp = 0;
+    constructor(mesh) {
+        const edges = Math.max(1, mesh.polyCount * mesh.maxVertsPerPoly);
+        this.edgeA = new Int32Array(edges);
+        this.edgeB = new Int32Array(edges);
+        this.edgeNext = new Int32Array(edges);
+        this.used = new Uint8Array(edges);
+        this.head = new Int32Array(Math.max(1, mesh.vertCount));
+        this.headStamp = new Uint32Array(Math.max(1, mesh.vertCount));
+    }
+}
+const outlineScratchFor = new WeakMap();
+const outlineFor = new WeakMap();
+function pushOutlinePoint(out, verts, v) {
+    const need = (out.pointCount + 1) * 3;
+    if (out.points.length < need) {
+        const next = new Float32Array(Math.max(need, Math.ceil(out.points.length * 1.5)));
+        next.set(out.points);
+        out.points = next;
+    }
+    const i = out.pointCount++ * 3;
+    out.points[i] = verts[v * 3];
+    out.points[i + 1] = verts[v * 3 + 1];
+    out.points[i + 2] = verts[v * 3 + 2];
+}
+function pushLoopStart(out, at) {
+    if (out.loopStart.length < out.loopCount + 2) {
+        const next = new Int32Array(Math.max(out.loopCount + 2, out.loopStart.length * 2));
+        next.set(out.loopStart);
+        out.loopStart = next;
+    }
+    out.loopStart[out.loopCount] = at;
+}
+/**
+ * The boundary of a reach as closed loops of mesh vertices: every edge of a reached polygon whose
+ * other side is off the mesh or not reached, chained end to end. Writes into `out`, or one
+ * outline kept per reach; nothing allocates once the buffers have grown to the largest outline.
+ * The boundary follows polygon edges, so its resolution is the mesh's.
+ */
+export function reachableOutline(reach, out) {
+    let o = out;
+    if (!o) {
+        o = outlineFor.get(reach);
+        if (!o) {
+            o = createReachOutline();
+            outlineFor.set(reach, o);
+        }
+    }
+    o.pointCount = 0;
+    o.loopCount = 0;
+    o.loopStart[0] = 0;
+    const mesh = reach.mesh;
+    if (reach.count === 0)
+        return o;
+    let s = outlineScratchFor.get(mesh);
+    if (!s) {
+        s = new OutlineScratch(mesh);
+        outlineScratchFor.set(mesh, s);
+    }
+    s.stamp = (s.stamp + 1) >>> 0;
+    if (s.stamp === 0) {
+        s.headStamp.fill(0);
+        s.stamp = 1;
+    }
+    const stamp = s.stamp;
+    const { edgeA, edgeB, edgeNext, used, head, headStamp } = s;
+    const nvp = mesh.maxVertsPerPoly;
+    const polys = mesh.polys;
+    const adjacency = mesh.adjacency;
+    const costs = reach.costs;
+    let edges = 0;
+    for (let i = 0; i < reach.count; i++) {
+        const p = reach.polys[i];
+        const n = mesh.polyVertexCount(p);
+        for (let e = 0; e < n; e++) {
+            const other = adjacency[p * nvp + e];
+            if (other >= 0 && costs[other] < Infinity)
+                continue;
+            const a = polys[p * nvp + e];
+            edgeA[edges] = a;
+            edgeB[edges] = polys[p * nvp + (e + 1 === n ? 0 : e + 1)];
+            used[edges] = 0;
+            edgeNext[edges] = headStamp[a] === stamp ? head[a] : -1;
+            head[a] = edges;
+            headStamp[a] = stamp;
+            edges++;
+        }
+    }
+    const verts = mesh.verts;
+    for (let first = 0; first < edges; first++) {
+        if (used[first])
+            continue;
+        used[first] = 1;
+        pushLoopStart(o, o.pointCount);
+        const origin = edgeA[first];
+        pushOutlinePoint(o, verts, origin);
+        let v = edgeB[first];
+        while (v !== origin) {
+            let e = headStamp[v] === stamp ? head[v] : -1;
+            while (e >= 0 && used[e])
+                e = edgeNext[e];
+            if (e < 0)
+                break; // an open chain (a mesh with unmatched shared edges); keep what we have
+            used[e] = 1;
+            pushOutlinePoint(o, verts, v);
+            v = edgeB[e];
+        }
+        o.loopCount++;
+    }
+    pushLoopStart(o, o.pointCount);
+    return o;
+}

package/dist/nav/mesh/navmesh.d.ts

@@ -0,0 +1,117 @@
+/**
+ * `NavMesh`: convex walkable polygons with shared edges, baked from triangle soup by
+ * `bakeNavMesh`. Queries (nearest polygon, random point, raycast, height) allocate nothing after
+ * construction and write into an `out`. Polygons are wound counter-clockwise seen from above
+ * (`area2 > 0`), so for edge `e` the right portal vertex is `v[e]` and the left is `v[e + 1]`.
+ */
+import { type AreaStamp } from './areas.js';
+import type { OffMeshLink } from './links.js';
+import { type NavBakeOptions, type NavBakeSource } from './voxelize.js';
+export interface NavPoint3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface NavBounds {
+    min: NavPoint3;
+    max: NavPoint3;
+}
+/** Twice the signed XZ area of `a, b, c`; positive is counter-clockwise seen from above. */
+export declare function area2(ax: number, az: number, bx: number, bz: number, cx: number, cz: number): number;
+export declare class NavMesh {
+    /** World `x, y, z` per vertex. */
+    readonly verts: Float32Array;
+    readonly vertCount: number;
+    /** `maxVertsPerPoly` vertex indices per polygon, -1 padded. */
+    readonly polys: Int32Array;
+    /** Per polygon edge `e` (from vertex `e` to `e + 1`): the polygon across it, or -1. */
+    readonly adjacency: Int32Array;
+    readonly polyCount: number;
+    readonly maxVertsPerPoly: number;
+    readonly bounds: NavBounds;
+    /** The bake's cell size and height, kept for serialisation and for defaults in queries. */
+    readonly cellSize: number;
+    readonly cellHeight: number;
+    /** The area byte per polygon (0 default; `markArea` stamps, 255 is reserved for obstacles). */
+    readonly area: Uint8Array;
+    /** Bumps whenever the mesh changes (links added or removed, areas stamped, obstacles applied). */
+    version: number;
+    /** The polygons the last `polysInBox` found (its return value says how many). */
+    readonly polysFound: Int32Array;
+    private readonly foundStamp;
+    private findStamp;
+    /** Off-mesh links by index (holes stay `null` after removal); edit with `addOffMeshLink`. */
+    readonly links: (OffMeshLink | null)[];
+    /** CSR of link ends per polygon: `linkItems[linkStart[p] .. linkStart[p + 1])` are `link * 2 + end`. */
+    linkStart: Int32Array;
+    linkItems: Int32Array;
+    nextLinkId: number;
+    /** Vertices per polygon (3..`maxVertsPerPoly`). */
+    private readonly nverts;
+    /** Per polygon XZ AABB, `minX, minZ, maxX, maxZ`. */
+    private readonly polyBox;
+    /** Cumulative polygon areas for `findRandomPoint`. */
+    private readonly cumArea;
+    private readonly gridW;
+    private readonly gridH;
+    private readonly gridCell;
+    private readonly gridStart;
+    private readonly gridItems;
+    private readonly triArea;
+    constructor(verts: Float32Array, vertCount: number, polys: Int32Array, polyCount: number, maxVertsPerPoly: number, cellSize: number, cellHeight: number, adjacency?: Int32Array, area?: Uint8Array);
+    private gx;
+    private gz;
+    /**
+     * Collects every polygon whose XZ bounding box overlaps the box into `polysFound` (each
+     * once) and returns how many. Allocation-free; the next call overwrites the list.
+     */
+    polysInBox(minX: number, minZ: number, maxX: number, maxZ: number): number;
+    /** Reverses any clockwise polygon so every polygon is counter-clockwise seen from above. */
+    private normaliseWinding;
+    /** Vertices in polygon `p`. */
+    polyVertexCount(p: number): number;
+    /** World position of vertex `k` of polygon `p`, into `out`. */
+    polyVertex(p: number, k: number, out: NavPoint3): NavPoint3;
+    /** The polygon's vertex centroid, into `out`. */
+    polyCenter(p: number, out: NavPoint3): NavPoint3;
+    /** The polygon's XZ area. */
+    polyArea(p: number): number;
+    /** Whether `(x, z)` projects inside polygon `p` (edges included). */
+    containsXZ(p: number, x: number, z: number): boolean;
+    /** The surface height of polygon `p` at `(x, z)`, by its triangle fan (extrapolated outside). */
+    polyHeight(p: number, x: number, z: number): number;
+    /**
+     * The polygon under or nearest to `(x, y, z)` within `radius`, or -1; the nearest point on it is
+     * written to `out` (left untouched when none).
+     */
+    findNearestPoly(x: number, y: number, z: number, out: NavPoint3, radius?: number): number;
+    /** The point of polygon `p` nearest `(x, y, z)` into `out`; returns the squared distance. */
+    closestPointOnPoly(p: number, x: number, y: number, z: number, out: NavPoint3): number;
+    /** The polygon whose XZ footprint holds `(x, z)`, nearest in height to `y`; -1 when none. */
+    findPolyAt(x: number, y: number, z: number): number;
+    /** The surface height at `(x, z)`: of `poly` when given, else of the polygon under it; NaN off the mesh. */
+    height(x: number, z: number, poly?: number): number;
+    /** A uniformly random point on the mesh into `out`; returns its polygon (-1 on an empty mesh). */
+    findRandomPoint(out: NavPoint3, rng?: () => number): number;
+    /**
+     * Walks the segment `from → to` across polygon edges. Returns `true` when a boundary edge
+     * stops it, with the hit point in `out`; otherwise `false` with `to` in `out`. A start off the
+     * mesh hits at once. `startPoly` skips the lookup of the polygon under `from`.
+     */
+    raycast(from: NavPoint3, to: NavPoint3, out: NavPoint3, startPoly?: number): boolean;
+}
+/** Pairs polygons across shared edges (both directions) into a fresh adjacency array. */
+export declare function buildAdjacency(polys: Int32Array, polyCount: number, nvp: number, nverts: Uint8Array, vertCount: number): Int32Array;
+export interface NavBakeAreaOptions {
+    /** Area stamps applied to the baked polygons (`markArea` for each, in order). Optional. */
+    areas?: AreaStamp[];
+}
+/**
+ * Bakes a navmesh from triangle soup: voxelise, filter by height, climb and slope, erode by the
+ * agent radius, partition into regions, trace and simplify contours, triangulate and merge into
+ * convex polygons, then stamp `opts.areas` (if any). Bake-time only; allocates freely. Options
+ * left out take the `resolveNavBakeOptions` defaults; a bad one throws a `NavBakeError`. An input
+ * with no triangles gives an empty mesh; one whose triangles yield no polygon gives an empty mesh
+ * and one `console.warn`.
+ */
+export declare function bakeNavMesh(input: NavBakeSource | NavBakeSource[], options: NavBakeOptions & NavBakeAreaOptions): NavMesh;