@series-inc/rundot-syncplay 6.0.0-rc.43 → 6.0.0-rc.44

package/MIGRATING-RC41-TO-RC42.md

@@ -0,0 +1,9 @@
+# Syncplay rc.42
+
+This release adds multiplayer physical assemblies and a 3D physics runtime bridge:
+- `createSyncplayPhysicalAssemblySlice`, `stepSyncplayPhysicalAssembly`, and `projectSyncplayPhysicalAssembly` under `@series-inc/rundot-syncplay/modules/physical-assembly`.
+- Authoritative Ultrahand glue, detach, and rotate operations with deterministic events.
+- Recall trajectory recording and kinematic rewinds via `createSyncplayBodyPoseTrack3D`.
+- Orientation hold controller (`createOrientationHold3D`) and kinematic path drive (`createKinematicPathDrive3D`) in 3D physics.
+- Authoritative Rapier physics bridge (`createPhysicalAssemblyBridge3D`) linking assembly events to 3D world state.
+- Disconnect recovery to release holds and active recalls on slot departure.

package/MIGRATING-RC42-TO-RC43.md

@@ -0,0 +1,32 @@
+# Syncplay rc.43
+
+This release introduces deterministic dynamic seating and player-keyed secret authority:
+
+## Dynamic Seat Control
+- Rooms can configure dynamic slot policies via `deterministic.seatPolicy`:
+  - `recycleVacatedSeats`: boolean (default `false`). When `true`, vacated seats can be claimed by new joining players.
+  - `allowHumanClaimBot`: boolean (default `false`). When `true`, new human players can take over bot-controlled slots (transition S3). Returning original owners with retained claims can always reclaim their own seat regardless of this setting.
+  - `onHumanLeave`: `'empty' | 'bot'` (default `'empty'`). Dictates slot controller when a human player disconnects or departs.
+  - `initialBotSlots`: array of slot numbers controlled by bots at match start.
+- Full state machine supporting transitions S1 through S6:
+  - `S1_empty_to_bot`
+  - `S2_empty_to_human`
+  - `S3_bot_to_human`
+  - `S4_bot_to_empty`
+  - `S5_human_to_bot`
+  - `S6_human_to_empty`
+- Authority-issued controller leases: each human and bot controller receives an immutable, room-scoped lease (`claimId`, `botLeaseId`, and `controlEpoch`). Outgoing leases are revoked prior to successor admission.
+
+## Player-Keyed Secret Authority
+- Private holdings (cards, items, secret roles, and choice commitments) are strictly bound to authenticated `playerId` and `claimId`, rather than bare slot indices.
+- Unconsumed holdings are permanently revoked upon final departure from recyclable seats.
+- Successor players occupying recycled slots never inherit prior secrets or assigned hidden roles.
+- Role arrays are sized dynamically by simulation capacity `X`, removing the previous 16-player secret limit while preserving byte and snapshot budgets.
+
+## Durable Recovery & Fencing
+- Critical seat transitions and claim modifications use monotonic revision fencing in `StateStore.saveCritical`.
+- Stored snapshots round-trip version 4 records containing explicit `seatCheckpoint` states.
+- Storage read errors fail closed to prevent accidental overwrites or fresh worker starts over existing persistent rooms.
+
+## Match Log v2
+- Match logs now support version 2 formatting with explicit `claimAttributions` mapping each confirmed input frame to the active controller claim.

package/MIGRATING-RC43-TO-RC44.md

@@ -0,0 +1,19 @@
+# Syncplay rc.44
+
+This candidate release introduces authoring and tooling gap closures across physics and presentation:
+
+## Physics Debug Overlay 3D
+- Introduced `createPhysicsDebugOverlay3D` in `@series-inc/rundot-syncplay/physics/3d` and `@series-inc/rundot-syncplay`.
+- Supports read-only extraction of wireframe geometry, contact records, joint state, and sensors from `PhysicsWorld3D` without mutating physics state or invalidating simulation digests.
+- Provides strict type definitions: `PhysicsDebugOverlay3D`, `PhysicsDebugOverlayOptions3D`, `PhysicsDebugWireframeShape3D`, `PhysicsDebugContactRecord3D`, and `PhysicsDebugJointRecord3D`.
+- Supports R3F wireframe rendering adapters and budgeting controls (`maxShapes`, `maxVertices`, `maxContacts`, `maxJoints`, `maxSensors`).
+
+## Collider Preparation
+- Introduced pure deterministic geometry cooking and validation in `collider-preparation.ts`.
+- Validates coplanar faces, non-manifold edges, slivers, and degenerate polygons before registration with the native physics solver.
+
+## Navmesh Geometry Cooking
+- Added headless geometry cooking tools for dynamic navmesh generation in `navmesh.ts`.
+
+## Presentation Inverse Kinematics
+- Added two-bone presentation inverse kinematics solver in `presentation-ik.ts` with joint constraints and pole targets.

package/core/src/physics/physics-profile-wasm-module.generated.mjs

@@ -23,7 +23,7 @@ export const physicsProfileWasmMetadata = Object.freeze({
   "sourceHash": "095061366ce3734601d06d48fa61d88a8538e1ba01e9c47663a7303ddb18fee7",
   "wasmSha256": "4b2ac3ff7d0f7a15eb31f5742a90f16f458a906d5d41bdc5fbde03e5589f94bf",
   "artifact": "profile",
-  "packageVersion": "6.0.0-rc.43",
+  "packageVersion": "6.0.0-rc.44",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/core/src/physics/physics-wasm-module.generated.mjs

@@ -23,7 +23,7 @@ export const physicsWasmMetadata = Object.freeze({
   "sourceHash": "38d5f2cde9e8d448f029fd2921a743e4a40e19dc84c03abf7bed829003e2469d",
   "wasmSha256": "5f6a3d861cf3eb79a2f8060d6c4b5512673a943044a52a9d20b39f0f2fef985f",
   "artifact": "production",
-  "packageVersion": "6.0.0-rc.43",
+  "packageVersion": "6.0.0-rc.44",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/core/src/physics2d/physics2d-wasm-module.generated.mjs

@@ -50,7 +50,7 @@ export const physics2dWasmMetadata = Object.freeze({
   "sourceHash": "faa090a03a6fddaf79c704fb1d76f810955ff35597449c8cec9541a75905a37e",
   "wasmSha256": "49cb90541deed40f5fff1015bb578e13ec9a793d51931c1227e3e5a11bbfa3f7",
   "artifact": "production",
-  "packageVersion": "6.0.0-rc.43",
+  "packageVersion": "6.0.0-rc.44",
   "compilerFlags": [
     "-std=c++20",
     "-O3",

package/dist/browser.d.ts

@@ -19,7 +19,7 @@ export { createDeterministicMath } from './math.js';
 export { rewindDeterministicTargets, runDeterministicMovementCrowdSimulation, runDeterministicMovementSimulation, stepDeterministicFpsAim, stepDeterministicKcc2D, stepDeterministicTopDownMover, validateDeterministicLagCompensatedHit } from './movement.js';
 export { stepDeterministicCarry3D, stepDeterministicKcc3D } from './movement3d.js';
 export { applyDeterministicReciprocalAvoidance, cookDeterministicNavigationGraph, cookTilemapNavigationGraph, createDeterministicFlowField, findDeterministicPath, smoothDeterministicPath, stepDeterministicNavigationAgents } from './navigation.js';
-export { cookDeterministicNavmesh, cookImportedDeterministicNavmesh, findDeterministicNavmeshPath, findDeterministicNavmeshPointPath, locateDeterministicNavmeshPolygon, runDeterministicNavmeshStress, smoothDeterministicNavmeshPath, stepDeterministicNavmeshAgents, stepDeterministicNavmeshOffMeshTraversal } from './navmesh.js';
+export { cookDeterministicNavmesh, cookDeterministicNavmeshFromGeometry, cookImportedDeterministicNavmesh, findDeterministicNavmeshPath, findDeterministicNavmeshPointPath, locateDeterministicNavmeshPolygon, runDeterministicNavmeshStress, smoothDeterministicNavmeshPath, stepDeterministicNavmeshAgents, stepDeterministicNavmeshOffMeshTraversal } from './navmesh.js';
 export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from './networked-client.js';
 export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
@@ -84,3 +84,6 @@ export type { MultiplayerApi, JoinTicketRequest } from '@series-inc/rundot-game-
 export { openSyncplayBrowserRoom, resolveSyncplayBrowserIntent, shareSyncplayRoom, } from './browserSession.js';
 export type { OpenSyncplayBrowserRoomOptions, OpenSyncplayBrowserRoomResult, ResolveSyncplayBrowserIntentOptions, SyncplayBrowserApi, SyncplayBrowserIntent, } from './browserSession.js';
 export { SyncplayRuntimeLeaseRequiredError } from './runtime-cleanup.js';
+export type { DeterministicNavmeshGeometrySource, DeterministicNavmeshGeometryOptions } from './navmesh.js';
+export { solveTwoBoneIk3D, solveFootPlanting3D, } from './presentation-ik.js';
+export type { TwoBoneIkInput3D, TwoBoneIkOutput3D, FootPlantingInput3D, FootPlantingOutput3D, Vec3PresentationIK, QuatPresentationIK, } from './presentation-ik.js';

package/dist/browser.js

@@ -20,7 +20,7 @@ export { createDeterministicMath } from './math.js';
 export { rewindDeterministicTargets, runDeterministicMovementCrowdSimulation, runDeterministicMovementSimulation, stepDeterministicFpsAim, stepDeterministicKcc2D, stepDeterministicTopDownMover, validateDeterministicLagCompensatedHit } from './movement.js';
 export { stepDeterministicCarry3D, stepDeterministicKcc3D } from './movement3d.js';
 export { applyDeterministicReciprocalAvoidance, cookDeterministicNavigationGraph, cookTilemapNavigationGraph, createDeterministicFlowField, findDeterministicPath, smoothDeterministicPath, stepDeterministicNavigationAgents } from './navigation.js';
-export { cookDeterministicNavmesh, cookImportedDeterministicNavmesh, findDeterministicNavmeshPath, findDeterministicNavmeshPointPath, locateDeterministicNavmeshPolygon, runDeterministicNavmeshStress, smoothDeterministicNavmeshPath, stepDeterministicNavmeshAgents, stepDeterministicNavmeshOffMeshTraversal } from './navmesh.js';
+export { cookDeterministicNavmesh, cookDeterministicNavmeshFromGeometry, cookImportedDeterministicNavmesh, findDeterministicNavmeshPath, findDeterministicNavmeshPointPath, locateDeterministicNavmeshPolygon, runDeterministicNavmeshStress, smoothDeterministicNavmeshPath, stepDeterministicNavmeshAgents, stepDeterministicNavmeshOffMeshTraversal } from './navmesh.js';
 export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from './networked-client.js';
 export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
@@ -49,3 +49,4 @@ export { WsMultiplayerApi } from '@series-inc/rundot-game-sdk/mp-client';
 // (RundotGameAPI comes from the SDK — syncplay may depend on the SDK).
 export { openSyncplayBrowserRoom, resolveSyncplayBrowserIntent, shareSyncplayRoom, } from './browserSession.js';
 export { SyncplayRuntimeLeaseRequiredError } from './runtime-cleanup.js';
+export { solveTwoBoneIk3D, solveFootPlanting3D, } from './presentation-ik.js';

package/dist/collider-preparation.d.ts

@@ -0,0 +1,31 @@
+import { type ColliderSourceMesh } from './collider-cooking.js';
+export interface Point3D {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export interface ColliderPreparationOptions {
+    readonly minArea?: number;
+    readonly minEdge?: number;
+    readonly resolution?: number;
+    readonly quantum?: number;
+}
+export interface ColliderPreparedPart {
+    readonly normal: Point3D;
+    readonly boundaries: readonly (readonly Point3D[])[];
+    readonly area: number;
+    readonly isHole?: boolean;
+}
+export interface ColliderPreparationRemovedStats {
+    readonly degenerate: number;
+    readonly interior: number;
+    readonly coplanar: number;
+    readonly contained: number;
+}
+export interface ColliderPreparationResult {
+    readonly triangles: readonly (readonly [Point3D, Point3D, Point3D])[];
+    readonly parts: readonly ColliderPreparedPart[];
+    readonly digest: string;
+    readonly removed: ColliderPreparationRemovedStats;
+}
+export declare function prepareColliderMesh(source: ColliderSourceMesh, options?: ColliderPreparationOptions): ColliderPreparationResult;

package/dist/collider-preparation.js

@@ -0,0 +1,506 @@
+import { defaultChecksum } from './canonical.js';
+import { __colliderCookingInternals } from './collider-cooking.js';
+function normalizeZero(v) {
+    return Object.is(v, -0) ? 0 : v;
+}
+function quantize(value, q) {
+    return normalizeZero(Math.round(value / q) * q);
+}
+function quantizePoint(p, q) {
+    return Object.freeze({
+        x: quantize(p.x, q),
+        y: quantize(p.y, q),
+        z: quantize(p.z, q),
+    });
+}
+function comparePoints(a, b) {
+    if (Math.abs(a.x - b.x) > 1e-9)
+        return a.x - b.x;
+    if (Math.abs(a.y - b.y) > 1e-9)
+        return a.y - b.y;
+    if (Math.abs(a.z - b.z) > 1e-9)
+        return a.z - b.z;
+    return 0;
+}
+function pointKey(p) {
+    return `${p.x},${p.y},${p.z}`;
+}
+function sortTriangleVertices(tri) {
+    const sorted = [...tri].sort(comparePoints);
+    return [sorted[0], sorted[1], sorted[2]];
+}
+function canonicalizeTriangle(tri) {
+    let minIdx = 0;
+    if (comparePoints(tri[1], tri[minIdx]) < 0)
+        minIdx = 1;
+    if (comparePoints(tri[2], tri[minIdx]) < 0)
+        minIdx = 2;
+    if (minIdx === 1)
+        return [tri[1], tri[2], tri[0]];
+    if (minIdx === 2)
+        return [tri[2], tri[0], tri[1]];
+    return tri;
+}
+function compareTriangles(a, b) {
+    const sA = sortTriangleVertices(a);
+    const sB = sortTriangleVertices(b);
+    for (let i = 0; i < 3; i += 1) {
+        const cmp = comparePoints(sA[i], sB[i]);
+        if (cmp !== 0)
+            return cmp;
+    }
+    return 0;
+}
+function triangleCross(p0, p1, p2) {
+    const e1x = p1.x - p0.x, e1y = p1.y - p0.y, e1z = p1.z - p0.z;
+    const e2x = p2.x - p0.x, e2y = p2.y - p0.y, e2z = p2.z - p0.z;
+    return {
+        x: e1y * e2z - e1z * e2y,
+        y: e1z * e2x - e1x * e2z,
+        z: e1x * e2y - e1y * e2x,
+    };
+}
+function triangleArea(p0, p1, p2) {
+    const c = triangleCross(p0, p1, p2);
+    return 0.5 * Math.hypot(c.x, c.y, c.z);
+}
+function triangleShortestEdge(p0, p1, p2) {
+    const d0 = Math.hypot(p1.x - p0.x, p1.y - p0.y, p1.z - p0.z);
+    const d1 = Math.hypot(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z);
+    const d2 = Math.hypot(p0.x - p2.x, p0.y - p2.y, p0.z - p2.z);
+    return Math.min(d0, d1, d2);
+}
+function planeKey(normal, d, normalQuantum = 1e-4, distQuantum = 1e-3) {
+    const qnx = quantize(normal.x, normalQuantum);
+    const qny = quantize(normal.y, normalQuantum);
+    const qnz = quantize(normal.z, normalQuantum);
+    const qd = quantize(d, distQuantum);
+    return `${qnx},${qny},${qnz}:${qd}`;
+}
+export function prepareColliderMesh(source, options = {}) {
+    const vertices = source.vertices;
+    if (!Array.isArray(vertices) || vertices.length % 3 !== 0) {
+        throw new Error('prepareColliderMesh: source requires triangle-list vertices (a positive multiple of 3)');
+    }
+    if (vertices.length === 0) {
+        return Object.freeze({
+            triangles: Object.freeze([]),
+            parts: Object.freeze([]),
+            digest: defaultChecksum([]),
+            removed: Object.freeze({
+                degenerate: 0,
+                interior: 0,
+                coplanar: 0,
+                contained: 0,
+            }),
+        });
+    }
+    for (const v of vertices) {
+        if (!Number.isFinite(v.x) || !Number.isFinite(v.y) || !Number.isFinite(v.z)) {
+            throw new Error('prepareColliderMesh: source contains a non-finite vertex');
+        }
+    }
+    const quantum = options.quantum ?? (1 / 1024);
+    const resolution = options.resolution ?? 16;
+    const minArea = options.minArea ?? 0;
+    const minEdge = options.minEdge ?? 0;
+    let removedDegenerate = 0;
+    let removedInterior = 0;
+    let removedCoplanar = 0;
+    let removedContained = 0;
+    // Stage 1: Degenerate removal
+    const rawTriangles = [];
+    for (let i = 0; i < vertices.length; i += 3) {
+        const p0 = quantizePoint(vertices[i], quantum);
+        const p1 = quantizePoint(vertices[i + 1], quantum);
+        const p2 = quantizePoint(vertices[i + 2], quantum);
+        const area = triangleArea(p0, p1, p2);
+        const shortestEdge = triangleShortestEdge(p0, p1, p2);
+        if (area < minArea || shortestEdge < minEdge || area <= 1e-12 || shortestEdge <= 1e-12) {
+            removedDegenerate += 1;
+            continue;
+        }
+        rawTriangles.push([p0, p1, p2]);
+    }
+    if (rawTriangles.length === 0) {
+        return Object.freeze({
+            triangles: Object.freeze([]),
+            parts: Object.freeze([]),
+            digest: defaultChecksum([]),
+            removed: Object.freeze({
+                degenerate: removedDegenerate,
+                interior: 0,
+                coplanar: 0,
+                contained: 0,
+            }),
+        });
+    }
+    // Detect and remove contained components (nested parts)
+    // 1. Group triangles into connected components via vertex sharing
+    const vertToTriangles = new Map();
+    for (let triIdx = 0; triIdx < rawTriangles.length; triIdx += 1) {
+        const tri = rawTriangles[triIdx];
+        for (const v of tri) {
+            const vk = pointKey(v);
+            let list = vertToTriangles.get(vk);
+            if (!list) {
+                list = [];
+                vertToTriangles.set(vk, list);
+            }
+            list.push(triIdx);
+        }
+    }
+    const visitedTriangles = new Uint8Array(rawTriangles.length);
+    const components = [];
+    for (let i = 0; i < rawTriangles.length; i += 1) {
+        if (visitedTriangles[i] !== 0)
+            continue;
+        const compIndices = [];
+        const queue = [i];
+        visitedTriangles[i] = 1;
+        let cMinX = Infinity, cMinY = Infinity, cMinZ = Infinity;
+        let cMaxX = -Infinity, cMaxY = -Infinity, cMaxZ = -Infinity;
+        while (queue.length > 0) {
+            const curr = queue.pop();
+            compIndices.push(curr);
+            const tri = rawTriangles[curr];
+            for (const v of tri) {
+                cMinX = Math.min(cMinX, v.x);
+                cMaxX = Math.max(cMaxX, v.x);
+                cMinY = Math.min(cMinY, v.y);
+                cMaxY = Math.max(cMaxY, v.y);
+                cMinZ = Math.min(cMinZ, v.z);
+                cMaxZ = Math.max(cMaxZ, v.z);
+                const neighbors = vertToTriangles.get(pointKey(v));
+                if (neighbors) {
+                    for (const nb of neighbors) {
+                        if (visitedTriangles[nb] === 0) {
+                            visitedTriangles[nb] = 1;
+                            queue.push(nb);
+                        }
+                    }
+                }
+            }
+        }
+        components.push({
+            indices: compIndices,
+            minX: cMinX, maxX: cMaxX,
+            minY: cMinY, maxY: cMaxY,
+            minZ: cMinZ, maxZ: cMaxZ,
+        });
+    }
+    // Check which components are strictly contained within another component's bounding box
+    const containedComponentSet = new Set();
+    for (let i = 0; i < components.length; i += 1) {
+        const compB = components[i];
+        for (let j = 0; j < components.length; j += 1) {
+            if (i === j)
+                continue;
+            const compA = components[j];
+            const eps = 1e-4;
+            if (compA.minX < compB.minX - eps && compB.maxX + eps < compA.maxX &&
+                compA.minY < compB.minY - eps && compB.maxY + eps < compA.maxY &&
+                compA.minZ < compB.minZ - eps && compB.maxZ + eps < compA.maxZ) {
+                containedComponentSet.add(i);
+                break;
+            }
+        }
+    }
+    removedContained = containedComponentSet.size;
+    const survivingTriangles = [];
+    for (let c = 0; c < components.length; c += 1) {
+        if (containedComponentSet.has(c))
+            continue;
+        for (const idx of components[c].indices) {
+            survivingTriangles.push(rawTriangles[idx]);
+        }
+    }
+    // Stage 2: Interior removal
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (const tri of survivingTriangles) {
+        for (const v of tri) {
+            minX = Math.min(minX, v.x);
+            maxX = Math.max(maxX, v.x);
+            minY = Math.min(minY, v.y);
+            maxY = Math.max(maxY, v.y);
+            minZ = Math.min(minZ, v.z);
+            maxZ = Math.max(maxZ, v.z);
+        }
+    }
+    const extent = Math.max(maxX - minX, maxY - minY, maxZ - minZ);
+    const voxelSize = extent > 0 ? extent / resolution : 1;
+    const originX = minX - voxelSize;
+    const originY = minY - voxelSize;
+    const originZ = minZ - voxelSize;
+    const nx = Math.max(1, Math.ceil((maxX - minX) / voxelSize)) + 2;
+    const ny = Math.max(1, Math.ceil((maxY - minY) / voxelSize)) + 2;
+    const nz = Math.max(1, Math.ceil((maxZ - minZ) / voxelSize)) + 2;
+    const cells = new Uint8Array(nx * ny * nz);
+    const at = (x, y, z) => (z * ny + y) * nx + x;
+    const clampIndex = (val, max) => Math.max(0, Math.min(max - 1, val));
+    const SURFACE = 1;
+    const EXTERIOR = 2;
+    const half = voxelSize / 2;
+    for (const tri of survivingTriangles) {
+        const x0 = clampIndex(Math.floor((Math.min(tri[0].x, tri[1].x, tri[2].x) - originX) / voxelSize), nx);
+        const x1 = clampIndex(Math.floor((Math.max(tri[0].x, tri[1].x, tri[2].x) - originX) / voxelSize), nx);
+        const y0 = clampIndex(Math.floor((Math.min(tri[0].y, tri[1].y, tri[2].y) - originY) / voxelSize), ny);
+        const y1 = clampIndex(Math.floor((Math.max(tri[0].y, tri[1].y, tri[2].y) - originY) / voxelSize), ny);
+        const z0 = clampIndex(Math.floor((Math.min(tri[0].z, tri[1].z, tri[2].z) - originZ) / voxelSize), nz);
+        const z1 = clampIndex(Math.floor((Math.max(tri[0].z, tri[1].z, tri[2].z) - originZ) / voxelSize), nz);
+        for (let z = z0; z <= z1; z += 1) {
+            for (let y = y0; y <= y1; y += 1) {
+                for (let x = x0; x <= x1; x += 1) {
+                    const center = {
+                        x: originX + (x + 0.5) * voxelSize,
+                        y: originY + (y + 0.5) * voxelSize,
+                        z: originZ + (z + 0.5) * voxelSize,
+                    };
+                    if (__colliderCookingInternals.triangleIntersectsBox(tri, center, half)) {
+                        cells[at(x, y, z)] = SURFACE;
+                    }
+                }
+            }
+        }
+    }
+    // Flood fill exterior
+    const stack = [];
+    const pushIfOpen = (x, y, z) => {
+        const idx = at(x, y, z);
+        if (cells[idx] === 0) {
+            cells[idx] = EXTERIOR;
+            stack.push(idx);
+        }
+    };
+    for (let z = 0; z < nz; z += 1) {
+        for (let y = 0; y < ny; y += 1) {
+            for (let x = 0; x < nx; x += 1) {
+                if (x === 0 || x === nx - 1 || y === 0 || y === ny - 1 || z === 0 || z === nz - 1) {
+                    pushIfOpen(x, y, z);
+                }
+            }
+        }
+    }
+    while (stack.length > 0) {
+        const curr = stack.pop();
+        const cx = curr % nx;
+        const cy = Math.floor(curr / nx) % ny;
+        const cz = Math.floor(curr / (nx * ny));
+        if (cx > 0)
+            pushIfOpen(cx - 1, cy, cz);
+        if (cx + 1 < nx)
+            pushIfOpen(cx + 1, cy, cz);
+        if (cy > 0)
+            pushIfOpen(cx, cy - 1, cz);
+        if (cy + 1 < ny)
+            pushIfOpen(cx, cy + 1, cz);
+        if (cz > 0)
+            pushIfOpen(cx, cy, cz - 1);
+        if (cz + 1 < nz)
+            pushIfOpen(cx, cy, cz + 1);
+    }
+    // Filter out triangles whose surrounding neighborhood touches no EXTERIOR cells
+    const surfaceTriangles = [];
+    for (const tri of survivingTriangles) {
+        const cross = triangleCross(tri[0], tri[1], tri[2]);
+        const len = Math.hypot(cross.x, cross.y, cross.z);
+        if (len <= 1e-12) {
+            removedInterior += 1;
+            continue;
+        }
+        const n = { x: cross.x / len, y: cross.y / len, z: cross.z / len };
+        const mid = {
+            x: (tri[0].x + tri[1].x + tri[2].x) / 3,
+            y: (tri[0].y + tri[1].y + tri[2].y) / 3,
+            z: (tri[0].z + tri[1].z + tri[2].z) / 3,
+        };
+        const p1 = {
+            x: Math.floor((mid.x + n.x * voxelSize - originX) / voxelSize),
+            y: Math.floor((mid.y + n.y * voxelSize - originY) / voxelSize),
+            z: Math.floor((mid.z + n.z * voxelSize - originZ) / voxelSize),
+        };
+        const p2 = {
+            x: Math.floor((mid.x - n.x * voxelSize - originX) / voxelSize),
+            y: Math.floor((mid.y - n.y * voxelSize - originY) / voxelSize),
+            z: Math.floor((mid.z - n.z * voxelSize - originZ) / voxelSize),
+        };
+        const c1 = (p1.x >= 0 && p1.x < nx && p1.y >= 0 && p1.y < ny && p1.z >= 0 && p1.z < nz) ? cells[at(p1.x, p1.y, p1.z)] : EXTERIOR;
+        const c2 = (p2.x >= 0 && p2.x < nx && p2.y >= 0 && p2.y < ny && p2.z >= 0 && p2.z < nz) ? cells[at(p2.x, p2.y, p2.z)] : EXTERIOR;
+        if (c1 === EXTERIOR || c2 === EXTERIOR) {
+            surfaceTriangles.push(tri);
+        }
+        else {
+            removedInterior += 1;
+        }
+    }
+    // Stage 3: Coplanar merge
+    // Group triangles by plane
+    const planeGroups = new Map();
+    for (const tri of surfaceTriangles) {
+        const cross = triangleCross(tri[0], tri[1], tri[2]);
+        const len = Math.hypot(cross.x, cross.y, cross.z);
+        if (len <= 1e-12)
+            continue;
+        const normal = {
+            x: normalizeZero(cross.x / len),
+            y: normalizeZero(cross.y / len),
+            z: normalizeZero(cross.z / len),
+        };
+        const d = normal.x * tri[0].x + normal.y * tri[0].y + normal.z * tri[0].z;
+        const key = planeKey(normal, d);
+        let group = planeGroups.get(key);
+        if (!group) {
+            const flippedKey = planeKey({ x: -normal.x, y: -normal.y, z: -normal.z }, -d);
+            if (planeGroups.has(flippedKey)) {
+                group = planeGroups.get(flippedKey);
+            }
+        }
+        if (!group) {
+            group = { normal, d, triangles: [] };
+            planeGroups.set(key, group);
+        }
+        group.triangles.push(tri);
+    }
+    const parts = [];
+    const finalTriangles = [];
+    // Sort plane keys deterministically
+    const sortedPlaneKeys = Array.from(planeGroups.keys()).sort();
+    for (const pKey of sortedPlaneKeys) {
+        const group = planeGroups.get(pKey);
+        const groupTriangles = group.triangles;
+        // Build directed edge map
+        const edgeCounts = new Map();
+        const edgeKey = (a, b) => `${pointKey(a)}->${pointKey(b)}`;
+        for (const tri of groupTriangles) {
+            for (let i = 0; i < 3; i += 1) {
+                const from = tri[i];
+                const to = tri[(i + 1) % 3];
+                const k = edgeKey(from, to);
+                const existing = edgeCounts.get(k);
+                if (existing) {
+                    existing.count += 1;
+                }
+                else {
+                    edgeCounts.set(k, { from, to, count: 1 });
+                }
+            }
+        }
+        // Cancel shared interior edges (a->b and b->a)
+        let sharedEdges = 0;
+        const boundaryEdges = [];
+        const processedPairs = new Set();
+        for (const [k, e] of edgeCounts.entries()) {
+            if (processedPairs.has(k))
+                continue;
+            const reverseK = edgeKey(e.to, e.from);
+            const rev = edgeCounts.get(reverseK);
+            if (rev) {
+                processedPairs.add(k);
+                processedPairs.add(reverseK);
+                const shared = Math.min(e.count, rev.count);
+                sharedEdges += shared;
+                const diffForward = e.count - shared;
+                const diffRev = rev.count - shared;
+                for (let i = 0; i < diffForward; i += 1)
+                    boundaryEdges.push({ from: e.from, to: e.to });
+                for (let i = 0; i < diffRev; i += 1)
+                    boundaryEdges.push({ from: rev.from, to: rev.to });
+            }
+            else {
+                processedPairs.add(k);
+                for (let i = 0; i < e.count; i += 1)
+                    boundaryEdges.push({ from: e.from, to: e.to });
+            }
+        }
+        if (groupTriangles.length > 1 && sharedEdges > 0) {
+            removedCoplanar += sharedEdges;
+        }
+        // Chain boundary edges into loops
+        const adj = new Map();
+        for (const e of boundaryEdges) {
+            const fk = pointKey(e.from);
+            let list = adj.get(fk);
+            if (!list) {
+                list = [];
+                adj.set(fk, list);
+            }
+            list.push(e.to);
+        }
+        const visitedEdges = new Set();
+        const loops = [];
+        // Sort starting points deterministically
+        const sortedStarts = Array.from(adj.keys()).sort();
+        for (const startKey of sortedStarts) {
+            const targets = adj.get(startKey);
+            for (const target of targets) {
+                const ek = `${startKey}->${pointKey(target)}`;
+                if (visitedEdges.has(ek))
+                    continue;
+                const loop = [];
+                let currStr = startKey;
+                let nextPt = target;
+                while (nextPt) {
+                    const nextStr = pointKey(nextPt);
+                    const currentEdgeKey = `${currStr}->${nextStr}`;
+                    if (visitedEdges.has(currentEdgeKey))
+                        break;
+                    visitedEdges.add(currentEdgeKey);
+                    loop.push(nextPt);
+                    currStr = nextStr;
+                    const nextList = adj.get(currStr);
+                    if (!nextList || nextList.length === 0)
+                        break;
+                    nextPt = nextList.find((cand) => !visitedEdges.has(`${currStr}->${pointKey(cand)}`));
+                    if (nextStr === startKey)
+                        break;
+                }
+                if (loop.length >= 3) {
+                    loops.push(loop);
+                }
+            }
+        }
+        // Compute total area for the plane
+        let totalPlaneArea = 0;
+        for (const tri of groupTriangles) {
+            totalPlaneArea += triangleArea(tri[0], tri[1], tri[2]);
+            finalTriangles.push(canonicalizeTriangle(tri));
+        }
+        if (loops.length > 0) {
+            parts.push(Object.freeze({
+                normal: Object.freeze(group.normal),
+                boundaries: Object.freeze(loops.map((l) => Object.freeze(l))),
+                area: totalPlaneArea,
+            }));
+        }
+    }
+    // Sort triangles and parts deterministically
+    finalTriangles.sort(compareTriangles);
+    parts.sort((a, b) => {
+        const cmpN = comparePoints(a.normal, b.normal);
+        if (cmpN !== 0)
+            return cmpN;
+        if (Math.abs(b.area - a.area) > 1e-4)
+            return b.area - a.area;
+        return a.boundaries.length - b.boundaries.length;
+    });
+    const digest = defaultChecksum({
+        triangles: finalTriangles.map((t) => sortTriangleVertices(t)),
+        parts: parts.map((p) => ({
+            normal: p.normal,
+            area: quantize(p.area, 1e-4),
+            boundaryCount: p.boundaries.length,
+        })),
+    });
+    return Object.freeze({
+        triangles: Object.freeze(finalTriangles),
+        parts: Object.freeze(parts),
+        digest,
+        removed: Object.freeze({
+            degenerate: removedDegenerate,
+            interior: removedInterior,
+            coplanar: removedCoplanar,
+            contained: removedContained,
+        }),
+    });
+}