@yali-engine/cli 0.0.0-stage → 0.4.0

package/dist/cmd-inspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmd-inspect.js","sourceRoot":"","sources":["../src/cmd-inspect.ts"],"names":[],"mappings":"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"}

package/dist/cmd-test.d.ts

@@ -0,0 +1,9 @@
+import { type Outcome } from './output.ts';
+/**
+ * `yali test`: runs the project's tests with `node:test` (files under `test/`, or the ones
+ * given), TypeScript stripped, and summarises every test. Exit 1 if any failed.
+ */
+export declare function testCommand(opts: {
+    root?: string;
+    files: readonly string[];
+}): Promise<Outcome>;

package/dist/cmd-test.js

@@ -0,0 +1,68 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+import { run } from 'node:test';
+import { YaliError } from '@yali-engine/core';
+import { ok } from "./output.js";
+import { loadProject } from "./project.js";
+/** `*.test.ts` / `*.test.js` files under `dir`, skipping dependencies and build output. */
+function findTests(dir) {
+    const out = [];
+    const walk = (d) => {
+        for (const e of readdirSync(d)) {
+            if (e === 'node_modules' || e === 'dist' || e.startsWith('.'))
+                continue;
+            const p = join(d, e);
+            if (statSync(p).isDirectory())
+                walk(p);
+            else if (/\.test\.(ts|mts|js|mjs)$/.test(e))
+                out.push(p);
+        }
+    };
+    if (existsSync(dir))
+        walk(dir);
+    return out.sort();
+}
+/**
+ * `yali test`: runs the project's tests with `node:test` (files under `test/`, or the ones
+ * given), TypeScript stripped, and summarises every test. Exit 1 if any failed.
+ */
+export async function testCommand(opts) {
+    const project = await loadProject(opts.root);
+    const files = opts.files.length ? opts.files.map((f) => resolve(project.root, f)) : findTests(join(project.root, 'test'));
+    if (files.length === 0) {
+        throw new YaliError('NO_TESTS', `No *.test.ts files under ${join(project.root, 'test')}.`, 'Add tests under test/, or pass the files to run.');
+    }
+    const rows = [];
+    const t0 = performance.now();
+    // Under an outer `node --test` (CI scripts, this package's own tests) the variable makes
+    // the test files report to that outer runner, and this run would see no tests at all.
+    delete process.env.NODE_TEST_CONTEXT;
+    const stream = run({ files, cwd: project.root, execArgv: ['--experimental-strip-types', '--no-warnings'] });
+    const fileNames = new Set(files);
+    const record = (d, passed) => {
+        // Each file is wrapped in a test named by its path; report the tests inside it.
+        if (d.details.type === 'suite' || (d.file && fileNames.has(d.name)) || d.name === d.file)
+            return;
+        const err = d.details.error;
+        rows.push({
+            name: d.name,
+            file: relative(project.root, d.file ?? '').split(sep).join('/'),
+            ok: passed,
+            ms: Math.round(d.details.duration_ms * 10) / 10,
+            ...(passed ? {} : { error: String(err?.cause?.message ?? err?.message ?? 'failed') }),
+        });
+    };
+    stream.on('test:pass', (d) => record(d, true));
+    stream.on('test:fail', (d) => record(d, false));
+    // Drain the stream; it ends when every file has finished.
+    for await (const _ of stream)
+        void _;
+    const failed = rows.filter((r) => !r.ok);
+    const result = { files: files.map((f) => relative(project.root, f).split(sep).join('/')), passed: rows.length - failed.length, failed: failed.length, ms: Math.round(performance.now() - t0), tests: rows };
+    const text = [
+        ...rows.map((r) => `${r.ok ? 'ok  ' : 'FAIL'} ${r.name}${r.ok ? '' : `\n     ${r.error}`}`),
+        `${result.passed} passed, ${result.failed} failed (${result.ms} ms)`,
+    ];
+    return ok('test', result, text, failed.length ? 1 : 0);
+}
+//# sourceMappingURL=cmd-test.js.map

package/dist/cmd-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmd-test.js","sourceRoot":"","sources":["../src/cmd-test.ts"],"names":[],"mappings":"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"}

package/dist/collision.d.ts

@@ -0,0 +1,31 @@
+import type { CollisionPiece } from '@yali-engine/physics';
+/** What decomposition takes. */
+export interface DecomposeOptions {
+    /** Voxels along the longest side (default 32). */
+    readonly resolution?: number;
+    /** Most hulls per mesh (default 16). */
+    readonly maxHulls?: number;
+    /** Wasted volume a piece may keep, a fraction of its hull (default 0.08). */
+    readonly concavity?: number;
+}
+/** A node's collision role by its name. */
+export declare function collisionRole(name: string): 'convex' | 'heightfield' | 'none' | 'mesh';
+/** The convex hull of `pts` (xyz triples): its vertices' indices and its faces (index triples, outward). */
+export declare function convexHull(pts: Float64Array | Float32Array): {
+    vertices: number[];
+    faces: [number, number, number][];
+    volume: number;
+};
+/** Splits a closed-or-not triangle mesh into convex pieces (each a point cloud for `Physics.addHull`). */
+export declare function decompose(positions: Float32Array, indices: Uint32Array, o?: DecomposeOptions): Float32Array[];
+/** A mesh's highest surface sampled on a grid about as fine as its vertices (2–512 per side). */
+export declare function heightfieldOf(positions: Float32Array, indices: Uint32Array): Extract<CollisionPiece, {
+    kind: 'heightfield';
+}> & {
+    node: number;
+};
+/** Welds identical positions; returns positions and remapped indices. */
+export declare function weld(positions: Float32Array, indices: Uint32Array): {
+    vertices: Float32Array;
+    indices: Uint32Array;
+};

package/dist/collision.js

@@ -0,0 +1,471 @@
+// `yali convert --collision` (ADR-0090): a glTF level's collision, baked into the level's frame.
+// Each mesh node becomes, by its name (the conventions Unreal and Godot use):
+//
+// - `UCX_*`, `UBX_*`, `USP_*`, `UCP_*`, `*-convcol`, `*_convex`: convex pieces, from an
+//   approximate convex decomposition (below);
+// - `*_heightfield`, `*-hf`: a heightfield sampled from the mesh (its highest surface);
+// - `UNC_*`, `*-nocol`: nothing;
+// - anything else: a static triangle mesh (welded).
+//
+// The decomposition: the mesh is voxelized solid (a parity fill along X, plus every voxel a
+// triangle crosses, so open meshes and thin walls survive), then split best-first. The piece
+// whose hull wastes the most volume (hull volume − its voxels' volume) is cut by the axis plane
+// whose two hulls cover the least volume, until every piece is within `concavity` (a fraction of
+// its hull) or there are `maxHulls`. Each piece's hull is the convex hull of the mesh's surface
+// samples inside its voxels (so it does not grow past the surface), trimmed to at most 64 points
+// by support sampling. V-HACD's idea (Mamou), without its
+// clipping or merging: coarser, smaller, deterministic.
+/** A node's collision role by its name. */
+export function collisionRole(name) {
+    if (/^(UCX|UBX|USP|UCP)_/i.test(name) || /[-_](convcol|convex)$/i.test(name))
+        return 'convex';
+    if (/[-_](heightfield|hf)$/i.test(name))
+        return 'heightfield';
+    if (/^UNC_/i.test(name) || /[-_]nocol$/i.test(name))
+        return 'none';
+    return 'mesh';
+}
+// ---- Convex hull (incremental, in f64) -------------------------------------------------------
+/** The convex hull of `pts` (xyz triples): its vertices' indices and its faces (index triples, outward). */
+export function convexHull(pts) {
+    const n = pts.length / 3;
+    const P = (i) => [pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]];
+    if (n < 4)
+        return { vertices: [...Array(n).keys()], faces: [], volume: 0 };
+    let lo = [Infinity, Infinity, Infinity];
+    let hi = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < n; i++)
+        for (let c = 0; c < 3; c++) {
+            lo[c] = Math.min(lo[c], pts[i * 3 + c]);
+            hi[c] = Math.max(hi[c], pts[i * 3 + c]);
+        }
+    const eps = 1e-9 * Math.max(1, hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]);
+    // The initial tetrahedron: two extreme points, the farthest from their line, the farthest from their plane.
+    let a = 0;
+    let b = 0;
+    for (let i = 1; i < n; i++) {
+        if (pts[i * 3] < pts[a * 3])
+            a = i;
+        if (pts[i * 3] > pts[b * 3])
+            b = i;
+    }
+    if (a === b) {
+        for (let i = 0; i < n; i++)
+            if (dist2(P(i), P(a)) > dist2(P(b), P(a)))
+                b = i;
+    }
+    let c = -1;
+    let best = eps;
+    for (let i = 0; i < n; i++) {
+        const d = len(cross(sub(P(b), P(a)), sub(P(i), P(a))));
+        if (d > best)
+            [best, c] = [d, i];
+    }
+    if (c < 0)
+        return { vertices: [a, b], faces: [], volume: 0 };
+    let d = -1;
+    best = eps;
+    const nrm = cross(sub(P(b), P(a)), sub(P(c), P(a)));
+    for (let i = 0; i < n; i++) {
+        const h = Math.abs(dot(nrm, sub(P(i), P(a))));
+        if (h > best)
+            [best, d] = [h, i];
+    }
+    if (d < 0)
+        return { vertices: [a, b, c], faces: [], volume: 0 };
+    const inside = scale(add(add(P(a), P(b)), add(P(c), P(d))), 0.25);
+    const faces = [];
+    const make = (i, j, k) => {
+        let nn = cross(sub(P(j), P(i)), sub(P(k), P(i)));
+        if (dot(nn, sub(inside, P(i))) > 0) {
+            [j, k] = [k, j];
+            nn = scale(nn, -1);
+        }
+        const l = len(nn) || 1;
+        nn = scale(nn, 1 / l);
+        faces.push({ v: [i, j, k], n: nn, off: dot(nn, P(i)), alive: true });
+    };
+    make(a, b, c);
+    make(a, b, d);
+    make(a, c, d);
+    make(b, c, d);
+    const used = new Set([a, b, c, d]);
+    for (let p = 0; p < n; p++) {
+        if (used.has(p))
+            continue;
+        const q = P(p);
+        const visible = [];
+        for (let f = 0; f < faces.length; f++)
+            if (faces[f].alive && dot(faces[f].n, q) - faces[f].off > eps)
+                visible.push(f);
+        if (visible.length === 0)
+            continue;
+        // The horizon: edges of visible faces whose twin is not visible.
+        const edges = new Map();
+        for (const f of visible) {
+            faces[f].alive = false;
+            const [i, j, k] = faces[f].v;
+            for (const [u, w] of [[i, j], [j, k], [k, i]]) {
+                const twin = `${w},${u}`;
+                if (edges.has(twin))
+                    edges.delete(twin);
+                else
+                    edges.set(`${u},${w}`, [u, w]);
+            }
+        }
+        for (const [u, w] of edges.values())
+            make(u, w, p);
+        used.add(p);
+    }
+    const live = faces.filter((f) => f.alive);
+    const verts = new Set();
+    let volume = 0;
+    for (const f of live) {
+        f.v.forEach((v) => verts.add(v));
+        volume += dot(P(f.v[0]), cross(P(f.v[1]), P(f.v[2]))) / 6;
+    }
+    return { vertices: [...verts].sort((x, y) => x - y), faces: live.map((f) => f.v), volume: Math.abs(volume) };
+}
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const len = (a) => Math.hypot(a[0], a[1], a[2]);
+const dist2 = (a, b) => (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2;
+/** At most `max` of the hull's points: the support points in `max` evenly spread directions. */
+function trimHull(points, max) {
+    if (points.length <= max)
+        return points;
+    const out = new Set();
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < max; i++) {
+        const y = 1 - (2 * (i + 0.5)) / max;
+        const r = Math.sqrt(1 - y * y);
+        const d = [Math.cos(golden * i) * r, y, Math.sin(golden * i) * r];
+        let bi = 0;
+        let bd = -Infinity;
+        points.forEach((p, k) => {
+            const s = p[0] * d[0] + p[1] * d[1] + p[2] * d[2];
+            if (s > bd)
+                [bd, bi] = [s, k];
+        });
+        out.add(bi);
+    }
+    return [...out].sort((x, y) => x - y).map((k) => points[k]);
+}
+// ---- Voxelization and decomposition --------------------------------------------------------
+/** Splits a closed-or-not triangle mesh into convex pieces (each a point cloud for `Physics.addHull`). */
+export function decompose(positions, indices, o = {}) {
+    const res = Math.max(4, Math.min(128, o.resolution ?? 32));
+    const maxHulls = Math.max(1, o.maxHulls ?? 16);
+    const concavity = o.concavity ?? 0.08;
+    const nv = positions.length / 3;
+    const lo = [Infinity, Infinity, Infinity];
+    const hi = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < nv; i++)
+        for (let c = 0; c < 3; c++) {
+            lo[c] = Math.min(lo[c], positions[i * 3 + c]);
+            hi[c] = Math.max(hi[c], positions[i * 3 + c]);
+        }
+    const ext = sub(hi, lo);
+    const size = Math.max(ext[0], ext[1], ext[2]) / res || 1;
+    const dims = ext.map((e) => Math.max(1, Math.ceil(e / size)));
+    const [nx, ny, nz] = dims;
+    const idx = (x, y, z) => (z * ny + y) * nx + x;
+    const solid = new Uint8Array(nx * ny * nz);
+    const P = (i) => [positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]];
+    // Parity fill along X: each column's crossings, sorted, fill between pairs.
+    const crossings = Array.from({ length: ny * nz }, () => []);
+    for (let t = 0; t < indices.length; t += 3) {
+        const [a, b, c] = [P(indices[t]), P(indices[t + 1]), P(indices[t + 2])];
+        const y0 = Math.max(0, Math.floor((Math.min(a[1], b[1], c[1]) - lo[1]) / size));
+        const y1 = Math.min(ny - 1, Math.floor((Math.max(a[1], b[1], c[1]) - lo[1]) / size));
+        const z0 = Math.max(0, Math.floor((Math.min(a[2], b[2], c[2]) - lo[2]) / size));
+        const z1 = Math.min(nz - 1, Math.floor((Math.max(a[2], b[2], c[2]) - lo[2]) / size));
+        for (let z = z0; z <= z1; z++) {
+            for (let y = y0; y <= y1; y++) {
+                const py = lo[1] + (y + 0.5) * size;
+                const pz = lo[2] + (z + 0.5) * size;
+                // The ray (x, py, pz) against the triangle, in the YZ plane.
+                const d = (b[1] - a[1]) * (c[2] - a[2]) - (c[1] - a[1]) * (b[2] - a[2]);
+                if (Math.abs(d) < 1e-12)
+                    continue;
+                const u = ((py - a[1]) * (c[2] - a[2]) - (c[1] - a[1]) * (pz - a[2])) / d;
+                const v = ((b[1] - a[1]) * (pz - a[2]) - (py - a[1]) * (b[2] - a[2])) / d;
+                if (u < 0 || v < 0 || u + v > 1)
+                    continue;
+                crossings[z * ny + y].push(a[0] + u * (b[0] - a[0]) + v * (c[0] - a[0]));
+            }
+        }
+    }
+    crossings.forEach((xs, k) => {
+        if (xs.length < 2)
+            return;
+        xs.sort((p, q) => p - q);
+        const y = k % ny;
+        const z = Math.floor(k / ny);
+        for (let i = 0; i + 1 < xs.length; i += 2) {
+            const x0 = Math.max(0, Math.ceil((xs[i] - lo[0]) / size - 0.5));
+            const x1 = Math.min(nx - 1, Math.floor((xs[i + 1] - lo[0]) / size - 0.5));
+            for (let x = x0; x <= x1; x++)
+                solid[idx(x, y, z)] = 1;
+        }
+    });
+    // Every voxel a triangle passes through (sampled at a third of a voxel); the samples are kept,
+    // each with its voxel: a piece's hull is the hull of its surface samples (on the true surface,
+    // not a voxel's corner out).
+    const samples = [];
+    const sampleVoxel = [];
+    for (let t = 0; t < indices.length; t += 3) {
+        const [a, b, c] = [P(indices[t]), P(indices[t + 1]), P(indices[t + 2])];
+        const span = Math.max(len(sub(b, a)), len(sub(c, a)), len(sub(c, b)));
+        const steps = Math.max(1, Math.ceil((3 * span) / size));
+        // A sample on a voxel boundary goes to the voxel on the solid side of its own face: nudged a
+        // hair inward (against the outward normal) and towards the triangle's centre (an edge sample
+        // belongs to its face, not the next column) before it is binned. The sample stays exact.
+        const nrm = cross(sub(b, a), sub(c, a));
+        const nl = len(nrm);
+        const inward = nl > 0 ? scale(nrm, -1e-3 * size / nl) : [0, 0, 0];
+        const centre = scale(add(add(a, b), c), 1 / 3);
+        for (let i = 0; i <= steps; i++) {
+            for (let j = 0; j <= steps - i; j++) {
+                const u = i / steps;
+                const v = j / steps;
+                const p = add(a, add(scale(sub(b, a), u), scale(sub(c, a), v)));
+                const toCentre = sub(centre, p);
+                const tl = len(toCentre);
+                const q = add(add(p, inward), tl > 0 ? scale(toCentre, (1e-3 * size) / tl) : [0, 0, 0]);
+                const x = Math.min(nx - 1, Math.max(0, Math.floor((q[0] - lo[0]) / size)));
+                const y = Math.min(ny - 1, Math.max(0, Math.floor((q[1] - lo[1]) / size)));
+                const z = Math.min(nz - 1, Math.max(0, Math.floor((q[2] - lo[2]) / size)));
+                solid[idx(x, y, z)] = 1;
+                samples.push(p[0], p[1], p[2]);
+                sampleVoxel.push(idx(x, y, z));
+            }
+        }
+    }
+    const all = [];
+    for (let i = 0; i < solid.length; i++)
+        if (solid[i])
+            all.push(i);
+    if (all.length === 0)
+        return [];
+    const coord = (i) => [i % nx, Math.floor(i / nx) % ny, Math.floor(i / (nx * ny))];
+    // Per voxel, only its samples extreme in 14 directions (the axes and the cube's diagonals):
+    // the only ones a hull can use.
+    const DIRS = [[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]];
+    for (let k = 0; k < 8; k++)
+        DIRS.push([k & 1 ? 1 : -1, k & 2 ? 1 : -1, k & 4 ? 1 : -1]);
+    const extremes = new Map();
+    {
+        const best = new Map();
+        sampleVoxel.forEach((v, k) => {
+            let ex = extremes.get(v);
+            let bs = best.get(v);
+            if (!ex || !bs) {
+                ex = new Array(DIRS.length).fill(k);
+                bs = new Float64Array(DIRS.length).fill(-Infinity);
+                extremes.set(v, ex);
+                best.set(v, bs);
+            }
+            for (let d = 0; d < DIRS.length; d++) {
+                const sd = samples[k * 3] * DIRS[d][0] + samples[k * 3 + 1] * DIRS[d][1] + samples[k * 3 + 2] * DIRS[d][2];
+                if (sd > bs[d]) {
+                    bs[d] = sd;
+                    ex[d] = k;
+                }
+            }
+        });
+        for (const [v, ex] of extremes)
+            extremes.set(v, [...new Set(ex)]);
+    }
+    /** The support points of `pts` in 64 spread directions (cheap), then their exact hull. */
+    const SUPPORT = [];
+    {
+        const golden = Math.PI * (3 - Math.sqrt(5));
+        for (let i = 0; i < 64; i++) {
+            const y = 1 - (2 * (i + 0.5)) / 64;
+            const r = Math.sqrt(1 - y * y);
+            SUPPORT.push([Math.cos(golden * i) * r, y, Math.sin(golden * i) * r]);
+        }
+    }
+    const supportHull = (pts) => {
+        const picked = new Set();
+        for (const d of SUPPORT) {
+            let bi = 0;
+            let bd = -Infinity;
+            for (let k = 0; k < pts.length; k += 3) {
+                const sd = pts[k] * d[0] + pts[k + 1] * d[1] + pts[k + 2] * d[2];
+                if (sd > bd)
+                    [bd, bi] = [sd, k];
+            }
+            picked.add(bi);
+        }
+        const out = [];
+        for (const k of [...picked].sort((x, y) => x - y))
+            out.push(pts[k], pts[k + 1], pts[k + 2]);
+        return { h: convexHull(new Float64Array(out)), pts: out };
+    };
+    /**
+     * A piece's hull: of the surface samples in its voxels (clamped to the voxels' box: a sample on
+     * a voxel boundary may lie on a neighbouring piece's face), or, for a piece with too few, of its
+     * voxels' corners.
+     */
+    const hullOf = (voxels) => {
+        const bmin = [Infinity, Infinity, Infinity];
+        const bmax = [-Infinity, -Infinity, -Infinity];
+        for (const v of voxels) {
+            const c = coord(v);
+            for (let a = 0; a < 3; a++) {
+                bmin[a] = Math.min(bmin[a], lo[a] + c[a] * size);
+                bmax[a] = Math.max(bmax[a], lo[a] + (c[a] + 1) * size);
+            }
+        }
+        const own = [];
+        for (const v of voxels) {
+            for (const k of extremes.get(v) ?? []) {
+                for (let a = 0; a < 3; a++)
+                    own.push(Math.min(bmax[a], Math.max(bmin[a], samples[k * 3 + a])));
+            }
+        }
+        if (own.length >= 12) {
+            const r = supportHull(own);
+            if (r.h.volume > 0)
+                return r;
+        }
+        const corners = [];
+        for (const v of voxels) {
+            const [x, y, z] = coord(v);
+            for (let k = 0; k < 8; k++)
+                corners.push(lo[0] + (x + (k & 1)) * size, lo[1] + (y + ((k >> 1) & 1)) * size, lo[2] + (z + ((k >> 2) & 1)) * size);
+        }
+        return supportHull(corners);
+    };
+    const voxelVolume = size ** 3;
+    const piece = (voxels) => {
+        const hull = hullOf(voxels);
+        return { voxels, hull, waste: Math.max(0, hull.h.volume - voxels.length * voxelVolume) };
+    };
+    const pieces = [piece(all)];
+    while (pieces.length < maxHulls) {
+        // The piece wasting the most volume, if it is over the threshold.
+        let wi = -1;
+        for (let i = 0; i < pieces.length; i++) {
+            const p = pieces[i];
+            if (p.waste > concavity * p.hull.h.volume && p.voxels.length > 1 && (wi < 0 || p.waste > pieces[wi].waste))
+                wi = i;
+        }
+        if (wi < 0)
+            break;
+        const p = pieces[wi];
+        // The cut whose two hulls cover the least space (waste, clamped at 0 and measured against
+        // voxels that overhang the surface, ties between good cuts; hull volume does not).
+        let bestSplit = null;
+        let bestVolume = p.hull.h.volume;
+        const pc = p.voxels.map(coord);
+        for (let axis = 0; axis < 3; axis++) {
+            let mn = Infinity;
+            let mx = -Infinity;
+            for (const c of pc) {
+                mn = Math.min(mn, c[axis]);
+                mx = Math.max(mx, c[axis]);
+            }
+            if (mx <= mn)
+                continue;
+            const step = Math.max(1, Math.floor((mx - mn) / 8));
+            for (let cut = mn + 1; cut <= mx; cut += step) {
+                const left = [];
+                const right = [];
+                p.voxels.forEach((v, k) => (pc[k][axis] < cut ? left : right).push(v));
+                if (left.length === 0 || right.length === 0)
+                    continue;
+                const l = piece(left);
+                const r = piece(right);
+                const v = l.hull.h.volume + r.hull.h.volume;
+                if (v < bestVolume - 1e-9 * bestVolume) {
+                    bestVolume = v;
+                    bestSplit = [l, r];
+                }
+            }
+        }
+        if (!bestSplit) {
+            // No cut helps: accept it as is.
+            p.waste = 0;
+            continue;
+        }
+        pieces.splice(wi, 1, ...bestSplit);
+    }
+    return pieces.map((p) => {
+        const pts = p.hull.h.vertices.map((v) => [p.hull.pts[v * 3], p.hull.pts[v * 3 + 1], p.hull.pts[v * 3 + 2]]);
+        return Float32Array.from(trimHull(pts, 64).flat());
+    });
+}
+// ---- Heightfields ----------------------------------------------------------------------------
+/** A mesh's highest surface sampled on a grid about as fine as its vertices (2–512 per side). */
+export function heightfieldOf(positions, indices) {
+    const nv = positions.length / 3;
+    let [x0, x1, z0, z1, y0] = [Infinity, -Infinity, Infinity, -Infinity, Infinity];
+    for (let i = 0; i < nv; i++) {
+        x0 = Math.min(x0, positions[i * 3]);
+        x1 = Math.max(x1, positions[i * 3]);
+        y0 = Math.min(y0, positions[i * 3 + 1]);
+        z0 = Math.min(z0, positions[i * 3 + 2]);
+        z1 = Math.max(z1, positions[i * 3 + 2]);
+    }
+    const per = Math.max(2, Math.min(512, Math.round(Math.sqrt(nv))));
+    const sx = x1 - x0 || 1;
+    const sz = z1 - z0 || 1;
+    const cols = Math.max(2, Math.min(512, Math.round((per * sx) / Math.max(sx, sz)) + 1));
+    const rows = Math.max(2, Math.min(512, Math.round((per * sz) / Math.max(sx, sz)) + 1));
+    const cx = sx / (cols - 1);
+    const cz = sz / (rows - 1);
+    const h = new Float32Array(rows * cols).fill(-Infinity);
+    const P = (i) => [positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]];
+    for (let t = 0; t < indices.length; t += 3) {
+        const [a, b, c] = [P(indices[t]), P(indices[t + 1]), P(indices[t + 2])];
+        const c0 = Math.max(0, Math.floor((Math.min(a[0], b[0], c[0]) - x0) / cx));
+        const c1 = Math.min(cols - 1, Math.ceil((Math.max(a[0], b[0], c[0]) - x0) / cx));
+        const r0 = Math.max(0, Math.floor((Math.min(a[2], b[2], c[2]) - z0) / cz));
+        const r1 = Math.min(rows - 1, Math.ceil((Math.max(a[2], b[2], c[2]) - z0) / cz));
+        const d = (b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2]);
+        if (Math.abs(d) < 1e-12)
+            continue;
+        for (let r = r0; r <= r1; r++) {
+            for (let col = c0; col <= c1; col++) {
+                const px = x0 + col * cx;
+                const pz = z0 + r * cz;
+                const u = ((px - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (pz - a[2])) / d;
+                const v = ((b[0] - a[0]) * (pz - a[2]) - (px - a[0]) * (b[2] - a[2])) / d;
+                if (u < -1e-6 || v < -1e-6 || u + v > 1 + 1e-6)
+                    continue;
+                const y = a[1] + u * (b[1] - a[1]) + v * (c[1] - a[1]);
+                if (y > h[r * cols + col])
+                    h[r * cols + col] = y;
+            }
+        }
+    }
+    // Holes (no triangle above a sample) take the lowest height.
+    for (let i = 0; i < h.length; i++)
+        if (!Number.isFinite(h[i]))
+            h[i] = y0;
+    return { kind: 'heightfield', node: -1, rows, cols, cell: [cx, cz], center: [(x0 + x1) / 2, 0, (z0 + z1) / 2], heights: h };
+}
+/** Welds identical positions; returns positions and remapped indices. */
+export function weld(positions, indices) {
+    const map = new Map();
+    const out = [];
+    const remap = new Uint32Array(positions.length / 3);
+    for (let i = 0; i < positions.length / 3; i++) {
+        const key = `${positions[i * 3]},${positions[i * 3 + 1]},${positions[i * 3 + 2]}`;
+        let k = map.get(key);
+        if (k === undefined) {
+            k = out.length / 3;
+            map.set(key, k);
+            out.push(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
+        }
+        remap[i] = k;
+    }
+    return { vertices: Float32Array.from(out), indices: indices.map((i) => remap[i]) };
+}
+//# sourceMappingURL=collision.js.map