@v12-engine/engine 0.1.1 → 0.4.0

package/dist/navigation/builds.d.ts

@@ -4,19 +4,33 @@
  * @beta
  */
 export interface NavigationBuildConfig {
+    /** Recast's cell size on the ground plane, in world units: how finely the ground is voxelised */
     cs: number;
+    /** Recast's cell height, in world units: how finely the ground is voxelised vertically */
     ch: number;
+    /** The size of one tile of the tile cache, in cells */
     tileSize: number;
+    /** The steepest slope that is walkable, in degrees */
     walkableSlopeAngle: number;
+    /** The least height of open space a unit needs to stand in, as Recast takes it */
     walkableHeight: number;
+    /** The most a unit can step up, as Recast takes it */
     walkableClimb: number;
+    /** How far the walkable area is kept from walls, as Recast takes it: the largest unit's radius */
     walkableRadius: number;
+    /** The most the edges of the walkable regions' outlines may stray from the ground when simplified */
     maxSimplificationError: number;
+    /** The smallest region that is kept apart; smaller ones are merged into a neighbour */
     mergeRegionArea: number;
+    /** The most vertices a polygon of the navigation mesh has */
     maxVertsPerPoly: number;
+    /** How far apart the points are where the mesh's height is sampled */
     detailSampleDist: number;
+    /** The most the mesh's height may differ from the ground between sampled points */
     detailSampleMaxError: number;
+    /** How many layers of walkable space a tile is expected to have, for the tile cache's size */
     expectedLayersPerTile: number;
+    /** How many obstacles (buildings, shut gates) the tile cache has room for */
     maxObstacles: number;
 }
 /**
@@ -25,8 +39,11 @@ export interface NavigationBuildConfig {
  * @beta
  */
 export interface NavigationBuild {
+    /** The ground's triangles as x, y, z triples, three vertices to a triangle */
     positions: Float32Array;
+    /** The triangles as indices into `positions` */
     indices: Uint32Array;
+    /** How the triangles are cut */
     config: NavigationBuildConfig;
     /**
      * How fast one on foot goes over each cell of the ground (`groundSpeedOfCell`), for a path to weigh: none where every
@@ -40,8 +57,11 @@ export interface NavigationBuild {
  * @beta
  */
 export interface NavigationSpeeds {
+    /** The width of the speed grid in cells */
     width: number;
+    /** The depth of the speed grid in cells */
     depth: number;
+    /** The speed over each cell, a multiplier where 1 is the ground's ordinary pace */
     values: Float32Array;
 }
 /**
@@ -58,7 +78,9 @@ export type NavigationBuilder = (build: NavigationBuild) => Promise<Uint8Array>;
  * @beta
  */
 export interface NavigationCache {
+    /** Gives what was built under the key, or undefined when nothing was; may answer later */
     get(key: string): Uint8Array | undefined | Promise<Uint8Array | undefined>;
+    /** Keeps what was built under the key */
     set(key: string, data: Uint8Array): void | Promise<void>;
 }
 /** Recast's WebAssembly, once for each thread */
@@ -82,11 +104,14 @@ export declare function memoryNavigationCache(maxBytes?: number): NavigationCach
  * @beta
  */
 export interface NavigationWorkerLike {
+    /** Sends the worker a message; `transfer` lists the buffers handed over rather than copied */
     postMessage(message: unknown, transfer?: unknown[]): void;
+    /** Listens for the worker's `message` and `error`, as a page's worker does */
     addEventListener?(type: 'message' | 'error', listener: (event: {
         data?: unknown;
         message?: string;
     }) => void): void;
+    /** Listens for the worker's `message` and `error`, as Node's `worker_threads` worker does */
     on?(type: 'message' | 'error', listener: (value: unknown) => void): void;
 }
 /**
@@ -97,21 +122,26 @@ export interface NavigationWorkerLike {
  * `navigationWorker(() => new Worker(new URL('./navigation.worker.ts', import.meta.url), { type: 'module' }))`, the
  * builder of every world it makes (`NavigationBuilds`).
  * Given as a function, the worker is made at the first build: a page whose menu builds nothing fetches none of it
- * until a world is made (OF2); given made, it is used as it is
+ * until a world is made (OF2); given made, it is used as it is. Given as a function, as many as `workers` are made as
+ * builds are asked at once (a world's navigations, one for each size of unit, the water's, each side's: built side by
+ * side, the Well's four in the time of its longest), each build to the one with the fewest under way
  *
  * @beta
  */
-export declare function navigationWorker(given: NavigationWorkerLike | (() => NavigationWorkerLike)): NavigationBuilder;
+export declare function navigationWorker(given: NavigationWorkerLike | (() => NavigationWorkerLike), workers?: number): NavigationBuilder;
 /**
  * Where a worker hears and answers: a page's worker scope, or Node's `parentPort`
  *
  * @beta
  */
 export interface NavigationPort {
+    /** Sends a message back to whoever started the worker; `transfer` lists the buffers handed over */
     postMessage(message: unknown, transfer?: unknown[]): void;
+    /** Listens for the messages sent to the worker, as a page's worker scope does */
     addEventListener?(type: 'message', listener: (event: {
         data: unknown;
     }) => void): void;
+    /** Listens for the messages sent to the worker, as Node's `parentPort` does */
     on?(type: 'message', listener: (value: unknown) => void): void;
 }
 /**
@@ -130,7 +160,9 @@ export declare function serveNavigationBuilds(port?: NavigationPort): void;
  * @beta
  */
 export interface NavigationBuilds {
+    /** Builds a navigation on this thread, or somewhere else when set to a worker's; this thread when left out */
     builder?: NavigationBuilder;
+    /** Where what was built is kept between worlds; the process's memory when left out, nowhere for `null` */
     cache?: NavigationCache | null;
 }
 /**

package/dist/navigation/builds.js

@@ -0,0 +1,287 @@
+import { generateGroundTileCache } from "./groundAreas.js";
+import { exportTileCache, init } from "@recast-navigation/core";
+import { generateTileCache } from "@recast-navigation/generators";
+//#region src/navigation/builds.ts
+var initialized;
+/** Recast's WebAssembly, once for each thread */
+var initRecast = () => initialized ??= init();
+/**
+* Builds a navigation on this thread, and gives back what was built: what a worker does too
+*
+* @beta
+*/
+async function buildNavigationData(build) {
+	await initRecast();
+	return buildNavigationNow(build);
+}
+/**
+* Builds a navigation on this thread at once, Recast's WebAssembly there already (`initRecast`): a navigation made
+* again in the middle of a tick, its ground reshaped (`RecastNavigation.reshape`)
+*
+* @internal
+*/
+function buildNavigationNow(build) {
+	if (build.speeds) {
+		const { navMesh, tileCache } = generateGroundTileCache(build);
+		try {
+			return exportTileCache(navMesh, tileCache);
+		} finally {
+			tileCache.destroy();
+			navMesh.destroy();
+		}
+	}
+	const result = generateTileCache(build.positions, build.indices, build.config);
+	if (!result.success) throw new Error(`Navmesh generation failed: ${result.error}`);
+	const { navMesh, tileCache } = result;
+	try {
+		return exportTileCache(navMesh, tileCache);
+	} finally {
+		tileCache.destroy();
+		navMesh.destroy();
+	}
+}
+/**
+* Kept in memory, the last built first, up to `maxBytes` of them (64 MB when left out): a map of 512 cells a side is
+* under a megabyte
+*
+* @beta
+*/
+function memoryNavigationCache(maxBytes = 67108864) {
+	const kept = /* @__PURE__ */ new Map();
+	let bytes = 0;
+	return {
+		get(key) {
+			const data = kept.get(key);
+			if (!data) return void 0;
+			kept.delete(key);
+			kept.set(key, data);
+			return data;
+		},
+		set(key, data) {
+			const before = kept.get(key);
+			if (before) bytes -= before.byteLength;
+			kept.delete(key);
+			kept.set(key, data);
+			bytes += data.byteLength;
+			for (const [old, value] of kept) {
+				if (bytes <= maxBytes || old === key) break;
+				kept.delete(old);
+				bytes -= value.byteLength;
+			}
+		}
+	};
+}
+/**
+* The key of a build: a hash of the triangles and of how they are cut. Two builds of the same key make the same
+* navigation
+*
+* @internal
+*/
+function navigationKey(build) {
+	let a = 2166136261;
+	let b = 1523705862;
+	const mix = (word) => {
+		a = Math.imul(a ^ word, 16777619);
+		b = Math.imul(b ^ word, 1540483477);
+	};
+	const positions = new Uint32Array(build.positions.buffer, build.positions.byteOffset, build.positions.length);
+	for (let i = 0; i < positions.length; i++) mix(positions[i]);
+	mix(4294967295);
+	for (let i = 0; i < build.indices.length; i++) mix(build.indices[i]);
+	const config = JSON.stringify(build.config, Object.keys(build.config).sort());
+	for (let i = 0; i < config.length; i++) mix(config.charCodeAt(i));
+	if (build.speeds) {
+		mix(4294967294);
+		mix(build.speeds.width);
+		const speeds = new Uint32Array(build.speeds.values.buffer, build.speeds.values.byteOffset, build.speeds.values.length);
+		for (let i = 0; i < speeds.length; i++) {
+			let word = speeds[i];
+			word = Math.imul(word ^ word >>> 16, 2246822507);
+			word = Math.imul(word ^ word >>> 13, 3266489909);
+			mix((word ^ word >>> 16) >>> 0);
+		}
+	}
+	return `${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0).toString(16).padStart(8, "0")}-${positions.length}`;
+}
+/** How many workers a page's builder makes at most: three, or one fewer than the machine's threads where that is less */
+function defaultWorkers() {
+	const threads = globalThis.navigator?.hardwareConcurrency ?? 2;
+	return Math.min(3, Math.max(1, threads - 1));
+}
+/**
+* A builder that builds in a worker: one whose file serves builds (`serveNavigationBuilds`). In a page, the page makes
+* the worker, as its bundler wants it: the library makes no worker of its own there.
+*
+* A worker's file of two lines (`serveNavigationBuilds` imported from the engine, and called), and the page:
+* `navigationWorker(() => new Worker(new URL('./navigation.worker.ts', import.meta.url), { type: 'module' }))`, the
+* builder of every world it makes (`NavigationBuilds`).
+* Given as a function, the worker is made at the first build: a page whose menu builds nothing fetches none of it
+* until a world is made (OF2); given made, it is used as it is. Given as a function, as many as `workers` are made as
+* builds are asked at once (a world's navigations, one for each size of unit, the water's, each side's: built side by
+* side, the Well's four in the time of its longest), each build to the one with the fewest under way
+*
+* @beta
+*/
+function navigationWorker(given, workers = defaultWorkers()) {
+	let next = 0;
+	const waiting = /* @__PURE__ */ new Map();
+	const answered = (answer) => {
+		const wait = waiting.get(answer.id);
+		if (!wait) return;
+		waiting.delete(answer.id);
+		wait.by.busy--;
+		if (answer.data) wait.done(answer.data);
+		else wait.failed(new Error(answer.error ?? "The navigation could not be built"));
+	};
+	const broke = (hired, error) => {
+		const reason = /* @__PURE__ */ new Error(`The navigation's worker stopped: ${error instanceof Error ? error.message : String(error?.message ?? error)}`);
+		for (const [id, wait] of waiting) if (wait.by === hired) {
+			waiting.delete(id);
+			wait.failed(reason);
+		}
+		hired.busy = 0;
+	};
+	const hired = [];
+	const hire = (worker) => {
+		const one = {
+			worker,
+			busy: 0
+		};
+		if (worker.on) {
+			worker.on("message", (value) => answered(value));
+			worker.on("error", (error) => broke(one, error));
+		} else {
+			worker.addEventListener?.("message", (event) => answered(event.data));
+			worker.addEventListener?.("error", (error) => broke(one, error));
+		}
+		hired.push(one);
+		return one;
+	};
+	const worker = () => {
+		const idle = hired.reduce((best, each) => !best || each.busy < best.busy ? each : best, void 0);
+		if (idle && (idle.busy === 0 || typeof given !== "function" || hired.length >= Math.max(1, workers))) return idle;
+		return hire(typeof given === "function" ? given() : given);
+	};
+	if (typeof given !== "function") hire(given);
+	return (build) => new Promise((done, failed) => {
+		const id = ++next;
+		const by = worker();
+		by.busy++;
+		waiting.set(id, {
+			done,
+			failed,
+			by
+		});
+		by.worker.postMessage({
+			id,
+			build: {
+				positions: build.positions.slice(),
+				indices: build.indices.slice(),
+				config: build.config,
+				...build.speeds && { speeds: {
+					...build.speeds,
+					values: build.speeds.values.slice()
+				} }
+			}
+		});
+	});
+}
+/**
+* What a navigation worker's file does: it builds what it is sent and sends back what it built. `port` is where it
+* hears: the worker's own scope when left out (a page's worker)
+*
+* @beta
+*/
+function serveNavigationBuilds(port = globalThis) {
+	const asked = async (message) => {
+		const { id, build } = message;
+		try {
+			const data = await buildNavigationData(build);
+			port.postMessage({
+				id,
+				data
+			}, [data.buffer]);
+		} catch (error) {
+			port.postMessage({
+				id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	};
+	if (port.on) port.on("message", (value) => void asked(value));
+	else port.addEventListener?.("message", (event) => void asked(event.data));
+}
+/** Where a world says nothing: this thread, and kept in the process's memory, which every world's ground may read */
+var defaults = {
+	builder: buildNavigationData,
+	cache: memoryNavigationCache()
+};
+/**
+* What was built from this: kept, or built now (by the builder set) and kept. A builder that fails falls back to this
+* thread once, and says why in what it throws only when that fails too
+*/
+async function navigationData(build, using = {}) {
+	const cache = using.cache !== void 0 ? using.cache : defaults.cache;
+	const builder = using.builder ?? defaults.builder;
+	const key = cache ? navigationKey(build) : "";
+	const building = cache ? buildsOf(cache) : void 0;
+	const under = building?.get(key);
+	if (under) return under;
+	const made = (async () => {
+		const kept = cache ? await cache.get(key) : void 0;
+		if (kept) return kept;
+		let data;
+		try {
+			data = await builder(build);
+		} catch (error) {
+			if (builder === buildNavigationData) throw error;
+			data = await buildNavigationData(build);
+		}
+		if (cache) await cache.set(key, data);
+		return data;
+	})();
+	if (!building) return made;
+	building.set(key, made);
+	try {
+		return await made;
+	} finally {
+		building.delete(key);
+	}
+}
+/** The last of the works on this thread asked to go one after another (`inTurn`): settled once it is done */
+var turn = Promise.resolve();
+/**
+* Runs `work` once every work asked before it this way is done, failed or not: Recast's WebAssembly on this thread, a
+* navigation built and read before the next is built (`RecastNavigation.create`)
+*
+* @internal
+*/
+function inTurn(work) {
+	const done = turn.then(work, work);
+	turn = done.catch(() => void 0);
+	return done;
+}
+/** The builds under way for what a cache keeps, by their key */
+var underWay = /* @__PURE__ */ new WeakMap();
+var buildsOf = (cache) => {
+	let builds = underWay.get(cache);
+	if (!builds) underWay.set(cache, builds = /* @__PURE__ */ new Map());
+	return builds;
+};
+/**
+* What each makes, made side by side and given back in their order: where one fails, those the others made are freed
+* (WebAssembly memory) once all are settled, and the first failure is thrown
+*
+* @internal
+*/
+async function allOrFreed(makes) {
+	const settled = await Promise.allSettled(makes.map((make) => make()));
+	const failed = settled.find((each) => each.status === "rejected");
+	if (!failed) return settled.map((each) => each.value);
+	for (const each of settled) if (each.status === "fulfilled") each.value?.dispose();
+	throw failed.reason;
+}
+//#endregion
+export { allOrFreed, buildNavigationData, buildNavigationNow, inTurn, initRecast, memoryNavigationCache, navigationData, navigationKey, navigationWorker, serveNavigationBuilds };
+
+//# sourceMappingURL=builds.js.map

package/dist/navigation/builds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builds.js","names":[],"sources":["../../src/navigation/builds.ts"],"sourcesContent":["import { exportTileCache, init } from '@recast-navigation/core'\nimport { generateTileCache } from '@recast-navigation/generators'\nimport { generateGroundTileCache } from './groundAreas'\n\n/*\n * Building a navigation off the thread that runs the game, and not again for ground it was built for (S37). A build of\n * the whole map blocks: 0.1 s for 128 cells a side, 0.4 s for 256, 2 s for 512, on every world made or loaded. What a\n * build makes is data (Recast's tile cache, exported): built once, it is kept by a hash of what it was built from, and\n * a world made again on the same ground (a restart, a load, Play here) reads it in a few milliseconds. Every navigation\n * is read from that data, built just now or kept, so the two are the same navigation: nothing depends on whether a\n * build was kept, nor on how long it took, and the world does not step until it is there.\n */\n\n/**\n * How Recast is told to cut the ground: what the tile cache is generated with\n *\n * @beta\n */\nexport interface NavigationBuildConfig {\n\t/** Recast's cell size on the ground plane, in world units: how finely the ground is voxelised */\n\tcs: number\n\t/** Recast's cell height, in world units: how finely the ground is voxelised vertically */\n\tch: number\n\t/** The size of one tile of the tile cache, in cells */\n\ttileSize: number\n\t/** The steepest slope that is walkable, in degrees */\n\twalkableSlopeAngle: number\n\t/** The least height of open space a unit needs to stand in, as Recast takes it */\n\twalkableHeight: number\n\t/** The most a unit can step up, as Recast takes it */\n\twalkableClimb: number\n\t/** How far the walkable area is kept from walls, as Recast takes it: the largest unit's radius */\n\twalkableRadius: number\n\t/** The most the edges of the walkable regions' outlines may stray from the ground when simplified */\n\tmaxSimplificationError: number\n\t/** The smallest region that is kept apart; smaller ones are merged into a neighbour */\n\tmergeRegionArea: number\n\t/** The most vertices a polygon of the navigation mesh has */\n\tmaxVertsPerPoly: number\n\t/** How far apart the points are where the mesh's height is sampled */\n\tdetailSampleDist: number\n\t/** The most the mesh's height may differ from the ground between sampled points */\n\tdetailSampleMaxError: number\n\t/** How many layers of walkable space a tile is expected to have, for the tile cache's size */\n\texpectedLayersPerTile: number\n\t/** How many obstacles (buildings, shut gates) the tile cache has room for */\n\tmaxObstacles: number\n}\n\n/**\n * What a navigation is built from: the ground's (or the water's) triangles, and how to cut them. Plain data, sent to a worker as it is\n *\n * @beta\n */\nexport interface NavigationBuild {\n\t/** The ground's triangles as x, y, z triples, three vertices to a triangle */\n\tpositions: Float32Array\n\t/** The triangles as indices into `positions` */\n\tindices: Uint32Array\n\t/** How the triangles are cut */\n\tconfig: NavigationBuildConfig\n\t/**\n\t * How fast one on foot goes over each cell of the ground (`groundSpeedOfCell`), for a path to weigh: none where every\n\t * cell is 1, which cuts the ground as it always was\n\t */\n\tspeeds?: NavigationSpeeds\n}\n\n/**\n * Each cell's speed on the ground, row by row (`NavigationBuild.speeds`)\n *\n * @beta\n */\nexport interface NavigationSpeeds {\n\t/** The width of the speed grid in cells */\n\twidth: number\n\t/** The depth of the speed grid in cells */\n\tdepth: number\n\t/** The speed over each cell, a multiplier where 1 is the ground's ordinary pace */\n\tvalues: Float32Array\n}\n\n/**\n * What builds a navigation: given what to build, gives back what was built (Recast's tile cache, exported). On this\n * thread (`buildNavigationData`), or in a worker (`navigationWorker`)\n *\n * @beta\n */\nexport type NavigationBuilder = (build: NavigationBuild) => Promise<Uint8Array>\n\n/**\n * Where what was built is kept, by a hash of what it was built from: in memory when nothing else is said\n * (`memoryNavigationCache`). A game keeps it elsewhere with one of its own (the browser's storage, a file)\n *\n * @beta\n */\nexport interface NavigationCache {\n\t/** Gives what was built under the key, or undefined when nothing was; may answer later */\n\tget(key: string): Uint8Array | undefined | Promise<Uint8Array | undefined>\n\t/** Keeps what was built under the key */\n\tset(key: string, data: Uint8Array): void | Promise<void>\n}\n\nlet initialized: Promise<void> | undefined\n\n/** Recast's WebAssembly, once for each thread */\nexport const initRecast = (): Promise<void> => (initialized ??= init())\n\n/**\n * Builds a navigation on this thread, and gives back what was built: what a worker does too\n *\n * @beta\n */\nexport async function buildNavigationData(build: NavigationBuild): Promise<Uint8Array> {\n\tawait initRecast()\n\treturn buildNavigationNow(build)\n}\n\n/**\n * Builds a navigation on this thread at once, Recast's WebAssembly there already (`initRecast`): a navigation made\n * again in the middle of a tick, its ground reshaped (`RecastNavigation.reshape`)\n *\n * @internal\n */\nexport function buildNavigationNow(build: NavigationBuild): Uint8Array {\n\t// slow ground marked as it is cut (EN2); ground without any, as Recast cuts it\n\tif (build.speeds) {\n\t\tconst { navMesh, tileCache } = generateGroundTileCache(build)\n\t\ttry {\n\t\t\treturn exportTileCache(navMesh, tileCache)\n\t\t} finally {\n\t\t\ttileCache.destroy()\n\t\t\tnavMesh.destroy()\n\t\t}\n\t}\n\tconst result = generateTileCache(build.positions, build.indices, build.config)\n\tif (!result.success) throw new Error(`Navmesh generation failed: ${result.error}`)\n\tconst { navMesh, tileCache } = result\n\ttry {\n\t\treturn exportTileCache(navMesh, tileCache)\n\t} finally {\n\t\ttileCache.destroy()\n\t\tnavMesh.destroy()\n\t}\n}\n\n/**\n * Kept in memory, the last built first, up to `maxBytes` of them (64 MB when left out): a map of 512 cells a side is\n * under a megabyte\n *\n * @beta\n */\nexport function memoryNavigationCache(maxBytes = 64 * 1024 * 1024): NavigationCache {\n\tconst kept = new Map<string, Uint8Array>()\n\tlet bytes = 0\n\treturn {\n\t\tget(key) {\n\t\t\tconst data = kept.get(key)\n\t\t\tif (!data) return undefined\n\t\t\t// used: the last to go\n\t\t\tkept.delete(key)\n\t\t\tkept.set(key, data)\n\t\t\treturn data\n\t\t},\n\t\tset(key, data) {\n\t\t\tconst before = kept.get(key)\n\t\t\tif (before) bytes -= before.byteLength\n\t\t\tkept.delete(key)\n\t\t\tkept.set(key, data)\n\t\t\tbytes += data.byteLength\n\t\t\tfor (const [old, value] of kept) {\n\t\t\t\tif (bytes <= maxBytes || old === key) break\n\t\t\t\tkept.delete(old)\n\t\t\t\tbytes -= value.byteLength\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * The key of a build: a hash of the triangles and of how they are cut. Two builds of the same key make the same\n * navigation\n *\n * @internal\n */\nexport function navigationKey(build: NavigationBuild): string {\n\t// FNV-1a over the words, twice over with different starts, for 64 bits: enough to tell grounds apart, not a secret\n\tlet a = 0x811c9dc5\n\tlet b = 0x01000193 ^ 0x5bd1e995\n\tconst mix = (word: number) => {\n\t\ta = Math.imul(a ^ word, 0x01000193)\n\t\tb = Math.imul(b ^ word, 0x5bd1e995)\n\t}\n\tconst positions = new Uint32Array(build.positions.buffer, build.positions.byteOffset, build.positions.length)\n\tfor (let i = 0; i < positions.length; i++) mix(positions[i])\n\tmix(0xffffffff)\n\tfor (let i = 0; i < build.indices.length; i++) mix(build.indices[i])\n\tconst config = JSON.stringify(build.config, Object.keys(build.config).sort())\n\tfor (let i = 0; i < config.length; i++) mix(config.charCodeAt(i))\n\t// the paint's speeds too, where there are any: a build of none is keyed as one always was\n\tif (build.speeds) {\n\t\tmix(0xfffffffe)\n\t\tmix(build.speeds.width)\n\t\tconst speeds = new Uint32Array(build.speeds.values.buffer, build.speeds.values.byteOffset, build.speeds.values.length)\n\t\t// each word stirred first: FNV a word at a time carries a change of a word's high bits into the high bits alone, so\n\t\t// that speeds that differ only there (1 and -1, which stops one on foot) came to the same key, two cells apart\n\t\tfor (let i = 0; i < speeds.length; i++) {\n\t\t\tlet word = speeds[i]\n\t\t\tword = Math.imul(word ^ (word >>> 16), 0x85ebca6b)\n\t\t\tword = Math.imul(word ^ (word >>> 13), 0xc2b2ae35)\n\t\t\tmix((word ^ (word >>> 16)) >>> 0)\n\t\t}\n\t}\n\treturn `${(a >>> 0).toString(16).padStart(8, '0')}${(b >>> 0).toString(16).padStart(8, '0')}-${positions.length}`\n}\n\n/**\n * What a worker is, as far as building goes: a page's `Worker`, or Node's `worker_threads` one\n *\n * @beta\n */\nexport interface NavigationWorkerLike {\n\t/** Sends the worker a message; `transfer` lists the buffers handed over rather than copied */\n\tpostMessage(message: unknown, transfer?: unknown[]): void\n\t/** Listens for the worker's `message` and `error`, as a page's worker does */\n\taddEventListener?(type: 'message' | 'error', listener: (event: { data?: unknown; message?: string }) => void): void\n\t/** Listens for the worker's `message` and `error`, as Node's `worker_threads` worker does */\n\ton?(type: 'message' | 'error', listener: (value: unknown) => void): void\n}\n\n/** How many workers a page's builder makes at most: three, or one fewer than the machine's threads where that is less */\nfunction defaultWorkers(): number {\n\tconst threads = (globalThis as { navigator?: { hardwareConcurrency?: number } }).navigator?.hardwareConcurrency ?? 2\n\treturn Math.min(3, Math.max(1, threads - 1))\n}\n\ninterface BuildAnswer {\n\tid: number\n\tdata?: Uint8Array\n\terror?: string\n}\n\n/**\n * A builder that builds in a worker: one whose file serves builds (`serveNavigationBuilds`). In a page, the page makes\n * the worker, as its bundler wants it: the library makes no worker of its own there.\n *\n * A worker's file of two lines (`serveNavigationBuilds` imported from the engine, and called), and the page:\n * `navigationWorker(() => new Worker(new URL('./navigation.worker.ts', import.meta.url), { type: 'module' }))`, the\n * builder of every world it makes (`NavigationBuilds`).\n * Given as a function, the worker is made at the first build: a page whose menu builds nothing fetches none of it\n * until a world is made (OF2); given made, it is used as it is. Given as a function, as many as `workers` are made as\n * builds are asked at once (a world's navigations, one for each size of unit, the water's, each side's: built side by\n * side, the Well's four in the time of its longest), each build to the one with the fewest under way\n *\n * @beta\n */\nexport function navigationWorker(given: NavigationWorkerLike | (() => NavigationWorkerLike), workers = defaultWorkers()): NavigationBuilder {\n\tlet next = 0\n\tconst waiting = new Map<number, { done: (data: Uint8Array) => void; failed: (error: Error) => void; by: Hired }>()\n\tinterface Hired {\n\t\tworker: NavigationWorkerLike\n\t\tbusy: number\n\t}\n\tconst answered = (answer: BuildAnswer) => {\n\t\tconst wait = waiting.get(answer.id)\n\t\tif (!wait) return\n\t\twaiting.delete(answer.id)\n\t\twait.by.busy--\n\t\tif (answer.data) wait.done(answer.data)\n\t\telse wait.failed(new Error(answer.error ?? 'The navigation could not be built'))\n\t}\n\tconst broke = (hired: Hired, error: unknown) => {\n\t\tconst reason = new Error(\n\t\t\t`The navigation's worker stopped: ${error instanceof Error ? error.message : String((error as { message?: string })?.message ?? error)}`\n\t\t)\n\t\t// what that worker was building: the others go on\n\t\tfor (const [id, wait] of waiting)\n\t\t\tif (wait.by === hired) {\n\t\t\t\twaiting.delete(id)\n\t\t\t\twait.failed(reason)\n\t\t\t}\n\t\thired.busy = 0\n\t}\n\tconst hired: Hired[] = []\n\tconst hire = (worker: NavigationWorkerLike) => {\n\t\tconst one: Hired = { worker, busy: 0 }\n\t\tif (worker.on) {\n\t\t\tworker.on('message', (value) => answered(value as BuildAnswer))\n\t\t\tworker.on('error', (error) => broke(one, error))\n\t\t} else {\n\t\t\tworker.addEventListener?.('message', (event) => answered(event.data as BuildAnswer))\n\t\t\tworker.addEventListener?.('error', (error) => broke(one, error))\n\t\t}\n\t\thired.push(one)\n\t\treturn one\n\t}\n\t// the one with the fewest builds under way; another made while each has some and there may be more\n\tconst worker = (): Hired => {\n\t\tconst idle = hired.reduce<Hired | undefined>((best, each) => (!best || each.busy < best.busy ? each : best), undefined)\n\t\tif (idle && (idle.busy === 0 || typeof given !== 'function' || hired.length >= Math.max(1, workers))) return idle\n\t\treturn hire(typeof given === 'function' ? given() : given)\n\t}\n\t// a worker given made is listened to now; one given as what makes it is made at the first build\n\tif (typeof given !== 'function') hire(given)\n\treturn (build) =>\n\t\tnew Promise<Uint8Array>((done, failed) => {\n\t\t\tconst id = ++next\n\t\t\tconst by = worker()\n\t\t\tby.busy++\n\t\t\twaiting.set(id, { done, failed, by })\n\t\t\t// copies: the triangles are the terrain's, and stay where they are\n\t\t\tby.worker.postMessage({\n\t\t\t\tid,\n\t\t\t\tbuild: {\n\t\t\t\t\tpositions: build.positions.slice(),\n\t\t\t\t\tindices: build.indices.slice(),\n\t\t\t\t\tconfig: build.config,\n\t\t\t\t\t...(build.speeds && { speeds: { ...build.speeds, values: build.speeds.values.slice() } })\n\t\t\t\t}\n\t\t\t})\n\t\t})\n}\n\n/**\n * Where a worker hears and answers: a page's worker scope, or Node's `parentPort`\n *\n * @beta\n */\nexport interface NavigationPort {\n\t/** Sends a message back to whoever started the worker; `transfer` lists the buffers handed over */\n\tpostMessage(message: unknown, transfer?: unknown[]): void\n\t/** Listens for the messages sent to the worker, as a page's worker scope does */\n\taddEventListener?(type: 'message', listener: (event: { data: unknown }) => void): void\n\t/** Listens for the messages sent to the worker, as Node's `parentPort` does */\n\ton?(type: 'message', listener: (value: unknown) => void): void\n}\n\n/**\n * What a navigation worker's file does: it builds what it is sent and sends back what it built. `port` is where it\n * hears: the worker's own scope when left out (a page's worker)\n *\n * @beta\n */\nexport function serveNavigationBuilds(port: NavigationPort = globalThis as unknown as NavigationPort): void {\n\tconst asked = async (message: unknown) => {\n\t\tconst { id, build } = message as { id: number; build: NavigationBuild }\n\t\ttry {\n\t\t\tconst data = await buildNavigationData(build)\n\t\t\tport.postMessage({ id, data } satisfies BuildAnswer, [data.buffer])\n\t\t} catch (error) {\n\t\t\tport.postMessage({ id, error: error instanceof Error ? error.message : String(error) } satisfies BuildAnswer)\n\t\t}\n\t}\n\tif (port.on) port.on('message', (value) => void asked(value))\n\telse port.addEventListener?.('message', (event) => void asked(event.data))\n}\n\n/**\n * Who builds a world's navigations and where what was built is kept (`CreateWorldOptions.navigation.builds`): this\n * thread when the builder is left out (a worker of the page's own: `navigationWorker`), the process's memory when the\n * cache is, `cache: null` for nowhere (every world built anew). What an app hands every world it makes (`launch`,\n * `startApp`, `GameServer.start`)\n *\n * @beta\n */\nexport interface NavigationBuilds {\n\t/** Builds a navigation on this thread, or somewhere else when set to a worker's; this thread when left out */\n\tbuilder?: NavigationBuilder\n\t/** Where what was built is kept between worlds; the process's memory when left out, nowhere for `null` */\n\tcache?: NavigationCache | null\n}\n\n/** Where a world says nothing: this thread, and kept in the process's memory, which every world's ground may read */\nconst defaults: { readonly builder: NavigationBuilder; readonly cache: NavigationCache } = {\n\tbuilder: buildNavigationData,\n\tcache: memoryNavigationCache()\n}\n\n/**\n * What was built from this: kept, or built now (by the builder set) and kept. A builder that fails falls back to this\n * thread once, and says why in what it throws only when that fails too\n */\nexport async function navigationData(build: NavigationBuild, using: NavigationBuilds = {}): Promise<Uint8Array> {\n\t// `using`: who builds this one and where it is kept (a page's worker, a game's worker asked by its page: S54)\n\tconst cache = using.cache !== undefined ? using.cache : defaults.cache\n\tconst builder = using.builder ?? defaults.builder\n\tconst key = cache ? navigationKey(build) : ''\n\t// the same ground asked again while it is built (each side's navigation, asked side by side): that build\n\tconst building = cache ? buildsOf(cache) : undefined\n\tconst under = building?.get(key)\n\tif (under) return under\n\tconst made = (async () => {\n\t\tconst kept = cache ? await cache.get(key) : undefined\n\t\tif (kept) return kept\n\t\tlet data: Uint8Array\n\t\ttry {\n\t\t\tdata = await builder(build)\n\t\t} catch (error) {\n\t\t\tif (builder === buildNavigationData) throw error\n\t\t\tdata = await buildNavigationData(build)\n\t\t}\n\t\tif (cache) await cache.set(key, data)\n\t\treturn data\n\t})()\n\tif (!building) return made\n\tbuilding.set(key, made)\n\ttry {\n\t\treturn await made\n\t} finally {\n\t\tbuilding.delete(key)\n\t}\n}\n\n/** The last of the works on this thread asked to go one after another (`inTurn`): settled once it is done */\nlet turn: Promise<unknown> = Promise.resolve()\n\n/**\n * Runs `work` once every work asked before it this way is done, failed or not: Recast's WebAssembly on this thread, a\n * navigation built and read before the next is built (`RecastNavigation.create`)\n *\n * @internal\n */\nexport function inTurn<T>(work: () => Promise<T>): Promise<T> {\n\tconst done = turn.then(work, work)\n\tturn = done.catch(() => undefined)\n\treturn done\n}\n\n/** The builds under way for what a cache keeps, by their key */\nconst underWay = new WeakMap<NavigationCache, Map<string, Promise<Uint8Array>>>()\nconst buildsOf = (cache: NavigationCache) => {\n\tlet builds = underWay.get(cache)\n\tif (!builds) underWay.set(cache, (builds = new Map()))\n\treturn builds\n}\n\n/**\n * What each makes, made side by side and given back in their order: where one fails, those the others made are freed\n * (WebAssembly memory) once all are settled, and the first failure is thrown\n *\n * @internal\n */\nexport async function allOrFreed<T extends { dispose(): void } | undefined>(makes: readonly (() => Promise<T>)[]): Promise<T[]> {\n\tconst settled = await Promise.allSettled(makes.map((make) => make()))\n\tconst failed = settled.find((each) => each.status === 'rejected')\n\tif (!failed) return settled.map((each) => (each as PromiseFulfilledResult<T>).value)\n\tfor (const each of settled) if (each.status === 'fulfilled') each.value?.dispose()\n\tthrow failed.reason\n}\n"],"mappings":";;;;AAuGA,IAAI;;AAGJ,IAAa,mBAAmC,gBAAgB,KAAK;;;;;;AAOrE,eAAsB,oBAAoB,OAA6C;CACtF,MAAM,WAAW;CACjB,OAAO,mBAAmB,KAAK;AAChC;;;;;;;AAQA,SAAgB,mBAAmB,OAAoC;CAEtE,IAAI,MAAM,QAAQ;EACjB,MAAM,EAAE,SAAS,cAAc,wBAAwB,KAAK;EAC5D,IAAI;GACH,OAAO,gBAAgB,SAAS,SAAS;EAC1C,UAAU;GACT,UAAU,QAAQ;GAClB,QAAQ,QAAQ;EACjB;CACD;CACA,MAAM,SAAS,kBAAkB,MAAM,WAAW,MAAM,SAAS,MAAM,MAAM;CAC7E,IAAI,CAAC,OAAO,SAAS,MAAM,IAAI,MAAM,8BAA8B,OAAO,OAAO;CACjF,MAAM,EAAE,SAAS,cAAc;CAC/B,IAAI;EACH,OAAO,gBAAgB,SAAS,SAAS;CAC1C,UAAU;EACT,UAAU,QAAQ;EAClB,QAAQ,QAAQ;CACjB;AACD;;;;;;;AAQA,SAAgB,sBAAsB,WAAW,UAAmC;CACnF,MAAM,uBAAO,IAAI,IAAwB;CACzC,IAAI,QAAQ;CACZ,OAAO;EACN,IAAI,KAAK;GACR,MAAM,OAAO,KAAK,IAAI,GAAG;GACzB,IAAI,CAAC,MAAM,OAAO,KAAA;GAElB,KAAK,OAAO,GAAG;GACf,KAAK,IAAI,KAAK,IAAI;GAClB,OAAO;EACR;EACA,IAAI,KAAK,MAAM;GACd,MAAM,SAAS,KAAK,IAAI,GAAG;GAC3B,IAAI,QAAQ,SAAS,OAAO;GAC5B,KAAK,OAAO,GAAG;GACf,KAAK,IAAI,KAAK,IAAI;GAClB,SAAS,KAAK;GACd,KAAK,MAAM,CAAC,KAAK,UAAU,MAAM;IAChC,IAAI,SAAS,YAAY,QAAQ,KAAK;IACtC,KAAK,OAAO,GAAG;IACf,SAAS,MAAM;GAChB;EACD;CACD;AACD;;;;;;;AAQA,SAAgB,cAAc,OAAgC;CAE7D,IAAI,IAAI;CACR,IAAI,IAAI;CACR,MAAM,OAAO,SAAiB;EAC7B,IAAI,KAAK,KAAK,IAAI,MAAM,QAAU;EAClC,IAAI,KAAK,KAAK,IAAI,MAAM,UAAU;CACnC;CACA,MAAM,YAAY,IAAI,YAAY,MAAM,UAAU,QAAQ,MAAM,UAAU,YAAY,MAAM,UAAU,MAAM;CAC5G,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,IAAI,UAAU,EAAE;CAC3D,IAAI,UAAU;CACd,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,QAAQ,KAAK,IAAI,MAAM,QAAQ,EAAE;CACnE,MAAM,SAAS,KAAK,UAAU,MAAM,QAAQ,OAAO,KAAK,MAAM,MAAM,CAAC,CAAC,KAAK,CAAC;CAC5E,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,IAAI,OAAO,WAAW,CAAC,CAAC;CAEhE,IAAI,MAAM,QAAQ;EACjB,IAAI,UAAU;EACd,IAAI,MAAM,OAAO,KAAK;EACtB,MAAM,SAAS,IAAI,YAAY,MAAM,OAAO,OAAO,QAAQ,MAAM,OAAO,OAAO,YAAY,MAAM,OAAO,OAAO,MAAM;EAGrH,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;GACvC,IAAI,OAAO,OAAO;GAClB,OAAO,KAAK,KAAK,OAAQ,SAAS,IAAK,UAAU;GACjD,OAAO,KAAK,KAAK,OAAQ,SAAS,IAAK,UAAU;GACjD,KAAK,OAAQ,SAAS,QAAS,CAAC;EACjC;CACD;CACA,OAAO,IAAI,MAAM,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,KAAK,MAAM,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,EAAE,GAAG,UAAU;AAC1G;;AAiBA,SAAS,iBAAyB;CACjC,MAAM,UAAW,WAAgE,WAAW,uBAAuB;CACnH,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,CAAC,CAAC;AAC5C;;;;;;;;;;;;;;;AAsBA,SAAgB,iBAAiB,OAA4D,UAAU,eAAe,GAAsB;CAC3I,IAAI,OAAO;CACX,MAAM,0BAAU,IAAI,IAA6F;CAKjH,MAAM,YAAY,WAAwB;EACzC,MAAM,OAAO,QAAQ,IAAI,OAAO,EAAE;EAClC,IAAI,CAAC,MAAM;EACX,QAAQ,OAAO,OAAO,EAAE;EACxB,KAAK,GAAG;EACR,IAAI,OAAO,MAAM,KAAK,KAAK,OAAO,IAAI;OACjC,KAAK,OAAO,IAAI,MAAM,OAAO,SAAS,mCAAmC,CAAC;CAChF;CACA,MAAM,SAAS,OAAc,UAAmB;EAC/C,MAAM,yBAAS,IAAI,MAClB,oCAAoC,iBAAiB,QAAQ,MAAM,UAAU,OAAQ,OAAgC,WAAW,KAAK,GACtI;EAEA,KAAK,MAAM,CAAC,IAAI,SAAS,SACxB,IAAI,KAAK,OAAO,OAAO;GACtB,QAAQ,OAAO,EAAE;GACjB,KAAK,OAAO,MAAM;EACnB;EACD,MAAM,OAAO;CACd;CACA,MAAM,QAAiB,CAAC;CACxB,MAAM,QAAQ,WAAiC;EAC9C,MAAM,MAAa;GAAE;GAAQ,MAAM;EAAE;EACrC,IAAI,OAAO,IAAI;GACd,OAAO,GAAG,YAAY,UAAU,SAAS,KAAoB,CAAC;GAC9D,OAAO,GAAG,UAAU,UAAU,MAAM,KAAK,KAAK,CAAC;EAChD,OAAO;GACN,OAAO,mBAAmB,YAAY,UAAU,SAAS,MAAM,IAAmB,CAAC;GACnF,OAAO,mBAAmB,UAAU,UAAU,MAAM,KAAK,KAAK,CAAC;EAChE;EACA,MAAM,KAAK,GAAG;EACd,OAAO;CACR;CAEA,MAAM,eAAsB;EAC3B,MAAM,OAAO,MAAM,QAA2B,MAAM,SAAU,CAAC,QAAQ,KAAK,OAAO,KAAK,OAAO,OAAO,MAAO,KAAA,CAAS;EACtH,IAAI,SAAS,KAAK,SAAS,KAAK,OAAO,UAAU,cAAc,MAAM,UAAU,KAAK,IAAI,GAAG,OAAO,IAAI,OAAO;EAC7G,OAAO,KAAK,OAAO,UAAU,aAAa,MAAM,IAAI,KAAK;CAC1D;CAEA,IAAI,OAAO,UAAU,YAAY,KAAK,KAAK;CAC3C,QAAQ,UACP,IAAI,SAAqB,MAAM,WAAW;EACzC,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,OAAO;EAClB,GAAG;EACH,QAAQ,IAAI,IAAI;GAAE;GAAM;GAAQ;EAAG,CAAC;EAEpC,GAAG,OAAO,YAAY;GACrB;GACA,OAAO;IACN,WAAW,MAAM,UAAU,MAAM;IACjC,SAAS,MAAM,QAAQ,MAAM;IAC7B,QAAQ,MAAM;IACd,GAAI,MAAM,UAAU,EAAE,QAAQ;KAAE,GAAG,MAAM;KAAQ,QAAQ,MAAM,OAAO,OAAO,MAAM;IAAE,EAAE;GACxF;EACD,CAAC;CACF,CAAC;AACH;;;;;;;AAsBA,SAAgB,sBAAsB,OAAuB,YAA+C;CAC3G,MAAM,QAAQ,OAAO,YAAqB;EACzC,MAAM,EAAE,IAAI,UAAU;EACtB,IAAI;GACH,MAAM,OAAO,MAAM,oBAAoB,KAAK;GAC5C,KAAK,YAAY;IAAE;IAAI;GAAK,GAAyB,CAAC,KAAK,MAAM,CAAC;EACnE,SAAS,OAAO;GACf,KAAK,YAAY;IAAE;IAAI,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;GAAE,CAAuB;EAC7G;CACD;CACA,IAAI,KAAK,IAAI,KAAK,GAAG,YAAY,UAAU,KAAK,MAAM,KAAK,CAAC;MACvD,KAAK,mBAAmB,YAAY,UAAU,KAAK,MAAM,MAAM,IAAI,CAAC;AAC1E;;AAkBA,IAAM,WAAqF;CAC1F,SAAS;CACT,OAAO,sBAAsB;AAC9B;;;;;AAMA,eAAsB,eAAe,OAAwB,QAA0B,CAAC,GAAwB;CAE/G,MAAM,QAAQ,MAAM,UAAU,KAAA,IAAY,MAAM,QAAQ,SAAS;CACjE,MAAM,UAAU,MAAM,WAAW,SAAS;CAC1C,MAAM,MAAM,QAAQ,cAAc,KAAK,IAAI;CAE3C,MAAM,WAAW,QAAQ,SAAS,KAAK,IAAI,KAAA;CAC3C,MAAM,QAAQ,UAAU,IAAI,GAAG;CAC/B,IAAI,OAAO,OAAO;CAClB,MAAM,QAAQ,YAAY;EACzB,MAAM,OAAO,QAAQ,MAAM,MAAM,IAAI,GAAG,IAAI,KAAA;EAC5C,IAAI,MAAM,OAAO;EACjB,IAAI;EACJ,IAAI;GACH,OAAO,MAAM,QAAQ,KAAK;EAC3B,SAAS,OAAO;GACf,IAAI,YAAY,qBAAqB,MAAM;GAC3C,OAAO,MAAM,oBAAoB,KAAK;EACvC;EACA,IAAI,OAAO,MAAM,MAAM,IAAI,KAAK,IAAI;EACpC,OAAO;CACR,EAAA,CAAG;CACH,IAAI,CAAC,UAAU,OAAO;CACtB,SAAS,IAAI,KAAK,IAAI;CACtB,IAAI;EACH,OAAO,MAAM;CACd,UAAU;EACT,SAAS,OAAO,GAAG;CACpB;AACD;;AAGA,IAAI,OAAyB,QAAQ,QAAQ;;;;;;;AAQ7C,SAAgB,OAAU,MAAoC;CAC7D,MAAM,OAAO,KAAK,KAAK,MAAM,IAAI;CACjC,OAAO,KAAK,YAAY,KAAA,CAAS;CACjC,OAAO;AACR;;AAGA,IAAM,2BAAW,IAAI,QAA2D;AAChF,IAAM,YAAY,UAA2B;CAC5C,IAAI,SAAS,SAAS,IAAI,KAAK;CAC/B,IAAI,CAAC,QAAQ,SAAS,IAAI,OAAQ,yBAAS,IAAI,IAAI,CAAE;CACrD,OAAO;AACR;;;;;;;AAQA,eAAsB,WAAsD,OAAoD;CAC/H,MAAM,UAAU,MAAM,QAAQ,WAAW,MAAM,KAAK,SAAS,KAAK,CAAC,CAAC;CACpE,MAAM,SAAS,QAAQ,MAAM,SAAS,KAAK,WAAW,UAAU;CAChE,IAAI,CAAC,QAAQ,OAAO,QAAQ,KAAK,SAAU,KAAmC,KAAK;CACnF,KAAK,MAAM,QAAQ,SAAS,IAAI,KAAK,WAAW,aAAa,KAAK,OAAO,QAAQ;CACjF,MAAM,OAAO;AACd"}

package/dist/navigation/groundAreas.d.ts

@@ -1,4 +1,4 @@
-import { NavMesh, type QueryFilter, TileCache, TileCacheMeshProcess } from '@recast-navigation/core';
+import { createRcConfig, NavMesh, type QueryFilter, Raw, TileCache, TileCacheData, TileCacheMeshProcess } from '@recast-navigation/core';
 import type { NavigationBuild, NavigationSpeeds } from './builds';
 /** The area of ground of this speed: 0 for ordinary ground, else its speed in sixteenths, 1 at the least and 62 at the most */
 export declare function areaOfSpeed(speed: number): number;
@@ -11,6 +11,17 @@ export declare function speedOfBuild(speeds: NavigationSpeeds | undefined, x: nu
  * under its middle (`speedAt`). Without one, every polygon is ordinary ground, as Recast's default makes them
  */
 export declare function groundMeshProcess(speedAt?: (x: number, z: number) => number): TileCacheMeshProcess;
+/** How a build is cut into tiles: Recast's config for one tile with its border, the bounds of the whole, the grid of tiles */
+export interface TileCut {
+    config: ReturnType<typeof createRcConfig>;
+    bbMin: [number, number, number];
+    bbMax: [number, number, number];
+    /** Tiles across and down */
+    tileWidth: number;
+    tileHeight: number;
+    expectedLayersPerTile: number;
+    maxObstacles: number;
+}
 /**
  * Builds a tile cache and its navmesh from a build, as Recast's `generateTileCache` does, but with each triangle of the
  * ground marked with its cell's speed (`NavigationBuild.speeds`) before it is rasterised. What it gives is Recast's own;
@@ -21,3 +32,50 @@ export declare function generateGroundTileCache(build: NavigationBuild): {
     tileCache: TileCache;
     process: TileCacheMeshProcess;
 };
+/** A tile of the grid by its column and row: `tx * 65536 + ty` */
+export declare const tileKey: (tx: number, ty: number) => number;
+/**
+ * Some tiles of a build made again (`RecastNavigation.reshape`): each tile's compressed layers, made as
+ * `generateGroundTileCache` makes them, from the triangles that reach it. Also the bounds of the whole build, for the
+ * caller to know the tiles are cut on the grid it has (a build of other bounds is cut on another). `speedOf` is the speed
+ * of the ground at a point where the build has no speeds of its own (a part of the ground, `RecastNavigation.groundChanged`).
+ * Undefined where they could not be made
+ */
+export declare function groundTileLayers(build: NavigationBuild, tiles: readonly number[], cut?: TileCut, speedOf?: (x: number, z: number) => number): Map<number, Uint8Array[]> | undefined;
+/**
+ * The grid a build is cut on: its bounds and its tiles across and down. A build of the same grid as another's is cut
+ * into the same tiles, so a tile of one may be made again alone from the other (`groundTileLayers`)
+ */
+export declare function tileGridOf(build: NavigationBuild): {
+    bbMin: readonly number[];
+    bbMax: readonly number[];
+    tileWidth: number;
+    tileHeight: number;
+    /** A tile's side, in ground units */
+    tileSize: number;
+    /** How far round a tile the ground it is made of reaches, in ground units */
+    border: number;
+    /** The whole of how it is cut, for `groundTileLayers` and `emptyTileCache` not to work it out again */
+    cut: TileCut;
+};
+/**
+ * A tile cache of the grid a build is cut on (`tileGridOf`), empty, with room for `room`'s tiles and obstacles: what
+ * a column of tiles made again alone is made into the navmesh's tiles through (`RecastNavigation.groundChanged`,
+ * `reshape`), as the whole's tile cache would make them. It works in the allocator and compressor given (the whole's:
+ * a tile is made in one call, and each starts the allocator over), which it does not take. Undefined where Recast
+ * would not make it
+ */
+export declare function columnTileCache(cut: TileCut, process: TileCacheMeshProcess, room: {
+    tiles: number;
+    obstacles: number;
+}, allocator: InstanceType<typeof Raw.RecastLinearAllocator>, compressor: InstanceType<typeof Raw.RecastFastLZCompressor>): TileCache | undefined;
+/**
+ * Puts a compressed layer (`groundTileLayers`) in a tile cache, which does not take it: its copy is given back, to be let
+ * go of (`destroy`) once the tile cache is. Undefined where the tile cache would not take it
+ */
+export declare function addTileLayer(tileCache: TileCache, bytes: Uint8Array): InstanceType<typeof TileCacheData> | undefined;
+/**
+ * Which layer of its column a compressed layer (`groundTileLayers`) is: the navmesh's tile made of it is at that layer.
+ * Its header (Detour's `dtTileCacheLayerHeader`) leads it uncompressed: magic, version, tx, ty, then the layer, each an int
+ */
+export declare const layerOf: (bytes: Uint8Array) => number;