gps-plus-slam-app-framework 1.11.0 → 1.14.0

package/dist/occupancy-mesher-DzNeJdQf.js

@@ -0,0 +1,837 @@
+import { n as CELL_KEY_STRIDE_X, r as CELL_KEY_STRIDE_Y, s as packCellKey } from "./cell-key-D1b_Ix-p.js";
+//#region ../src/ar/packed-key-hash.ts
+/**
+* Open-addressed hash map for packed cell keys — the mesher hot-loop
+* replacement for `Map<number, number>` / `Set<number>`.
+*
+* WHY (2026-07-17 perf loop, iteration 2): profiling the production-default
+* 'smooth' surface-nets mesher showed ~65% of its time inside Map/Set
+* operations keyed by packed cell keys (occupied-membership tests, dual-vertex
+* welding, centroid memo). This flat typed-array table answers the same
+* lookups without per-entry heap boxes or hash-object overhead — together
+* with the smooth builder's ordinal/incremental-key rewrite it took the
+* production re-mesh (`runMeshRequest`, 100k-cell corpus regime) from 331 to
+* 101 ms, −69% (byte-identical output, see occupancy-mesher.ts.md).
+*
+* CONTRACT (deliberately narrow — this is a fast path, not a general map):
+* - Keys: non-negative finite numbers ≤ 2^53 (packed cell keys are ≤ ~2^51).
+*   `-1` is the internal empty sentinel, so negative keys are unsupported.
+* - Values: integers ≥ 0 (Int32). `get` returns `-1` for absent keys — the
+*   caller-friendly miss signal that avoids an `undefined` check in hot loops.
+*   Storing a negative value throws (it would read back as a miss).
+* - No delete (the mesher builds tables once per mesh and drops them).
+*
+* Implementation: linear probing over power-of-two capacity, grown at ~2/3
+* load by rehashing (growth is CORRECTNESS, not tuning — a full table would
+* probe forever). The 51-bit key is mixed to 32 bits via lo³²⊕hi²¹ and a
+* golden-ratio `Math.imul` spread; packed keys are highly structured
+* (base-2^17 positional), and the multiplicative mix breaks that structure —
+* verified by the property test driving adjacent-coordinate workloads.
+*
+* @see packed-key-hash.ts.md for detailed documentation
+*/
+const EMPTY = -1;
+const TWO_32 = 4294967296;
+var PackedKeyHash = class {
+	keys;
+	vals;
+	mask;
+	used = 0;
+	/** Grow when `used` exceeds this (2/3 of capacity). */
+	growAt;
+	/**
+	* @param expectedEntries sizing hint — the table starts at the next power
+	*   of two ≥ 2× the hint (≥ 16) and grows transparently beyond it.
+	*/
+	constructor(expectedEntries) {
+		let cap = 16;
+		const target = Math.max(0, expectedEntries) * 2;
+		while (cap < target) cap *= 2;
+		this.keys = new Float64Array(cap).fill(EMPTY);
+		this.vals = new Int32Array(cap);
+		this.mask = cap - 1;
+		this.growAt = cap * 2 / 3;
+	}
+	/** Number of distinct keys stored. */
+	get size() {
+		return this.used;
+	}
+	/** The slot holding `key`, or the empty slot where it would be inserted. */
+	slot(key) {
+		const hi = Math.floor(key / TWO_32);
+		let h = key - hi * TWO_32 ^ Math.imul(hi, 2654435761);
+		h ^= h >>> 16;
+		h = Math.imul(h, 2246822507);
+		h ^= h >>> 13;
+		h = Math.imul(h, 3266489909);
+		h ^= h >>> 16;
+		let i = h >>> 0 & this.mask;
+		const keys = this.keys;
+		while (keys[i] !== EMPTY && keys[i] !== key) i = i + 1 & this.mask;
+		return i;
+	}
+	/** Value stored for `key`, or -1 when absent. */
+	get(key) {
+		const i = this.slot(key);
+		return this.keys[i] === key ? this.vals[i] : -1;
+	}
+	/** True iff `key` is stored. */
+	has(key) {
+		return this.keys[this.slot(key)] === key;
+	}
+	/** Insert or overwrite. `value` must be an integer ≥ 0 (see contract). */
+	set(key, value) {
+		if (value < 0) throw new RangeError(`PackedKeyHash values must be ≥ 0 (got ${value}); -1 is the miss sentinel`);
+		const i = this.slot(key);
+		if (this.keys[i] === EMPTY) {
+			if (this.used >= this.growAt) {
+				this.grow();
+				this.setPresized(key, value);
+				return;
+			}
+			this.used++;
+		}
+		this.keys[i] = key;
+		this.vals[i] = value;
+	}
+	/** `set` after `grow()` — capacity is guaranteed, no growth check needed. */
+	setPresized(key, value) {
+		const i = this.slot(key);
+		if (this.keys[i] === EMPTY) this.used++;
+		this.keys[i] = key;
+		this.vals[i] = value;
+	}
+	grow() {
+		const oldKeys = this.keys;
+		const oldVals = this.vals;
+		const cap = (this.mask + 1) * 2;
+		this.keys = new Float64Array(cap).fill(EMPTY);
+		this.vals = new Int32Array(cap);
+		this.mask = cap - 1;
+		this.growAt = cap * 2 / 3;
+		this.used = 0;
+		for (let i = 0; i < oldKeys.length; i++) {
+			const k = oldKeys[i];
+			if (k !== EMPTY) this.setPresized(k, oldVals[i]);
+		}
+	}
+};
+//#endregion
+//#region ../src/ar/occupancy-mesher.ts
+/** Resolve the effective mesher mode from the options. */
+function resolveMode(options) {
+	return options?.mode ?? "per-face";
+}
+/**
+* Right-handed cyclic axis assignment per face-normal axis `d`: `(d, u, v)`
+* with `eu × ev = ed`, so a `(uMin,vMin)→(uMax,vMin)→(uMax,vMax)→(uMin,vMax)`
+* quad has the `+d` outward normal (and the reverse order has `−d`). Used by the
+* greedy mesher to keep merged-quad winding consistent with the per-face path.
+*/
+const GREEDY_DIRS = [
+	{
+		d: 0,
+		u: 1,
+		v: 2
+	},
+	{
+		d: 1,
+		u: 2,
+		v: 0
+	},
+	{
+		d: 2,
+		u: 0,
+		v: 1
+	}
+];
+/**
+* The six cube faces with outward (CCW-from-outside) winding. Corner signs are
+* ±1 multipliers of the half-cell extent. Triangulated as (0,1,2)+(0,2,3).
+*/
+const FACES = [
+	{
+		neighbour: [
+			1,
+			0,
+			0
+		],
+		corners: [
+			[
+				1,
+				-1,
+				-1
+			],
+			[
+				1,
+				1,
+				-1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				-1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			-1,
+			0,
+			0
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				-1,
+				-1,
+				1
+			],
+			[
+				-1,
+				1,
+				1
+			],
+			[
+				-1,
+				1,
+				-1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			1,
+			0
+		],
+		corners: [
+			[
+				-1,
+				1,
+				-1
+			],
+			[
+				-1,
+				1,
+				1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				1,
+				-1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			-1,
+			0
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				1,
+				-1,
+				-1
+			],
+			[
+				1,
+				-1,
+				1
+			],
+			[
+				-1,
+				-1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			0,
+			1
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				1
+			],
+			[
+				1,
+				-1,
+				1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				-1,
+				1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			0,
+			-1
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				-1,
+				1,
+				-1
+			],
+			[
+				1,
+				1,
+				-1
+			],
+			[
+				1,
+				-1,
+				-1
+			]
+		]
+	}
+];
+/** Finite, integer, and within the packable key range on every axis.
+*  `Number.isInteger` subsumes the finiteness check (NaN/±Infinity are not
+*  integers) and rejects fractional coordinates, which the packed-key algebra
+*  cannot key safely (neighbour ±1 and half-lattice `2·coord ± 1` keys only
+*  coincide for integer cells). */
+function isPackableCell(cell) {
+	for (let i = 0; i < 3; i++) {
+		const c = cell[i];
+		if (!Number.isInteger(c) || Math.abs(c) > 32767) return false;
+	}
+	return true;
+}
+/** True iff all three components are finite. A non-finite measured centroid
+*  from `getCellPoint` (an upstream tracking/accumulation glitch) must degrade
+*  to the geometric fallback exactly like a `null` one — otherwise it poisons
+*  every welded vertex / shared corner that averages it, and it also breaks
+*  `runMeshRequest`'s byte-identical parity with a direct mesh (the worker wire
+*  protocol packs "no centroid" as NaN, so NaN already falls back off-thread). */
+function isFiniteVector3(v) {
+	return Number.isFinite(v[0]) && Number.isFinite(v[1]) && Number.isFinite(v[2]);
+}
+/**
+* Mesh a snapshot of occupied cells into a face-culled surface + AABB list.
+*
+* Only faces whose neighbour cell is **not** in the occupied set are emitted
+* (interior faces are dropped), so the triangle count scales with the surface
+* area of the occupied set. Duplicate cells in `cells` are de-duplicated;
+* cells with a non-finite or non-integer coordinate are skipped defensively (a
+* tracking glitch upstream must not poison the mesh, and the packed cell keys
+* are only collision-safe for integer coordinates).
+*
+* @param cells     occupied cells (e.g. `grid.getOccupiedCells(minConfidence)`).
+* @param cellSizeM cube edge length in metres (must be a positive finite number).
+* @returns positions/indices (raw-WebXR metres) + one AABB per unique cell.
+*/
+function meshOccupiedCells(cells, cellSizeM, options) {
+	if (!Number.isFinite(cellSizeM) || cellSizeM <= 0) throw new RangeError(`cellSizeM must be a positive number, got ${cellSizeM}`);
+	const half = cellSizeM / 2;
+	const mode = resolveMode(options);
+	const centroids = mode === "smooth" ? options?.centroids ?? null : null;
+	const occupied = new PackedKeyHash(Array.isArray(cells) ? cells.length : 64);
+	const uniqueCells = [];
+	const inputIndices = centroids ? [] : null;
+	let inputIndex = -1;
+	for (const cell of cells) {
+		inputIndex++;
+		if (!isPackableCell(cell)) continue;
+		const key = packCellKey(cell[0], cell[1], cell[2]);
+		if (occupied.has(key)) continue;
+		occupied.set(key, uniqueCells.length);
+		uniqueCells.push(cell);
+		inputIndices?.push(inputIndex);
+	}
+	const sharedHalfExtents = Object.freeze([
+		half,
+		half,
+		half
+	]);
+	const aabbs = options?.includeAabbs === false ? [] : uniqueCells.map(([x, y, z]) => ({
+		center: [
+			x * cellSizeM,
+			y * cellSizeM,
+			z * cellSizeM
+		],
+		halfExtents: sharedHalfExtents
+	}));
+	if (mode === "smooth") {
+		const geometry = buildSmooth(occupied, uniqueCells, cellSizeM, centroids ? resolveCellPointsFromCentroids(uniqueCells, inputIndices, centroids, cellSizeM) : resolveCellPoints(uniqueCells, cellSizeM, options?.getCellPoint));
+		return {
+			positions: geometry.positions,
+			indices: geometry.indices,
+			aabbs
+		};
+	}
+	const positions = [];
+	const indices = [];
+	if (mode === "greedy") buildGreedy(occupied, uniqueCells, cellSizeM, positions, indices);
+	else if (mode === "corner-fit") buildCornerFit(occupied, uniqueCells, cellSizeM, options?.getCellPoint, positions, indices);
+	else buildCulled(occupied, uniqueCells, cellSizeM, positions, indices);
+	return {
+		positions: new Float32Array(positions),
+		indices: new Uint32Array(indices),
+		aabbs
+	};
+}
+/** Push a quad (4 corners, already ordered) as two triangles. */
+/** Per-face culling: emit each exposed unit face as its own quad. */
+function buildCulled(occupied, uniqueCells, cellSizeM, positions, indices) {
+	const half = cellSizeM / 2;
+	for (const [x, y, z] of uniqueCells) {
+		const cx = x * cellSizeM;
+		const cy = y * cellSizeM;
+		const cz = z * cellSizeM;
+		for (const face of FACES) {
+			const nx = x + face.neighbour[0];
+			const ny = y + face.neighbour[1];
+			const nz = z + face.neighbour[2];
+			if (occupied.has(packCellKey(nx, ny, nz))) continue;
+			const base = positions.length / 3;
+			const corners = face.corners;
+			for (let i = 0; i < 4; i++) {
+				const c = corners[i];
+				positions.push(cx + c[0] * half, cy + c[1] * half, cz + c[2] * half);
+			}
+			indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+		}
+	}
+}
+/**
+* 'smooth' mode — **standard Naive Surface Nets (dual contouring)** over the
+* occupancy field, consuming the per-cell measured centroids the cube meshers
+* discard.
+*
+* Treats occupancy as a binary field sampled at integer cell coordinates and
+* contours the occupied/empty boundary:
+*  - **Vertices** — one welded vertex per "dual cell" (a unit cube whose 8
+*    corners are the cells `b … b+1`) that **straddles** the boundary (≥1
+*    occupied AND ≥1 empty corner), placed at the **mean of its occupied
+*    corners' `getCellPoint()`** (the measured surface points; the corners'
+*    geometric centres without a provider). Welding by dual-cell key makes the
+*    surface crack-free.
+*  - **Quads** — one per occupied↔empty **crossing**: for every occupied-cell
+*    face whose neighbour is empty (the SAME set the cube mesher emits), a quad
+*    joins the 4 dual cells sharing that edge, wound to face the empty side.
+*
+* Because there is one quad per crossing, **coverage matches the cubes** — unlike
+* the previous 2×2-fully-occupied-patch heuristic, which only meshed flat solid
+* blocks and so missed 80–90 % of a real, ragged depth surface (the reported
+* "barely any surfaces" bug; 2026-06-30 rewrite). The result is smooth (welded
+* vertices pulled onto the measured surface) and watertight for closed regions;
+* over a thin feature (a one-cell floor) the top and bottom dual vertices average
+* the same cells and coincide, so it reads as a single smooth sheet — the
+* smoothest of the modes. Exception: a dual cell with exactly ONE occupied
+* corner is nudged toward its dual-cell centre ({@link SINGLE_CORNER_NUDGE_K}),
+* so features thin in ≥2 dimensions (isolated voxels, line/pillar ends) keep a
+* non-zero area instead of collapsing onto a single point; on a thin floor this
+* puffs only the perimeter-corner vertices by ±0.25·cell.
+*/
+/**
+* 'smooth' single-occupied-corner fallback strength: a dual cell with exactly
+* one occupied corner places its vertex ON that corner's cell point, so every
+* dual cell around a feature thin in ≥2 dimensions (an isolated voxel, the end
+* of a 1-cell line/pillar) coincided with its neighbours → all-degenerate
+* (zero-area) triangles → thin features were invisible to the occluder despite
+* a full per-face triangle count. Nudging the `n === 1` vertex toward the
+* dual-cell centre by this fraction of the corner→centre distance (0.5 ⇒
+* ±0.25·cell per axis) keeps it a pure function of the dual cell, so welding /
+* watertightness and the measured-offset invariant are preserved. Trade-off
+* (accepted 2026-07-02): the `n === 1` perimeter corners of a thin floor (and
+* of a solid box) puff by ±0.25·cell — imperceptible for AR occlusion. Known
+* residual: the `n === 2` shaft rings of a long 1×1×N feature still collapse
+* (locally indistinguishable from a thin floor's intentionally-flat edges).
+* 0.25 was rejected as too close to imperceptibly-non-zero; 1.0 discards the
+* measured centroid exactly where data is sparsest. See
+* 2026-07-01-1455-smooth-mesher-single-corner-degeneracy-followup.md.
+*/
+const SINGLE_CORNER_NUDGE_K = .5;
+/**
+* Resolve every unique cell's surface point (measured centroid via
+* `getCellPoint`, or the geometric centre when the provider is absent /
+* returns null / returns a non-finite triple) EAGERLY into ordinal-aligned
+* typed arrays — `buildSmooth`'s dual-vertex loop then reads points by the
+* ordinal stored in the occupied hash, with no per-key memo Map. The lazy
+* memo this replaces resolved the same points for every surface cell anyway
+* (interior cells of a solid are the only extra work, and reconstruction
+* grids are shells).
+*/
+function resolveCellPoints(uniqueCells, cellSizeM, getCellPoint) {
+	const n = uniqueCells.length;
+	const px = new Float64Array(n);
+	const py = new Float64Array(n);
+	const pz = new Float64Array(n);
+	const scratch = [
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < n; i++) {
+		const cell = uniqueCells[i];
+		const x = cell[0];
+		const y = cell[1];
+		const z = cell[2];
+		let wx = x * cellSizeM;
+		let wy = y * cellSizeM;
+		let wz = z * cellSizeM;
+		if (getCellPoint) {
+			scratch[0] = x;
+			scratch[1] = y;
+			scratch[2] = z;
+			const cp = getCellPoint(scratch);
+			if (cp && isFiniteVector3(cp)) {
+				wx = cp[0];
+				wy = cp[1];
+				wz = cp[2];
+			}
+		}
+		px[i] = wx;
+		py[i] = wy;
+		pz[i] = wz;
+	}
+	return {
+		px,
+		py,
+		pz
+	};
+}
+/**
+* The `centroids`-array twin of {@link resolveCellPoints} (the mesh-worker
+* fast path): centroids arrive input-order-aligned over the wire, so each
+* unique cell's point is `centroids[inputIndices[i]·3 …]` when that triple is
+* finite, else the geometric centre — the exact fallback rule of the callback
+* path (NaN is the wire's "no centroid" sentinel; a non-finite value from a
+* poisoned provider must also degrade, never propagate).
+*/
+function resolveCellPointsFromCentroids(uniqueCells, inputIndices, centroids, cellSizeM) {
+	const n = uniqueCells.length;
+	const px = new Float64Array(n);
+	const py = new Float64Array(n);
+	const pz = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		const j = inputIndices[i] * 3;
+		const cx = centroids[j];
+		const cy = centroids[j + 1];
+		const cz = centroids[j + 2];
+		if (Number.isFinite(cx) && Number.isFinite(cy) && Number.isFinite(cz)) {
+			px[i] = cx;
+			py[i] = cy;
+			pz[i] = cz;
+		} else {
+			const cell = uniqueCells[i];
+			px[i] = cell[0] * cellSizeM;
+			py[i] = cell[1] * cellSizeM;
+			pz[i] = cell[2] * cellSizeM;
+		}
+	}
+	return {
+		px,
+		py,
+		pz
+	};
+}
+/** Growth step for the smooth builder's typed output buffers. */
+function grownCopy(buffer, Ctor) {
+	const grown = new Ctor(buffer.length * 2);
+	grown.set(buffer);
+	return grown;
+}
+function buildSmooth(occupied, uniqueCells, cellSizeM, points) {
+	const n = uniqueCells.length;
+	const { px, py, pz } = points;
+	let positions = new Float32Array(4096 * 3);
+	let posLen = 0;
+	let indices = new Uint32Array(8192 * 3);
+	let idxLen = 0;
+	const vertexIndex = new PackedKeyHash(n * 2);
+	const nudge = cellSizeM * SINGLE_CORNER_NUDGE_K;
+	const dualVertex = (dkey) => {
+		const existing = vertexIndex.get(dkey);
+		if (existing !== -1) return existing;
+		let sx = 0;
+		let sy = 0;
+		let sz = 0;
+		let count = 0;
+		let odx = 0;
+		let ody = 0;
+		let odz = 0;
+		for (let dx = 0; dx <= 1; dx++) for (let dy = 0; dy <= 1; dy++) for (let dz = 0; dz <= 1; dz++) {
+			const ord = occupied.get(dkey + dx * CELL_KEY_STRIDE_X + dy * CELL_KEY_STRIDE_Y + dz);
+			if (ord === -1) continue;
+			sx += px[ord];
+			sy += py[ord];
+			sz += pz[ord];
+			count += 1;
+			odx = dx;
+			ody = dy;
+			odz = dz;
+		}
+		let vx = sx / count;
+		let vy = sy / count;
+		let vz = sz / count;
+		if (count === 1) {
+			vx += (.5 - odx) * nudge;
+			vy += (.5 - ody) * nudge;
+			vz += (.5 - odz) * nudge;
+		}
+		if (posLen + 3 > positions.length) positions = grownCopy(positions, Float32Array);
+		const idx = posLen / 3;
+		positions[posLen] = vx;
+		positions[posLen + 1] = vy;
+		positions[posLen + 2] = vz;
+		posLen += 3;
+		vertexIndex.set(dkey, idx);
+		return idx;
+	};
+	const STRIDES = [
+		CELL_KEY_STRIDE_X,
+		CELL_KEY_STRIDE_Y,
+		1
+	];
+	for (const cell of uniqueCells) {
+		const cKey = packCellKey(cell[0], cell[1], cell[2]);
+		for (const { d, u, v } of GREEDY_DIRS) {
+			const sd = STRIDES[d];
+			const su = STRIDES[u];
+			const sv = STRIDES[v];
+			for (let sgn = 1; sgn >= -1; sgn -= 2) {
+				if (occupied.has(cKey + sgn * sd)) continue;
+				const keyA = (sgn > 0 ? cKey : cKey - sd) - su - sv;
+				const iA = dualVertex(keyA);
+				const iB = dualVertex(keyA + su);
+				const iC = dualVertex(keyA + su + sv);
+				const iD = dualVertex(keyA + sv);
+				if (idxLen + 6 > indices.length) indices = grownCopy(indices, Uint32Array);
+				indices[idxLen] = iA;
+				indices[idxLen + 3] = iA;
+				indices[idxLen + 4] = iC;
+				if (sgn > 0) {
+					indices[idxLen + 1] = iB;
+					indices[idxLen + 2] = iC;
+					indices[idxLen + 5] = iD;
+				} else {
+					indices[idxLen + 1] = iD;
+					indices[idxLen + 2] = iC;
+					indices[idxLen + 5] = iB;
+				}
+				idxLen += 6;
+			}
+		}
+	}
+	return {
+		positions: positions.slice(0, posLen),
+		indices: indices.slice(0, idxLen)
+	};
+}
+/**
+* 'corner-fit' mode — the per-face cube mesher with **displaced shared corners**.
+*
+* Keeps {@link buildCulled}'s exact face topology (same exposed faces), but each
+* lattice corner — identified by its integer half-lattice key `(2x±1, 2y±1,
+* 2z±1)` so every cell sharing it produces the SAME key — is **nudged by the mean
+* sub-cell offset** (`getCellPoint() − cellCentre`) of the occupied cells
+* touching it. Vertices are welded by corner key, so adjacent faces reference the
+* identical displaced position: seams stay coincident ⇒ the surface deforms to
+* hug the measured points yet stays **watertight** (the even-edge-cover invariant
+* `'smooth'` gives up). Without a `getCellPoint` provider every corner falls back
+* to the geometric corner `key · cellSize/2`, i.e. plain cubes.
+*
+* Why the **offset**, not the absolute centroid mean (2026-06-30 fix): moving a
+* corner onto the absolute mean collapsed thin features — a one-cell-thick floor's
+* top and bottom corners average the SAME cells, so they coincided into a flat
+* sheet visually indistinguishable from `'smooth'`. Adding the offset to each
+* corner's OWN geometric position keeps the cube's thickness, so `'corner-fit'`
+* stays a distinct, cube-like, watertight option.
+*
+* Tradeoffs vs `'smooth'`: watertight and exact-cube topology, but corners are
+* 8-way averages (so geometry only *approaches* the measured points, never lands
+* on them) and the per-face O(surface-area) triangle cost is unchanged. Greedy
+* merging does not apply (displaced corners are non-coplanar).
+*/
+function buildCornerFit(occupied, uniqueCells, cellSizeM, getCellPoint, positions, indices) {
+	const half = cellSizeM / 2;
+	const cornerSum = /* @__PURE__ */ new Map();
+	const addCornerOffset = (key, ox, oy, oz) => {
+		let acc = cornerSum.get(key);
+		if (!acc) {
+			acc = {
+				x: 0,
+				y: 0,
+				z: 0,
+				n: 0
+			};
+			cornerSum.set(key, acc);
+		}
+		acc.x += ox;
+		acc.y += oy;
+		acc.z += oz;
+		acc.n += 1;
+	};
+	for (const cell of uniqueCells) {
+		const cp = getCellPoint ? getCellPoint(cell) : null;
+		if (!cp || !isFiniteVector3(cp)) continue;
+		const ox = cp[0] - cell[0] * cellSizeM;
+		const oy = cp[1] - cell[1] * cellSizeM;
+		const oz = cp[2] - cell[2] * cellSizeM;
+		for (let sx = -1; sx <= 1; sx += 2) for (let sy = -1; sy <= 1; sy += 2) for (let sz = -1; sz <= 1; sz += 2) addCornerOffset(packCellKey(2 * cell[0] + sx, 2 * cell[1] + sy, 2 * cell[2] + sz), ox, oy, oz);
+	}
+	const vertexIndex = /* @__PURE__ */ new Map();
+	const cornerVertex = (kx, ky, kz) => {
+		const key = packCellKey(kx, ky, kz);
+		const existing = vertexIndex.get(key);
+		if (existing !== void 0) return existing;
+		const acc = cornerSum.get(key);
+		const px = kx * half + (acc ? acc.x / acc.n : 0);
+		const py = ky * half + (acc ? acc.y / acc.n : 0);
+		const pz = kz * half + (acc ? acc.z / acc.n : 0);
+		const idx = positions.length / 3;
+		positions.push(px, py, pz);
+		vertexIndex.set(key, idx);
+		return idx;
+	};
+	for (const [x, y, z] of uniqueCells) for (const face of FACES) {
+		const nx = x + face.neighbour[0];
+		const ny = y + face.neighbour[1];
+		const nz = z + face.neighbour[2];
+		if (occupied.has(packCellKey(nx, ny, nz))) continue;
+		const corners = face.corners;
+		const x2 = 2 * x;
+		const y2 = 2 * y;
+		const z2 = 2 * z;
+		const c0 = corners[0];
+		const c1 = corners[1];
+		const c2 = corners[2];
+		const c3 = corners[3];
+		const v0 = cornerVertex(x2 + c0[0], y2 + c0[1], z2 + c0[2]);
+		const v1 = cornerVertex(x2 + c1[0], y2 + c1[1], z2 + c1[2]);
+		const v2 = cornerVertex(x2 + c2[0], y2 + c2[1], z2 + c2[2]);
+		const v3 = cornerVertex(x2 + c3[0], y2 + c3[1], z2 + c3[2]);
+		indices.push(v0, v1, v2, v0, v2, v3);
+	}
+}
+/**
+* Greedy meshing: for each face-normal axis and side, sweep slices and merge
+* adjacent coplanar exposed faces into maximal rectangles, emitting one quad
+* per rectangle. The covered unit faces are identical to {@link buildCulled};
+* only the triangle count drops.
+*/
+function buildGreedy(occupied, uniqueCells, cellSizeM, positions, indices) {
+	const half = cellSizeM / 2;
+	const neighbour = [
+		0,
+		0,
+		0
+	];
+	for (const { d, u, v } of GREEDY_DIRS) for (let sign = 1; sign >= -1; sign -= 2) {
+		const slices = /* @__PURE__ */ new Map();
+		for (const cell of uniqueCells) {
+			neighbour[0] = cell[0];
+			neighbour[1] = cell[1];
+			neighbour[2] = cell[2];
+			neighbour[d] += sign;
+			if (occupied.has(packCellKey(neighbour[0], neighbour[1], neighbour[2]))) continue;
+			const k = cell[d];
+			const iu = cell[u];
+			const iv = cell[v];
+			let slice = slices.get(k);
+			if (!slice) {
+				slice = /* @__PURE__ */ new Map();
+				slices.set(k, slice);
+			}
+			slice.set(packCellKey(iu, iv, 0), [iu, iv]);
+		}
+		for (const [k, slice] of [...slices.entries()].sort((a, b) => a[0] - b[0])) greedyMergeSlice(slice, half, cellSizeM, d, u, v, k, sign, positions, indices);
+	}
+}
+/** Greedy-merge one slice's exposed (iu,iv) mask into maximal rectangles. */
+function greedyMergeSlice(slice, half, cellSizeM, d, u, v, k, sign, positions, indices) {
+	const has = (iu, iv) => slice.has(packCellKey(iu, iv, 0));
+	const used = /* @__PURE__ */ new Set();
+	const isUsed = (iu, iv) => used.has(packCellKey(iu, iv, 0));
+	const p = [
+		0,
+		0,
+		0
+	];
+	const cells = [...slice.values()].sort((a, b) => a[1] !== b[1] ? a[1] - b[1] : a[0] - b[0]);
+	for (const [iu, iv] of cells) {
+		if (isUsed(iu, iv)) continue;
+		let w = 1;
+		while (has(iu + w, iv) && !isUsed(iu + w, iv)) w++;
+		let h = 1;
+		let canGrow = true;
+		while (canGrow) {
+			for (let du = 0; du < w; du++) {
+				if (has(iu + du, iv + h) && !isUsed(iu + du, iv + h)) continue;
+				canGrow = false;
+				break;
+			}
+			if (canGrow) h++;
+		}
+		for (let dv = 0; dv < h; dv++) for (let du = 0; du < w; du++) used.add(packCellKey(iu + du, iv + dv, 0));
+		const plane = k * cellSizeM + sign * half;
+		const uMin = iu * cellSizeM - half;
+		const uMax = (iu + w - 1) * cellSizeM + half;
+		const vMin = iv * cellSizeM - half;
+		const vMax = (iv + h - 1) * cellSizeM + half;
+		const base = positions.length / 3;
+		p[d] = plane;
+		p[u] = uMin;
+		p[v] = vMin;
+		positions.push(p[0], p[1], p[2]);
+		if (sign > 0) {
+			p[u] = uMax;
+			positions.push(p[0], p[1], p[2]);
+			p[v] = vMax;
+			positions.push(p[0], p[1], p[2]);
+			p[u] = uMin;
+			positions.push(p[0], p[1], p[2]);
+		} else {
+			p[v] = vMax;
+			positions.push(p[0], p[1], p[2]);
+			p[u] = uMax;
+			positions.push(p[0], p[1], p[2]);
+			p[v] = vMin;
+			positions.push(p[0], p[1], p[2]);
+		}
+		indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+	}
+}
+//#endregion
+export { meshOccupiedCells as t };