@playcraft/cli 0.1.63 → 0.1.65

package/dist/model-optimization/optimize.js

@@ -0,0 +1,281 @@
+import { constants } from 'node:fs';
+import { lstat, readFile, realpath, mkdir, open, link, unlink } from 'node:fs/promises';
+import { basename, dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash, randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
+import sharp from 'sharp';
+import { NodeIO } from '@gltf-transform/core';
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import { dedup, prune } from '@gltf-transform/functions';
+import { readModelSourceDocument } from '@playcraft/common/cloud-workspace/runtime';
+const hash = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const canonical = (value) => JSON.stringify(value && typeof value === 'object'
+    ? Array.isArray(value) ? value.map(item => JSON.parse(canonical(item)))
+        : Object.fromEntries(Object.keys(value).sort().map(key => [key, JSON.parse(canonical(value[key]))])) : value);
+const padded = (n) => Math.ceil(n / 4) * 4;
+function parse(bytes) {
+    if (bytes.length < 20 || Buffer.from(bytes).readUInt32LE(0) !== 0x46546c67)
+        throw Error('optimization_requires_self_contained_glb');
+    const { document, binary, extraChunks } = readModelSourceDocument(bytes);
+    const doc = document;
+    if (!binary || extraChunks?.length || doc.asset?.version !== '2.0' || doc.buffers?.length !== 1 || doc.buffers[0].uri ||
+        doc.buffers[0].byteLength > binary.length)
+        throw Error('optimization_requires_self_contained_glb');
+    const supported = new Set(ALL_EXTENSIONS.map(extension => extension.EXTENSION_NAME));
+    for (const name of new Set([...doc.extensionsUsed ?? [], ...doc.extensionsRequired ?? []])) {
+        if (!supported.has(name) || ['KHR_draco_mesh_compression', 'EXT_meshopt_compression', 'KHR_texture_basisu'].includes(name))
+            throw Error(`optimization_unsupported_extension:${name}`);
+    }
+    for (const view of doc.bufferViews ?? [])
+        if (view.buffer !== 0 || !Number.isSafeInteger(view.byteLength) || view.byteLength < 0 ||
+            !Number.isSafeInteger(view.byteOffset ?? 0) || (view.byteOffset ?? 0) < 0 || (view.byteOffset ?? 0) + view.byteLength > doc.buffers[0].byteLength)
+            throw Error('optimization_invalid_buffer_view');
+    return { doc, binary: Buffer.from(binary) };
+}
+function metrics(bytes) {
+    const { doc } = parse(bytes);
+    let triangles = 0, vertices = 0;
+    for (const mesh of doc.meshes ?? [])
+        for (const primitive of mesh.primitives ?? []) {
+            const count = doc.accessors?.[primitive.indices ?? primitive.attributes?.POSITION]?.count ?? 0;
+            vertices += doc.accessors?.[primitive.attributes?.POSITION]?.count ?? 0;
+            triangles += (primitive.mode ?? 4) === 4 ? count / 3 : [5, 6].includes(primitive.mode) ? Math.max(0, count - 2) : 0;
+        }
+    return { modelBytes: bytes.length, meshes: doc.meshes?.length ?? 0, triangles, vertices, textures: doc.images?.length ?? 0,
+        textureBytes: (doc.images ?? []).reduce((n, image) => n + (doc.bufferViews?.[image.bufferView]?.byteLength ?? 0), 0),
+        extensionsUsed: [...doc.extensionsUsed ?? []].sort() };
+}
+function extensionValues(doc) {
+    const values = [];
+    const walk = (value) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (!Array.isArray(value) && value.extensions)
+            for (const [name, payload] of Object.entries(value.extensions))
+                values.push(canonical({ name, payload }));
+        for (const [key, child] of Object.entries(value))
+            if (key !== 'extensions')
+                walk(child);
+    };
+    walk(doc);
+    return values.sort();
+}
+function unchangedEvidence(bytes) {
+    const { doc, binary } = parse(bytes), images = new Set((doc.images ?? []).map((image) => image.bufferView));
+    const semantic = structuredClone(doc);
+    for (const buffer of semantic.buffers)
+        delete buffer.byteLength;
+    for (let i = 0; i < (semantic.bufferViews?.length ?? 0); i++) {
+        delete semantic.bufferViews[i].byteOffset;
+        if (images.has(i))
+            delete semantic.bufferViews[i].byteLength;
+    }
+    for (const image of semantic.images ?? [])
+        delete image.mimeType;
+    return { semanticHash: hash(canonical(semantic)), geometryViews: (doc.bufferViews ?? []).flatMap((view, index) => images.has(index) ? []
+            : [{ index, sha256: hash(binary.subarray(view.byteOffset ?? 0, (view.byteOffset ?? 0) + view.byteLength)) }]) };
+}
+function requireOpaqueColorUsage(doc, imageIndex) {
+    const textureIndices = new Set();
+    for (const [index, texture] of (doc.textures ?? []).entries())
+        if (texture.source === imageIndex)
+            textureIndices.add(index);
+    for (const material of doc.materials ?? []) {
+        const walk = (value, path) => {
+            if (!value || typeof value !== 'object')
+                return;
+            if (typeof value.index === 'number' && textureIndices.has(value.index) && /Texture$/.test(path)) {
+                if ((material.alphaMode ?? 'OPAQUE') !== 'OPAQUE' || !['pbrMetallicRoughness.baseColorTexture', 'emissiveTexture'].includes(path))
+                    throw Error('optimization_jpeg_requires_opaque_color_texture');
+            }
+            for (const [key, child] of Object.entries(value))
+                walk(child, path ? `${path}.${key}` : key);
+        };
+        walk(material, '');
+    }
+}
+async function rewriteTextures(input, options) {
+    const { doc, binary } = parse(input), replacements = new Map();
+    const imageViews = new Set();
+    for (const [index, image] of (doc.images ?? []).entries()) {
+        if (!Number.isInteger(image.bufferView) || image.uri || !['image/png', 'image/jpeg'].includes(image.mimeType))
+            throw Error('optimization_embedded_png_or_jpeg_required');
+        const view = doc.bufferViews?.[image.bufferView];
+        if (!view)
+            throw Error('optimization_invalid_image_view');
+        if (view.target !== undefined || (doc.accessors ?? []).some((accessor) => accessor.bufferView === image.bufferView ||
+            accessor.sparse?.indices?.bufferView === image.bufferView || accessor.sparse?.values?.bufferView === image.bufferView))
+            throw Error('optimization_image_view_used_by_geometry');
+        const start = view.byteOffset ?? 0, end = start + padded(view.byteLength);
+        if (start % 4 || end > binary.length || [...binary.subarray(start + view.byteLength, end)].some(value => value !== 0))
+            throw Error('optimization_image_alignment_unsupported');
+        for (let i = 0; i < doc.bufferViews.length; i++) {
+            const other = doc.bufferViews[i], a = other.byteOffset ?? 0;
+            if (i !== image.bufferView && start < a + other.byteLength && a < end)
+                throw Error('optimization_shared_image_buffer_view');
+        }
+        if (imageViews.has(image.bufferView))
+            throw Error('optimization_shared_image_buffer_view');
+        imageViews.add(image.bufferView);
+        const original = binary.subarray(start, start + view.byteLength), decoder = sharp(original, { limitInputPixels: 64 * 1024 * 1024 });
+        const meta = await decoder.metadata();
+        if (!meta.width || !meta.height)
+            throw Error('optimization_texture_dimensions_missing');
+        const format = options.textureFormat ?? 'png';
+        if (format === 'jpeg') {
+            requireOpaqueColorUsage(doc, index);
+            if (meta.hasAlpha) {
+                const stats = await decoder.clone().stats();
+                if (stats.channels.at(-1)?.min !== 255)
+                    throw Error('optimization_jpeg_would_discard_alpha');
+            }
+        }
+        if (meta.width <= options.textureSize && meta.height <= options.textureSize && options.textureFormat === undefined)
+            continue;
+        const encoder = decoder.clone().resize(options.textureSize, options.textureSize, { fit: 'inside', withoutEnlargement: true });
+        const encoded = format === 'jpeg' ? await encoder.removeAlpha().jpeg({ quality: options.quality }).toBuffer() : await encoder.png().toBuffer();
+        image.mimeType = format === 'jpeg' ? 'image/jpeg' : 'image/png';
+        replacements.set(image.bufferView, encoded);
+    }
+    const ordered = [...replacements].sort(([a], [b]) => (doc.bufferViews[a].byteOffset ?? 0) - (doc.bufferViews[b].byteOffset ?? 0));
+    const parts = [], shifts = [];
+    let cursor = 0;
+    for (const [index, encoded] of ordered) {
+        const view = doc.bufferViews[index], start = view.byteOffset ?? 0, oldEnd = start + padded(view.byteLength);
+        const prefix = binary.subarray(cursor, start);
+        parts.push(prefix, encoded, Buffer.alloc(padded(encoded.length) - encoded.length));
+        shifts.push({ end: oldEnd, delta: padded(encoded.length) - padded(view.byteLength) });
+        view.byteLength = encoded.length;
+        cursor = oldEnd;
+    }
+    parts.push(binary.subarray(cursor));
+    for (const view of doc.bufferViews ?? []) {
+        const offset = view.byteOffset ?? 0;
+        const delta = shifts.filter(shift => shift.end <= offset).reduce((n, shift) => n + shift.delta, 0);
+        if (offset + delta !== 0 || view.byteOffset !== undefined)
+            view.byteOffset = offset + delta;
+    }
+    const outputBinary = Buffer.concat(parts);
+    doc.buffers[0].byteLength = outputBinary.length;
+    const text = Buffer.from(JSON.stringify(doc)), json = Buffer.concat([text, Buffer.alloc(padded(text.length) - text.length, 0x20)]);
+    const result = Buffer.alloc(12 + 8 + json.length + 8 + outputBinary.length);
+    result.writeUInt32LE(0x46546c67, 0);
+    result.writeUInt32LE(2, 4);
+    result.writeUInt32LE(result.length, 8);
+    result.writeUInt32LE(json.length, 12);
+    result.writeUInt32LE(0x4e4f534a, 16);
+    json.copy(result, 20);
+    result.writeUInt32LE(outputBinary.length, 20 + json.length);
+    result.writeUInt32LE(0x004e4942, 24 + json.length);
+    outputBinary.copy(result, 28 + json.length);
+    if (canonical(unchangedEvidence(input)) !== canonical(unchangedEvidence(result)))
+        throw Error('optimization_non_texture_data_changed');
+    return result;
+}
+async function packageVersion(name) {
+    let path = dirname(name === '@playcraft/cli' ? fileURLToPath(import.meta.url) : createRequire(import.meta.url).resolve(name));
+    while (dirname(path) !== path) {
+        try {
+            const data = JSON.parse(await readFile(join(path, 'package.json'), 'utf8'));
+            if (data.name === name)
+                return data.version;
+        }
+        catch { /* Continue to the owning package. */ }
+        path = dirname(path);
+    }
+    throw Error('optimization_tool_version_missing');
+}
+async function publishPair(files) {
+    const temporary = [];
+    try {
+        for (const file of files) {
+            await mkdir(dirname(file.path), { recursive: true });
+            if (await realpath(dirname(file.path)) !== dirname(file.path))
+                throw Error('optimization_output_parent_not_canonical');
+            try {
+                await lstat(file.path);
+                throw Error('optimization_output_exists');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        for (const file of files) {
+            const path = join(dirname(file.path), `.${basename(file.path)}.${randomUUID()}.pending`);
+            const handle = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+            try {
+                const meta = await handle.stat();
+                temporary.push({ path, destination: file.path, ino: meta.ino, dev: meta.dev, linked: false });
+                await handle.writeFile(file.content);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        for (const file of temporary) {
+            await link(file.path, file.destination);
+            file.linked = true;
+        }
+    }
+    catch (error) {
+        for (const file of temporary.filter(item => item.linked)) {
+            const meta = await lstat(file.destination).catch(() => undefined);
+            if (meta?.ino === file.ino && meta.dev === file.dev)
+                await unlink(file.destination);
+        }
+        throw error;
+    }
+    finally {
+        for (const file of temporary)
+            await unlink(file.path).catch(() => undefined);
+    }
+}
+export async function optimizeModel(options) {
+    const textureSize = options.textureSize ?? 512, quality = options.quality ?? 85;
+    if (!Number.isInteger(textureSize) || textureSize < 1 || textureSize > 16384 || !Number.isInteger(quality) || quality < 1 || quality > 100 ||
+        options.textureFormat !== undefined && !['jpeg', 'png'].includes(options.textureFormat) ||
+        options.maxOutputBytes !== undefined && (!Number.isSafeInteger(options.maxOutputBytes) || options.maxOutputBytes < 1))
+        throw Error('optimization_invalid_options');
+    const input = resolve(options.input), output = resolve(options.output), lineagePath = resolve(options.lineagePath ?? `${output}.optimization.json`);
+    if (input === output || input === lineagePath || output === lineagePath)
+        throw Error('optimization_output_must_be_new');
+    const metadata = await lstat(input);
+    if (!metadata.isFile() || metadata.nlink !== 1 || await realpath(input) !== input || metadata.size > 64 * 1024 * 1024)
+        throw Error('optimization_input_invalid');
+    const original = await readFile(input), inputHash = hash(original), before = metrics(original), beforeEvidence = unchangedEvidence(original);
+    let result = await rewriteTextures(original, { textureSize, quality, textureFormat: options.textureFormat });
+    if (!options.texturesOnly) {
+        const io = new NodeIO().registerExtensions(ALL_EXTENSIONS), document = await io.readBinary(result);
+        await document.transform(dedup(), prune());
+        result = Buffer.from(await io.writeBinary(document));
+    }
+    const originalDoc = parse(original).doc, resultDoc = parse(result).doc;
+    if (canonical(extensionValues(originalDoc)) !== canonical(extensionValues(resultDoc)) ||
+        [...originalDoc.extensionsUsed ?? []].some(name => !(resultDoc.extensionsUsed ?? []).includes(name)))
+        throw Error('optimization_extension_semantics_changed');
+    const afterEvidence = unchangedEvidence(result), geometryUnchanged = canonical(beforeEvidence) === canonical(afterEvidence);
+    if (options.texturesOnly && !geometryUnchanged)
+        throw Error('optimization_geometry_changed');
+    if (options.maxOutputBytes !== undefined && result.length > options.maxOutputBytes)
+        throw Error(`optimization_output_budget_exceeded:${result.length}:${options.maxOutputBytes}`);
+    const latest = await lstat(input);
+    if (latest.ino !== metadata.ino || latest.dev !== metadata.dev || hash(await readFile(input)) !== inputHash)
+        throw Error('optimization_source_changed');
+    const parameters = { textureSize, textureFormat: options.textureFormat ?? 'png', formatExplicit: options.textureFormat !== undefined, quality,
+        texturesOnly: options.texturesOnly === true, maxOutputBytes: options.maxOutputBytes ?? null };
+    const nativeBinaries = await Promise.all(Object.keys(createRequire(import.meta.url).cache)
+        .filter(path => /[/\\]sharp[^/\\]*\.node$/.test(path)).sort().map(async (path) => ({ name: basename(path), sha256: hash(await readFile(path)) })));
+    if (!nativeBinaries.length)
+        throw Error('optimization_encoder_binary_identity_missing');
+    const tool = { name: 'playcraft-3d-optimize', version: await packageVersion('@playcraft/cli'), scriptHash: hash(await readFile(fileURLToPath(import.meta.url))),
+        dependencies: { sharp: await packageVersion('sharp'), gltfTransform: await packageVersion('@gltf-transform/core') }, codecs: sharp.versions, nativeBinaries };
+    const lineage = { schemaVersion: 1, parent: { path: input, inputHash, bytes: original.length }, parameters, optionsHash: hash(canonical(parameters)),
+        result: { path: output, resultHash: hash(result), bytes: result.length }, tool: { ...tool, manifestHash: hash(canonical(tool)) },
+        before, after: metrics(result), preservation: { sourceUnchanged: true, geometryUnchanged, before: beforeEvidence, after: afterEvidence, extensionsPreserved: true },
+        offlineChecks: 'passed', browserValidation: 'pending', cloudValidation: 'pending', modelAcceptance: false };
+    await publishPair([{ path: output, content: result }, { path: lineagePath, content: Buffer.from(JSON.stringify(lineage, null, 2) + '\n') }]);
+    return { output, lineagePath, lineage };
+}

package/dist/model-preparation/bindings.js

@@ -0,0 +1,35 @@
+import { createModelAdaptationCore, inspectModelAdaptationSource, workspaceModelAdaptationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { digest } from './glb.js';
+/** Uses an actual caller-owned loader/engine scene. It neither fabricates geometry identities nor draws. */
+export async function inspectPreparedSplitBindings(input) {
+    if (digest(input.bytes) !== input.manifest.output.contentHash)
+        throw Error('model_preparation_output_hash_mismatch');
+    const source = { kind: 'resource', path: input.sourcePath, contentHash: digest(input.bytes), files: [{ path: input.sourcePath, contentHash: digest(input.bytes) }] };
+    const inventory = await inspectModelAdaptationSource({ source: input.scene, digestBytes: digest, animationCount: input.animationCount, signal: input.signal });
+    const ref = (role) => {
+        const expected = input.manifest.output.nodes.find(node => node.role === role);
+        const matches = inventory.nodes.filter(node => node.name === expected.name && node.sourceNodeId === expected.sourceNodeId);
+        if (matches.length !== 1)
+            throw Error('model_preparation_actual_node_identity_mismatch');
+        return { sourceNodeId: matches[0].sourceNodeId, geometryHash: matches[0].geometryHash };
+    };
+    const body = ref('body'), moving = ref('lid');
+    const plan = workspaceModelAdaptationSchema.parse({ schemaVersion: 1, source,
+        hinges: [{ id: 'primary', movingNodeRef: moving, bodyNodeRefs: [body], pivot: input.manifest.hinge.pivot,
+                axis: input.manifest.hinge.axis, openAngleDegrees: input.manifest.hinge.openAngleDegrees }] });
+    const factory = await createModelAdaptationCore({ THREE: input.THREE, source: input.scene, sourceIdentity: source, plan,
+        digestBytes: digest, animationCount: input.animationCount, signal: input.signal });
+    try {
+        const instance = factory.create();
+        try {
+            instance.setHinge('primary', plan.hinges[0].openAngleDegrees);
+        }
+        finally {
+            instance.dispose();
+        }
+    }
+    finally {
+        factory.release();
+    }
+    return { source, inventory, plan, observation: { kind: 'actual-engine-geometry-inspection', rendered: false, browserStarted: false, modelAcceptance: false } };
+}

package/dist/model-preparation/commands.js

@@ -0,0 +1,28 @@
+import { lstat, readFile, realpath } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { splitRigidModel } from './split-rigid.js';
+/** The caller registers this under its existing `playcraft 3d` parent. */
+export function registerModelPreparationCommands(parent) {
+    parent.command('split-rigid <model>')
+        .description('Prepare a new restricted rigid shell derivative; no rendering, inference or acceptance')
+        .requiredOption('--source-hash <sha256>', 'Expected immutable source digest')
+        .requiredOption('--config <json>', 'Explicit scene-plane, inner-shell and hinge configuration')
+        .requiredOption('--output <directory>', 'New output directory; existing directories are rejected')
+        .action(async (model, options) => {
+        try {
+            if (!/^[a-f0-9]{64}$/.test(options.sourceHash))
+                throw Error('model_preparation_source_hash_invalid');
+            const path = resolve(options.config), stat = await lstat(path);
+            if (await realpath(path) !== path || !stat.isFile() || stat.nlink !== 1 || stat.size > 65536)
+                throw Error('model_preparation_config_file_invalid');
+            const recipe = JSON.parse(await readFile(path, 'utf8'));
+            const result = await splitRigidModel({ sourcePath: resolve(model), expectedSourceHash: options.sourceHash, outputRoot: resolve(options.output), options: recipe });
+            process.stdout.write(JSON.stringify({ outputRoot: result.outputRoot, output: result.manifest.output, recipeHash: result.manifest.recipeHash,
+                geometryChecksPassed: true, visualAcceptance: false, browserAcceptance: false, modelAcceptance: false }, null, 2) + '\n');
+        }
+        catch (error) {
+            process.stderr.write((error instanceof Error ? error.message : 'model_preparation_failed') + '\n');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/model-preparation/geometry.js

@@ -0,0 +1,241 @@
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const mul = (a, n) => [a[0] * n, a[1] * n, a[2] * n];
+export const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+export 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]];
+export const length = (v) => Math.hypot(...v);
+export const unit = (v) => { const n = length(v); if (!Number.isFinite(n) || n < 1e-15)
+    throw Error('model_preparation_invalid_direction'); return mul(v, 1 / n); };
+export const f32 = (p) => p.map(v => Math.fround(v) || 0);
+export const pointKey = (p) => f32(p).join(',');
+export const area = (t) => length(cross(sub(t[1], t[0]), sub(t[2], t[0]))) / 2;
+export const volume = (ts) => ts.reduce((sum, t) => sum + dot(t[0], cross(t[1], t[2])) / 6, 0);
+export function bounds(ts) {
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (const t of ts)
+        for (const p of t)
+            for (let k = 0; k < 3; k++) {
+                min[k] = Math.min(min[k], p[k]);
+                max[k] = Math.max(max[k], p[k]);
+            }
+    return { min, max };
+}
+export function topology(triangles, epsilon) {
+    const vertices = new Map(), edgeFaces = new Map();
+    const ids = triangles.map(t => t.map(p => { const key = pointKey(p); if (!vertices.has(key))
+        vertices.set(key, vertices.size); return vertices.get(key); }));
+    let degenerate = 0;
+    triangles.forEach((t, i) => {
+        if (new Set(ids[i]).size !== 3 || area(t) <= epsilon * epsilon)
+            degenerate++;
+        const row = ids[i];
+        for (const [a, b] of [[row[0], row[1]], [row[1], row[2]], [row[2], row[0]]]) {
+            const key = a < b ? `${a}:${b}` : `${b}:${a}`, edge = edgeFaces.get(key) ?? { count: 0, direction: 0, faces: [] };
+            edge.count++;
+            edge.direction += a < b ? 1 : -1;
+            edge.faces.push(i);
+            edgeFaces.set(key, edge);
+        }
+    });
+    const parent = triangles.map((_, i) => i);
+    const find = (v) => parent[v] === v ? v : (parent[v] = find(parent[v]));
+    for (const e of edgeFaces.values())
+        for (const f of e.faces.slice(1))
+            parent[find(f)] = find(e.faces[0]);
+    const groups = new Map();
+    triangles.forEach((_, i) => { const key = find(i), list = groups.get(key) ?? []; list.push(i); groups.set(key, list); });
+    return { vertices: vertices.size, edges: edgeFaces.size, faces: triangles.length, degenerate,
+        boundaryEdges: [...edgeFaces.values()].filter(e => e.count === 1).length,
+        nonManifoldEdges: [...edgeFaces.values()].filter(e => e.count > 2).length,
+        inconsistentEdges: [...edgeFaces.values()].filter(e => e.count === 2 && e.direction !== 0).length,
+        components: [...groups.values()].sort((a, b) => b.length - a.length), signedVolume: volume(triangles) };
+}
+export function buildBvh(triangles, indices = triangles.map((_, i) => i)) {
+    const box = bounds(indices.map(i => triangles[i]));
+    if (indices.length <= 8)
+        return { ...box, indices };
+    const sizes = sub(box.max, box.min), axis = sizes.indexOf(Math.max(...sizes));
+    indices.sort((a, b) => triangles[a].reduce((s, p) => s + p[axis], 0) - triangles[b].reduce((s, p) => s + p[axis], 0));
+    const middle = Math.floor(indices.length / 2);
+    return { ...box, left: buildBvh(triangles, indices.slice(0, middle)), right: buildBvh(triangles, indices.slice(middle)) };
+}
+const boxDistanceSquared = (a, b) => a.min.reduce((sum, _, k) => sum + Math.max(0, a.min[k] - b.max[k], b.min[k] - a.max[k]) ** 2, 0);
+function pointSegmentSquared(p, a, b) {
+    const v = sub(b, a), denominator = dot(v, v), t = denominator ? Math.max(0, Math.min(1, dot(sub(p, a), v) / denominator)) : 0;
+    const d = sub(p, add(a, mul(v, t)));
+    return dot(d, d);
+}
+function insideTriangle(p, t, epsilon) {
+    const ab = sub(t[1], t[0]), ac = sub(t[2], t[0]), ap = sub(p, t[0]);
+    const aa = dot(ab, ab), bb = dot(ac, ac), abac = dot(ab, ac), denominator = aa * bb - abac * abac;
+    if (denominator <= 0)
+        return false;
+    const u = (bb * dot(ap, ab) - abac * dot(ap, ac)) / denominator;
+    const v = (aa * dot(ap, ac) - abac * dot(ap, ab)) / denominator;
+    const tolerance = epsilon / Math.max(Math.sqrt(aa), Math.sqrt(bb), epsilon);
+    return u >= -tolerance && v >= -tolerance && u + v <= 1 + tolerance;
+}
+function edgePlanePoints(t, other, normal, epsilon) {
+    const points = [];
+    for (let i = 0; i < 3; i++) {
+        const a = t[i], b = t[(i + 1) % 3], da = dot(sub(a, other[0]), normal), db = dot(sub(b, other[0]), normal);
+        if (Math.abs(da) <= epsilon && insideTriangle(a, other, epsilon))
+            points.push(a);
+        if (da * db < 0) {
+            const p = add(a, mul(sub(b, a), da / (da - db)));
+            if (insideTriangle(p, other, epsilon))
+                points.push(p);
+        }
+    }
+    return points;
+}
+function coplanarPoints(a, b, normal, epsilon) {
+    const points = [...a.filter(p => insideTriangle(p, b, epsilon)), ...b.filter(p => insideTriangle(p, a, epsilon))];
+    const axis = normal.map(Math.abs).indexOf(Math.max(...normal.map(Math.abs))), axes = [0, 1, 2].filter(k => k !== axis);
+    const cross2 = (x, y) => x[axes[0]] * y[axes[1]] - x[axes[1]] * y[axes[0]];
+    for (let i = 0; i < 3; i++)
+        for (let j = 0; j < 3; j++) {
+            const p = a[i], q = b[j], u = sub(a[(i + 1) % 3], p), v = sub(b[(j + 1) % 3], q), denominator = cross2(u, v);
+            if (Math.abs(denominator) <= epsilon * Math.max(length(u), length(v)))
+                continue;
+            const delta = sub(q, p), s = cross2(delta, v) / denominator, t = cross2(delta, u) / denominator;
+            if (s >= 0 && s <= 1 && t >= 0 && t <= 1)
+                points.push(add(p, mul(u, s)));
+        }
+    return points;
+}
+export function intersectionPoints(a, b, epsilon) {
+    const an = unit(cross(sub(a[1], a[0]), sub(a[2], a[0]))), bn = unit(cross(sub(b[1], b[0]), sub(b[2], b[0])));
+    const distances = b.map(p => dot(sub(p, a[0]), an));
+    if (distances.every(d => d > epsilon) || distances.every(d => d < -epsilon))
+        return [];
+    if (length(cross(an, bn)) <= 1e-8)
+        return distances.every(d => Math.abs(d) <= epsilon) ? coplanarPoints(a, b, an, epsilon) : [];
+    return [...edgePlanePoints(a, b, bn, epsilon), ...edgePlanePoints(b, a, an, epsilon)];
+}
+function forbiddenIntersection(a, b, epsilon) {
+    const shared = a.filter(p => b.some(q => pointKey(p) === pointKey(q)));
+    if (shared.length === 3)
+        return true;
+    const points = intersectionPoints(a, b, epsilon);
+    return points.some(p => shared.length === 0 || (shared.length === 1
+        ? length(sub(p, shared[0])) > epsilon * 4
+        : pointSegmentSquared(p, shared[0], shared[1]) > (epsilon * 4) ** 2));
+}
+export function findSelfIntersections(triangles, epsilon, maximumPairs = 10000, signal) {
+    const tree = buildBvh(triangles), pairs = [];
+    let tested = 0, truncated = false;
+    const visit = (a, b) => {
+        if (pairs.length >= maximumPairs) {
+            truncated = true;
+            return;
+        }
+        if (boxDistanceSquared(a, b) > epsilon * epsilon)
+            return;
+        signal?.throwIfAborted();
+        if (a === b && a.left) {
+            visit(a.left, a.left);
+            visit(a.left, a.right);
+            visit(a.right, a.right);
+            return;
+        }
+        if (a.indices && b.indices) {
+            for (const i of a.indices)
+                for (const j of b.indices) {
+                    if (a === b && i >= j)
+                        continue;
+                    if (boxDistanceSquared(bounds([triangles[i]]), bounds([triangles[j]])) > epsilon * epsilon)
+                        continue;
+                    tested++;
+                    if (forbiddenIntersection(triangles[i], triangles[j], epsilon)) {
+                        pairs.push([i, j]);
+                        if (pairs.length >= maximumPairs) {
+                            truncated = true;
+                            return;
+                        }
+                    }
+                }
+        }
+        else if (!b.indices && (a.indices || length(sub(b.max, b.min)) > length(sub(a.max, a.min)))) {
+            visit(a, b.left);
+            visit(a, b.right);
+        }
+        else {
+            visit(a.left, b);
+            visit(a.right, b);
+        }
+    };
+    visit(tree, tree);
+    return { testedPairs: tested, pairs, truncated };
+}
+export function assertNoSelfIntersections(triangles, epsilon, signal) {
+    const result = findSelfIntersections(triangles, epsilon, 1, signal);
+    if (result.pairs.length)
+        throw Error(`model_preparation_self_intersection:${result.pairs[0][0]}:${result.pairs[0][1]}`);
+    return { testedPairs: result.testedPairs };
+}
+function pointTriangleSquared(p, t) {
+    const n = unit(cross(sub(t[1], t[0]), sub(t[2], t[0]))), distance = dot(sub(p, t[0]), n), projected = sub(p, mul(n, distance));
+    if (insideTriangle(projected, t, 0))
+        return distance * distance;
+    return Math.min(...t.map((a, i) => pointSegmentSquared(p, a, t[(i + 1) % 3])));
+}
+function segmentsSquared(a, b, c, d) {
+    const u = sub(b, a), v = sub(d, c), w = sub(a, c), aa = dot(u, u), bb = dot(u, v), cc = dot(v, v), dd = dot(u, w), ee = dot(v, w), determinant = aa * cc - bb * bb;
+    let s = determinant > 1e-30 ? Math.max(0, Math.min(1, (bb * ee - cc * dd) / determinant)) : 0;
+    let t = cc ? (bb * s + ee) / cc : 0;
+    if (t < 0) {
+        t = 0;
+        s = aa ? Math.max(0, Math.min(1, -dd / aa)) : 0;
+    }
+    else if (t > 1) {
+        t = 1;
+        s = aa ? Math.max(0, Math.min(1, (bb - dd) / aa)) : 0;
+    }
+    const delta = sub(add(a, mul(u, s)), add(c, mul(v, t)));
+    return dot(delta, delta);
+}
+function triangleDistanceSquared(a, b, epsilon) {
+    if (intersectionPoints(a, b, epsilon).length)
+        return 0;
+    let value = Math.min(...a.map(p => pointTriangleSquared(p, b)), ...b.map(p => pointTriangleSquared(p, a)));
+    for (let i = 0; i < 3; i++)
+        for (let j = 0; j < 3; j++)
+            value = Math.min(value, segmentsSquared(a[i], a[(i + 1) % 3], b[j], b[(j + 1) % 3]));
+    return value;
+}
+export function assertClearance(inner, outer, minimum, epsilon, signal) {
+    const tree = buildBvh(outer), threshold = (minimum + epsilon * 4) ** 2;
+    let tested = 0;
+    for (let i = 0; i < inner.length; i++) {
+        signal?.throwIfAborted();
+        const a = inner[i], box = bounds([a]);
+        const visit = (node) => {
+            if (boxDistanceSquared(box, node) >= threshold)
+                return;
+            if (node.indices)
+                for (const j of node.indices) {
+                    if (boxDistanceSquared(box, bounds([outer[j]])) >= threshold)
+                        continue;
+                    tested++;
+                    if (triangleDistanceSquared(a, outer[j], epsilon) < threshold)
+                        throw Error(`model_preparation_thickness_unproven:${i}:${j}`);
+                }
+            else {
+                visit(node.left);
+                visit(node.right);
+            }
+        };
+        visit(tree);
+    }
+    return { provenLowerBound: minimum, testedPairs: tested };
+}
+export function windingNumber(point, triangles) {
+    let angle = 0;
+    for (const t of triangles) {
+        const a = sub(t[0], point), b = sub(t[1], point), c = sub(t[2], point);
+        const denominator = length(a) * length(b) * length(c) + dot(a, b) * length(c) + dot(b, c) * length(a) + dot(c, a) * length(b);
+        angle += 2 * Math.atan2(dot(a, cross(b, c)), denominator);
+    }
+    return angle / (4 * Math.PI);
+}