@aethervtt/shard-nav 0.0.1

package/dist/query.js

@@ -0,0 +1,391 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { GlobalTransform } from "@aethervtt/shard-transform";
+import { NavAgent } from "./components.js";
+import { nearestWalkable, smoothGridPath, traceSegment } from "./grid.js";
+import { navState } from "./state.js";
+const PATH_STATUSES = ["complete", "partial", "none"];
+function createNavPath(capacity = 256) {
+  return { corners: new Float32Array(capacity * 3), count: 0, length: 0, status: "none", nav: null };
+}
+const SNAP_CELLS = 8;
+function inGrid(g, x, y) {
+  if (!g.grid) return false;
+  const cx = (x - g.ox) / g.csx;
+  const cy = (y - g.oy) / g.csy;
+  return cx >= 0 && cy >= 0 && cx < g.grid.width && cy < g.grid.height;
+}
+function inMesh(m, x, y, z) {
+  const pad = m.settings.agentRadius + m.settings.cellSize * 2;
+  return x >= m.min[0] - pad && x <= m.max[0] + pad && z >= m.min[2] - pad && z <= m.max[2] + pad && y >= m.min[1] - m.settings.agentHeight && y <= m.max[1] + m.settings.agentHeight;
+}
+let foundGrid = null;
+let foundMesh = null;
+const inFrame = new Float64Array(3);
+function locate(state, point, nav) {
+  foundGrid = null;
+  foundMesh = null;
+  if (nav !== null) {
+    foundGrid = state.grids.get(nav) ?? null;
+    if (foundGrid && !foundGrid.grid) foundGrid = null;
+    if (!foundGrid) foundMesh = state.meshes.get(nav) ?? null;
+    return foundGrid !== null || foundMesh !== null;
+  }
+  const x = point[0];
+  const y = point[1];
+  const z = point[2] ?? 0;
+  for (let i = 0; i < state.gridList.length; i++) {
+    const g = state.gridList[i];
+    if (inGrid(g, x, y)) {
+      foundGrid = g;
+      return true;
+    }
+  }
+  for (let i = 0; i < state.meshList.length; i++) {
+    const m = state.meshList[i];
+    if (m.frame !== null) {
+      m.pointIn(x, y, z, inFrame);
+      if (inMesh(m, inFrame[0], inFrame[1], inFrame[2])) {
+        foundMesh = m;
+        return true;
+      }
+    } else if (inMesh(m, x, y, z)) {
+      foundMesh = m;
+      return true;
+    }
+  }
+  return false;
+}
+function navAt(world, point, nav = null) {
+  if (!locate(navState(world), point, nav)) return void 0;
+  if (foundGrid) return { kind: "grid", entity: foundGrid.entity, grid: foundGrid };
+  return { kind: "mesh", entity: foundMesh.entity, mesh: foundMesh };
+}
+function requireNav(world, point, nav) {
+  const state = navState(world);
+  if (locate(state, point, nav)) return;
+  if (nav !== null) {
+    throw new ShardError("nav/no-navmesh", `Entity ${nav} has no built NavGrid or NavMesh`, {
+      hint: "Check nav.describe: the grid may be waiting for data, or the navmesh for sources."
+    });
+  }
+  if (state.grids.size === 0 && state.meshes.size === 0) {
+    throw new ShardError("nav/no-navmesh", "There is no NavGrid or NavMesh to query", {
+      hint: "Add a nav/NavGrid (2D) or a nav/NavMesh and tag level geometry with nav/NavSource."
+    });
+  }
+  const p = [point[0], point[1], point[2] ?? 0].map((v) => Math.round((v ?? 0) * 100) / 100);
+  throw new ShardError(
+    "nav/out-of-bounds",
+    `(${p.join(", ")}) is outside every NavGrid and NavMesh`,
+    { hint: "nav.describe lists each grid and navmesh with its bounds." }
+  );
+}
+const ends = new Float64Array(4);
+let cellScratch = new Float32Array(2 * 256);
+function findPath(world, from, to, options = {}) {
+  const out = options.out ?? createNavPath();
+  let navEntity = options.nav ?? null;
+  if (navEntity === null && options.agent != null && world.has(options.agent, NavAgent)) {
+    navEntity = world.get(options.agent, NavAgent).nav;
+  }
+  requireNav(world, from, navEntity);
+  if (foundGrid) {
+    out.nav = foundGrid.entity;
+    gridPath(navState(world), foundGrid, from, to, out);
+  } else {
+    out.nav = foundMesh.entity;
+    const m = foundMesh;
+    if (m.frame === null) meshPath(m, from, to, out, options.areas);
+    else {
+      m.pointIn(from[0], from[1], from[2] ?? 0, fromLocal);
+      m.pointIn(to[0], to[1], to[2] ?? 0, toLocal);
+      meshPath(m, fromLocal, toLocal, out, options.areas);
+      const c = out.corners;
+      for (let i = 0; i < out.count; i++) {
+        m.pointOut(c[i * 3], c[i * 3 + 1], c[i * 3 + 2], inFrame);
+        c[i * 3] = inFrame[0];
+        c[i * 3 + 1] = inFrame[1];
+        c[i * 3 + 2] = inFrame[2];
+      }
+    }
+  }
+  return out;
+}
+const fromLocal = new Float64Array(3);
+const toLocal = new Float64Array(3);
+function meshPathLocal(m, from, to, out, areas) {
+  out.nav = m.entity;
+  meshPath(m, from, to, out, areas);
+}
+function gridPath(state, g, from, to, out) {
+  const grid = g.grid;
+  const w = grid.width;
+  const fx = (from[0] - g.ox) / g.csx;
+  const fy = (from[1] - g.oy) / g.csy;
+  let tx = (to[0] - g.ox) / g.csx;
+  let ty = (to[1] - g.oy) / g.csy;
+  const z = from[2] ?? g.z;
+  out.count = 0;
+  out.length = 0;
+  out.status = "none";
+  const start = nearestWalkable(grid, fx, fy, SNAP_CELLS);
+  if (start === -1) return;
+  const outside = tx < 0 || ty < 0 || tx >= grid.width || ty >= grid.height;
+  if (outside) {
+    tx = tx < 0 ? 0.5 : tx >= grid.width ? grid.width - 0.5 : tx;
+    ty = ty < 0 ? 0.5 : ty >= grid.height ? grid.height - 0.5 : ty;
+  }
+  let goal = nearestWalkable(grid, tx, ty, SNAP_CELLS);
+  const noGoal = goal === -1;
+  if (noGoal) goal = start;
+  const search = state.search;
+  const sx = start % w;
+  const sy = (start - sx) / w;
+  const gx = goal % w;
+  const gy = (goal - gx) / w;
+  search.search(grid, sx, sy, gx, gy, g.diagonal, g.csx, g.csy);
+  const reached = search.reached && !noGoal;
+  const snappedStart = Math.floor(fx) !== sx || Math.floor(fy) !== sy;
+  ends[0] = snappedStart ? sx + 0.5 : fx;
+  ends[1] = snappedStart ? sy + 0.5 : fy;
+  const last = search.cells[search.count - 1];
+  const lx = last % w;
+  const ly = (last - lx) / w;
+  const exact = reached && Math.floor(tx) === lx && Math.floor(ty) === ly && !outside;
+  ends[2] = exact ? tx : lx + 0.5;
+  ends[3] = exact ? ty : ly + 0.5;
+  const capacity = Math.floor(out.corners.length / 3);
+  if (cellScratch.length < capacity * 2) cellScratch = new Float32Array(capacity * 2);
+  const n = smoothGridPath(
+    grid,
+    search.cells,
+    search.count,
+    ends,
+    g.diagonal,
+    cellScratch,
+    2,
+    capacity
+  );
+  const c = out.corners;
+  let length = 0;
+  for (let i = 0; i < n; i++) {
+    c[i * 3] = g.ox + cellScratch[i * 2] * g.csx;
+    c[i * 3 + 1] = g.oy + cellScratch[i * 2 + 1] * g.csy;
+    c[i * 3 + 2] = z;
+    if (i > 0) {
+      const dx = c[i * 3] - c[i * 3 - 3];
+      const dy = c[i * 3 + 1] - c[i * 3 - 2];
+      length += Math.sqrt(dx * dx + dy * dy);
+    }
+  }
+  out.count = n;
+  out.length = length;
+  out.status = exact ? "complete" : "partial";
+}
+const v3 = { x: 0, y: 0, z: 0 };
+const v3b = { x: 0, y: 0, z: 0 };
+const extents = { x: 0, y: 0, z: 0 };
+function queryExtents(m) {
+  extents.x = Math.max(1, m.settings.agentRadius * 4);
+  extents.y = Math.max(2, m.settings.agentHeight * 1.5);
+  extents.z = extents.x;
+  return extents;
+}
+function areaFilter(m, areas) {
+  const f = new m.R.QueryFilter();
+  for (let a = 0; a < 63; a++) f.setAreaCost(a, m.filter.getAreaCost(a));
+  let exclude = ~m.filter.includeFlags & 65535;
+  for (const key of Object.keys(areas)) {
+    const area = Number(key);
+    const cost = areas[area];
+    if (!(area >= 0 && area < 63)) continue;
+    if (cost <= 0) exclude |= area < 15 ? 1 << area : 1 << 15;
+    else f.setAreaCost(area, cost);
+  }
+  f.includeFlags = 65535 & ~exclude;
+  return f;
+}
+function meshPath(m, from, to, out, areas) {
+  out.count = 0;
+  out.length = 0;
+  out.status = "none";
+  const filter = areas ? areaFilter(m, areas) : m.filter;
+  try {
+    const q = m.query;
+    const halfExtents = queryExtents(m);
+    v3.x = from[0];
+    v3.y = from[1];
+    v3.z = from[2];
+    const start = q.findNearestPoly(v3, { filter, halfExtents });
+    v3b.x = to[0];
+    v3b.y = to[1];
+    v3b.z = to[2];
+    const end = q.findNearestPoly(v3b, { filter, halfExtents });
+    if (!start.success || start.nearestRef === 0) return;
+    const startPos = start.nearestPoint;
+    let endRef = end.success ? end.nearestRef : 0;
+    let endPos = endRef ? end.nearestPoint : v3b;
+    const capacity = Math.floor(out.corners.length / 3);
+    if (endRef === 0) {
+      endRef = start.nearestRef;
+      endPos = startPos;
+    }
+    const path = q.findPath(start.nearestRef, endRef, startPos, endPos, {
+      filter,
+      maxPathPolys: 512
+    });
+    const polys = path.polys;
+    try {
+      if (!path.success || polys.size === 0) return;
+      let n = 0;
+      while (n < polys.size && polys.get(n) !== 0) n++;
+      if (n === 0) return;
+      const lastPoly = polys.get(n - 1);
+      let target = endPos;
+      const complete = lastPoly === end.nearestRef && end.success && end.nearestRef !== 0;
+      if (lastPoly !== endRef) {
+        const closest = q.closestPointOnPoly(lastPoly, endPos);
+        if (closest.success) target = closest.closestPoint;
+      }
+      if (n < polys.size) polys.resize(n);
+      const straight = q.findStraightPath(startPos, target, polys, {
+        maxStraightPathPoints: capacity
+      });
+      try {
+        if (!straight.success) return;
+        const c = out.corners;
+        const count = straight.straightPathCount;
+        let length = 0;
+        for (let i = 0; i < count; i++) {
+          c[i * 3] = straight.straightPath.get(i * 3);
+          c[i * 3 + 1] = straight.straightPath.get(i * 3 + 1);
+          c[i * 3 + 2] = straight.straightPath.get(i * 3 + 2);
+          if (i > 0) {
+            const dx = c[i * 3] - c[i * 3 - 3];
+            const dy = c[i * 3 + 1] - c[i * 3 - 2];
+            const dz = c[i * 3 + 2] - c[i * 3 - 1];
+            length += Math.sqrt(dx * dx + dy * dy + dz * dz);
+          }
+        }
+        out.count = count;
+        out.length = length;
+        out.status = complete ? "complete" : "partial";
+      } finally {
+        straight.straightPath.destroy();
+        straight.straightPathFlags.destroy();
+        straight.straightPathRefs.destroy();
+      }
+    } finally {
+      polys.destroy();
+    }
+  } finally {
+    if (filter !== m.filter) m.R.Raw.destroy(filter.raw);
+  }
+}
+function nearestPoint(world, point, out, options = {}) {
+  requireNav(world, point, options.nav ?? null);
+  if (foundGrid) {
+    const g = foundGrid;
+    const grid = g.grid;
+    const x = (point[0] - g.ox) / g.csx;
+    const y = (point[1] - g.oy) / g.csy;
+    const cell = nearestWalkable(grid, x, y, Math.max(grid.width, grid.height));
+    if (cell === -1) return false;
+    const cx = cell % grid.width;
+    const cy = (cell - cx) / grid.width;
+    const inside = Math.floor(x) === cx && Math.floor(y) === cy;
+    out[0] = inside ? point[0] : g.ox + (cx + 0.5) * g.csx;
+    out[1] = inside ? point[1] : g.oy + (cy + 0.5) * g.csy;
+    out[2] = point[2] ?? g.z;
+    return true;
+  }
+  const m = foundMesh;
+  m.pointIn(point[0], point[1], point[2] ?? 0, inFrame);
+  v3.x = inFrame[0];
+  v3.y = inFrame[1];
+  v3.z = inFrame[2];
+  const r = m.query.findClosestPoint(v3, { filter: m.filter, halfExtents: queryExtents(m) });
+  if (!r.success || r.polyRef === 0) return false;
+  m.pointOut(r.point.x, r.point.y, r.point.z, inFrame);
+  out[0] = inFrame[0];
+  out[1] = inFrame[1];
+  out[2] = inFrame[2];
+  return true;
+}
+function createNavRayHit() {
+  return { t: 1, point: new Float64Array(3), normal: new Float64Array(3) };
+}
+const gridHit = { t: 1, x: 0, y: 0 };
+const seg = new Float64Array(4);
+function navRaycast(world, from, to, hit = createNavRayHit(), options = {}) {
+  requireNav(world, from, options.nav ?? null);
+  hit.normal.fill(0);
+  if (foundGrid) {
+    const g = foundGrid;
+    seg[0] = (from[0] - g.ox) / g.csx;
+    seg[1] = (from[1] - g.oy) / g.csy;
+    seg[2] = (to[0] - g.ox) / g.csx;
+    seg[3] = (to[1] - g.oy) / g.csy;
+    const clear = traceSegment(g.grid, seg, g.diagonal, 255, gridHit);
+    hit.t = gridHit.t;
+    hit.point[0] = g.ox + gridHit.x * g.csx;
+    hit.point[1] = g.oy + gridHit.y * g.csy;
+    hit.point[2] = from[2] ?? g.z;
+    if (!clear) {
+      const dx = seg[2] - seg[0];
+      const dy = seg[3] - seg[1];
+      const fx = gridHit.x - Math.floor(gridHit.x);
+      const fy = gridHit.y - Math.floor(gridHit.y);
+      const onX = Math.min(fx, 1 - fx) < Math.min(fy, 1 - fy);
+      if (onX) hit.normal[0] = dx > 0 ? -1 : 1;
+      else hit.normal[1] = dy > 0 ? -1 : 1;
+    }
+    return !clear;
+  }
+  const m = foundMesh;
+  m.pointIn(from[0], from[1], from[2] ?? 0, fromLocal);
+  m.pointIn(to[0], to[1], to[2] ?? 0, toLocal);
+  v3.x = fromLocal[0];
+  v3.y = fromLocal[1];
+  v3.z = fromLocal[2];
+  const start = m.query.findNearestPoly(v3, { filter: m.filter, halfExtents: queryExtents(m) });
+  if (!start.success || start.nearestRef === 0) {
+    hit.t = 0;
+    hit.point[0] = from[0];
+    hit.point[1] = from[1];
+    hit.point[2] = from[2];
+    return true;
+  }
+  v3b.x = toLocal[0];
+  v3b.y = toLocal[1];
+  v3b.z = toLocal[2];
+  const r = m.query.raycast(start.nearestRef, start.nearestPoint, v3b, { filter: m.filter });
+  const t = r.t > 1 ? 1 : r.t;
+  hit.t = t;
+  const sp = start.nearestPoint;
+  m.pointOut(
+    sp.x + (toLocal[0] - sp.x) * t,
+    sp.y + (toLocal[1] - sp.y) * t,
+    sp.z + (toLocal[2] - sp.z) * t,
+    hit.point
+  );
+  if (t < 1) m.vectorOut(r.hitNormal.x, r.hitNormal.y, r.hitNormal.z, hit.normal);
+  return t < 1;
+}
+function worldPos(world, e, out) {
+  const m = world.get(e, GlobalTransform).matrix;
+  out[0] = m[3];
+  out[1] = m[7];
+  out[2] = m[11];
+}
+export {
+  PATH_STATUSES,
+  createNavPath,
+  createNavRayHit,
+  findPath,
+  meshPathLocal,
+  navAt,
+  navRaycast,
+  nearestPoint,
+  worldPos
+};

package/dist/recast.d.ts

@@ -0,0 +1,39 @@
+import type * as RecastModule from 'recast-navigation';
+import type { TriangleSoup } from './geometry.js';
+export type Recast = typeof RecastModule;
+/** Loads and initializes Recast and Detour (WASM) once per process. */
+export declare function loadRecast(): Promise<Recast>;
+/** What a NavMesh bakes with, as its component fields. */
+export interface BakeSettings {
+    agentRadius: number;
+    agentHeight: number;
+    maxClimb: number;
+    maxSlope: number;
+    cellSize: number;
+    cellHeight: number;
+    tileSize: number;
+}
+/** Poly flags for an area: one bit per area 0–14, so filters can exclude areas exactly. */
+export declare function areaFlags(area: number): number;
+export interface OffMeshLinkParams {
+    start: [number, number, number];
+    end: [number, number, number];
+    radius: number;
+    bidirectional: boolean;
+    area: number;
+}
+/** Voxel counts Recast wants, from world-unit settings. */
+export declare function voxelSettings(s: BakeSettings): {
+    walkableRadius: number;
+    walkableHeight: number;
+    walkableClimb: number;
+    borderSize: number;
+    tileWorld: number;
+};
+/**
+ * Builds one navmesh tile with Recast: the triangles of `soup` listed in `triangles` (already
+ * those overlapping the tile plus its border), rasterized with their area codes, filtered for
+ * the agent, and turned into Detour tile data. Returns the tile's bytes, or null when nothing is
+ * walkable in it. Throws `nav/bake-failed` when a Recast step fails.
+ */
+export declare function buildTile(R: Recast, s: BakeSettings, tx: number, ty: number, yMin: number, yMax: number, soup: TriangleSoup, triangles: Int32Array, count: number, links: readonly OffMeshLinkParams[]): Uint8Array | null;

package/dist/recast.js

@@ -0,0 +1,161 @@
+import { ShardError } from "@aethervtt/shard-core";
+let module;
+function loadRecast() {
+  module ??= (async () => {
+    const R = await import("recast-navigation");
+    await R.init();
+    return R;
+  })();
+  return module;
+}
+const WALKABLE = 63;
+function areaFlags(area) {
+  return 1 << (area < 15 ? area : 15);
+}
+function voxelSettings(s) {
+  const walkableRadius = Math.ceil(s.agentRadius / s.cellSize);
+  return {
+    walkableRadius,
+    walkableHeight: Math.max(3, Math.ceil(s.agentHeight / s.cellHeight)),
+    walkableClimb: Math.floor(s.maxClimb / s.cellHeight),
+    borderSize: walkableRadius + 3,
+    tileWorld: s.tileSize * s.cellSize
+  };
+}
+const scratch = { verts: new Float32Array(0), tris: new Int32Array(0), areas: new Uint8Array(0) };
+function buildTile(R, s, tx, ty, yMin, yMax, soup, triangles, count, links) {
+  const v = voxelSettings(s);
+  const cs = s.cellSize;
+  const ch = s.cellHeight;
+  const border = v.borderSize;
+  const size = s.tileSize + border * 2;
+  const bmin = [
+    tx * v.tileWorld - border * cs,
+    yMin,
+    ty * v.tileWorld - border * cs
+  ];
+  const bmax = [
+    (tx + 1) * v.tileWorld + border * cs,
+    yMax,
+    (ty + 1) * v.tileWorld + border * cs
+  ];
+  if (count === 0) return null;
+  if (scratch.areas.length < count) {
+    scratch.verts = new Float32Array(count * 9);
+    scratch.tris = new Int32Array(count * 3);
+    scratch.areas = new Uint8Array(count);
+  }
+  const p = soup.positions;
+  for (let i = 0; i < count; i++) {
+    const t = triangles[i];
+    scratch.verts.set(p.subarray(t * 9, t * 9 + 9), i * 9);
+    scratch.tris[i * 3] = i * 3;
+    scratch.tris[i * 3 + 1] = i * 3 + 1;
+    scratch.tris[i * 3 + 2] = i * 3 + 2;
+    scratch.areas[i] = soup.areas[t];
+  }
+  const ctx = new R.RecastBuildContext(false);
+  const verts = new R.VerticesArray();
+  const tris = new R.TrianglesArray();
+  const areas = new R.TriangleAreasArray();
+  verts.copy(scratch.verts.subarray(0, count * 9));
+  tris.copy(scratch.tris.subarray(0, count * 3));
+  areas.resize(count);
+  let hf;
+  let chf;
+  let cset;
+  let pmesh;
+  let dmesh;
+  const fail = (step) => {
+    throw new ShardError("nav/bake-failed", `Recast failed to ${step} for tile (${tx}, ${ty})`, {
+      hint: "Check the NavMesh settings: cellSize and cellHeight must be positive, and tileSize small enough for its bounds."
+    });
+  };
+  try {
+    hf = R.allocHeightfield();
+    if (!R.createHeightfield(ctx, hf, size, size, bmin, bmax, cs, ch)) fail("create a heightfield");
+    R.markWalkableTriangles(ctx, s.maxSlope, verts, count * 3, tris, count, areas);
+    const view = areas.getHeapView();
+    for (let i = 0; i < count; i++) {
+      const a = scratch.areas[i];
+      if (a !== 0 && view[i] === WALKABLE) view[i] = a;
+    }
+    if (!R.rasterizeTriangles(ctx, verts, count * 3, tris, areas, count, hf, v.walkableClimb))
+      fail("rasterize triangles");
+    R.filterLowHangingWalkableObstacles(ctx, v.walkableClimb, hf);
+    R.filterLedgeSpans(ctx, v.walkableHeight, v.walkableClimb, hf);
+    R.filterWalkableLowHeightSpans(ctx, v.walkableHeight, hf);
+    chf = R.allocCompactHeightfield();
+    if (!R.buildCompactHeightfield(ctx, v.walkableHeight, v.walkableClimb, hf, chf))
+      fail("build the compact heightfield");
+    R.freeHeightfield(hf);
+    hf = void 0;
+    if (!R.erodeWalkableArea(ctx, v.walkableRadius, chf)) fail("erode the walkable area");
+    if (!R.buildDistanceField(ctx, chf)) fail("build the distance field");
+    if (!R.buildRegions(ctx, chf, border, 8 * 8, 20 * 20)) fail("build regions");
+    cset = R.allocContourSet();
+    const maxEdge = Math.ceil(s.agentRadius * 8 / cs) || 12;
+    if (!R.buildContours(ctx, chf, 1.3, maxEdge, cset, R.Recast.RC_CONTOUR_TESS_WALL_EDGES))
+      fail("trace contours");
+    pmesh = R.allocPolyMesh();
+    if (!R.buildPolyMesh(ctx, cset, 6, pmesh)) fail("triangulate contours");
+    dmesh = R.allocPolyMeshDetail();
+    if (!R.buildPolyMeshDetail(ctx, pmesh, chf, cs * 6, ch * 1, dmesh))
+      fail("build the detail mesh");
+    const npolys = pmesh.npolys();
+    if (npolys === 0) return null;
+    for (let i = 0; i < npolys; i++) {
+      let area = pmesh.areas(i);
+      if (area === WALKABLE) {
+        area = 0;
+        pmesh.setAreas(i, 0);
+      }
+      pmesh.setFlags(i, areaFlags(area));
+    }
+    const params = new R.NavMeshCreateParams();
+    params.setPolyMeshCreateParams(pmesh);
+    params.setPolyMeshDetailCreateParams(dmesh);
+    params.setWalkableHeight(v.walkableHeight * ch);
+    params.setWalkableRadius(v.walkableRadius * cs);
+    params.setWalkableClimb(v.walkableClimb * ch);
+    params.setCellSize(cs);
+    params.setCellHeight(ch);
+    params.setBuildBvTree(true);
+    if (links.length > 0) {
+      params.setOffMeshConnections(
+        links.map((l) => ({
+          startPosition: { x: l.start[0], y: l.start[1], z: l.start[2] },
+          endPosition: { x: l.end[0], y: l.end[1], z: l.end[2] },
+          radius: l.radius,
+          bidirectional: l.bidirectional,
+          area: l.area,
+          flags: areaFlags(l.area)
+        }))
+      );
+    }
+    params.setTileX(tx);
+    params.setTileY(ty);
+    const result = R.createNavMeshData(params);
+    R.Raw.destroy(params.raw);
+    if (!result.success) fail("create Detour tile data");
+    const bytes = result.navMeshData.toTypedArray().slice();
+    result.navMeshData.destroy();
+    return bytes;
+  } finally {
+    if (hf) R.freeHeightfield(hf);
+    if (chf) R.freeCompactHeightfield(chf);
+    if (cset) R.freeContourSet(cset);
+    if (pmesh) R.freePolyMesh(pmesh);
+    if (dmesh) R.freePolyMeshDetail(dmesh);
+    verts.destroy();
+    tris.destroy();
+    areas.destroy();
+    R.Raw.destroy(ctx.raw);
+  }
+}
+export {
+  areaFlags,
+  buildTile,
+  loadRecast,
+  voxelSettings
+};