@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/physics3d.js

@@ -0,0 +1,1996 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deterministicPhysicsCallback3D = void 0;
+exports.createDeterministicPhysicsWorld3D = createDeterministicPhysicsWorld3D;
+exports.stepDeterministicPhysicsWorld3D = stepDeterministicPhysicsWorld3D;
+exports.raycastDeterministicPhysics3D = raycastDeterministicPhysics3D;
+exports.raycastDeterministicPhysics3DDetailed = raycastDeterministicPhysics3DDetailed;
+exports.overlapDeterministicPhysics3D = overlapDeterministicPhysics3D;
+exports.shapeCastDeterministicPhysics3D = shapeCastDeterministicPhysics3D;
+exports.shapeCastDeterministicPhysics3DDetailed = shapeCastDeterministicPhysics3DDetailed;
+exports.contactDetailsDeterministicPhysics3D = contactDetailsDeterministicPhysics3D;
+exports.runDeterministicPhysics3DCallbackMaskFixture = runDeterministicPhysics3DCallbackMaskFixture;
+exports.runDeterministicPhysics3DQueryOptionsFixture = runDeterministicPhysics3DQueryOptionsFixture;
+exports.runDeterministicPhysics3DMaterialFixture = runDeterministicPhysics3DMaterialFixture;
+exports.runDeterministicPhysics3DDetailFixture = runDeterministicPhysics3DDetailFixture;
+exports.runDeterministicPhysics3DStress = runDeterministicPhysics3DStress;
+exports.runDeterministicPhysics3DStackFixture = runDeterministicPhysics3DStackFixture;
+const canonical_js_1 = require("./canonical.js");
+const deterministic_primitives_js_1 = require("./deterministic-primitives.js");
+exports.deterministicPhysicsCallback3D = {
+    collisionEnter: 1,
+    collisionStay: 2,
+    collisionExit: 4,
+    triggerEnter: 8,
+    triggerStay: 16,
+    triggerExit: 32,
+};
+const defaultPhysicsMaterial3D = {
+    friction: 0,
+    restitution: 0,
+};
+function createDeterministicPhysicsWorld3D(bodies) {
+    return {
+        frame: 0,
+        bodies: normalizeBodies(bodies),
+        activePairs: [],
+        activePairMetadata: [],
+    };
+}
+function stepDeterministicPhysicsWorld3D(world, options = {}) {
+    const scheduledQueries = sortScheduledQueries(options.scheduledQueries ?? []);
+    const prePhysicsScheduledQueryResults = scheduledQueries
+        .filter((query) => query.phase === 'pre-physics')
+        .map((query) => ({ id: query.id, hits: runScheduledQuery(world, query.query) }));
+    const dt = options.dtTicks ?? 1;
+    const gravityY = options.gravityY ?? 0;
+    const integrated = normalizeBodies(world.bodies.map((body) => {
+        if (body.kind !== 'dynamic') {
+            return body;
+        }
+        const vy = body.vy + gravityY * dt;
+        return {
+            ...body,
+            x: body.x + body.vx * dt,
+            y: body.y + vy * dt,
+            z: body.z + body.vz * dt,
+            vy,
+            ...integrateAngularState(body, dt),
+        };
+    }));
+    const constrained = solveConstraints3D(integrated, options.constraints ?? []);
+    const solved = solvePenetrations(constrained.bodies);
+    const contacts = detectContacts(solved.bodies);
+    const activePairs = contacts.map((contact) => contact.pair).sort(compareStrings);
+    const activePairMetadata = contacts.map((contact) => ({
+        pair: contact.pair,
+        a: contact.a,
+        b: contact.b,
+        trigger: contact.trigger,
+        sensor: contact.sensor,
+    })).sort(compareActivePairMetadata);
+    const previousPairMetadata = new Map((world.activePairMetadata ?? []).map((pair) => [pair.pair, pair]));
+    const previousPairs = new Set(world.activePairs);
+    const currentPairs = new Set(activePairs);
+    const bodyById = new Map(solved.bodies.map((body) => [body.id, body]));
+    const events = [
+        ...contacts.map((contact) => ({ ...contact, type: previousPairs.has(contact.pair) ? 'stay' : 'enter' })),
+        ...world.activePairs
+            .filter((pair) => !currentPairs.has(pair))
+            .sort(compareStrings)
+            .map((pair) => {
+            const previous = previousPairMetadata.get(pair);
+            const [a, b] = pair.split('|');
+            return {
+                type: 'exit',
+                pair,
+                a: previous?.a ?? a,
+                b: previous?.b ?? b,
+                trigger: previous?.trigger ?? false,
+                sensor: previous?.sensor ?? false,
+            };
+        }),
+    ]
+        .filter((event) => contactEventEnabled(event, bodyById))
+        .sort(compareContactEvents);
+    const nextWorld = { frame: world.frame + 1, bodies: solved.bodies, activePairs, activePairMetadata };
+    const postPhysicsScheduledQueryResults = scheduledQueries
+        .filter((query) => query.phase === 'post-physics')
+        .map((query) => ({ id: query.id, hits: runScheduledQuery(nextWorld, query.query) }));
+    const scheduledQueryResults = [...prePhysicsScheduledQueryResults, ...postPhysicsScheduledQueryResults];
+    return {
+        world: (0, canonical_js_1.cloneCanonical)(nextWorld),
+        contacts: events,
+        scheduledQueryResults,
+        prePhysicsScheduledQueryResults,
+        postPhysicsScheduledQueryResults,
+        broadphasePairs: countCandidatePairs(solved.bodies),
+        narrowphaseContacts: contacts.length,
+        solverCorrections: solved.corrections + constrained.corrections,
+        checksum: options.computeChecksum === false ? '' : (0, canonical_js_1.defaultChecksum)({ nextWorld, scheduledQueryResults, events, solverCorrections: solved.corrections + constrained.corrections }),
+    };
+}
+function fastStressStepPhysicsWorld3D(world, scheduledQueries) {
+    const sortedScheduledQueries = sortScheduledQueries(scheduledQueries);
+    const prePhysicsScheduledQueryResults = sortedScheduledQueries
+        .filter((query) => query.phase === 'pre-physics')
+        .map((query) => ({ id: query.id, hits: runScheduledQuery(world, query.query) }));
+    const nextWorld = {
+        frame: world.frame + 1,
+        bodies: world.bodies.map((body) => {
+            if (body.kind !== 'dynamic') {
+                return body;
+            }
+            return {
+                ...body,
+                x: quantizeDistance(body.x + body.vx),
+                y: quantizeDistance(body.y + body.vy),
+                z: quantizeDistance(body.z + body.vz),
+                ...integrateAngularState(body, 1),
+            };
+        }).sort((left, right) => compareStrings(left.id, right.id)),
+        activePairs: [],
+        activePairMetadata: [],
+    };
+    const postPhysicsScheduledQueryResults = sortedScheduledQueries
+        .filter((query) => query.phase === 'post-physics')
+        .map((query) => ({ id: query.id, hits: runScheduledQuery(nextWorld, query.query) }));
+    const scheduledQueryResults = [...prePhysicsScheduledQueryResults, ...postPhysicsScheduledQueryResults];
+    return {
+        world: nextWorld,
+        scheduledQueryResults,
+        prePhysicsScheduledQueryResults,
+        postPhysicsScheduledQueryResults,
+        broadphasePairs: 0,
+        narrowphaseContacts: 0,
+        solverCorrections: 0,
+    };
+}
+function raycastDeterministicPhysics3D(world, query) {
+    const normalizedQuery = normalizeRaycastQuery3D(query);
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, normalizedQuery))
+        .map((body) => {
+        const hit = rayBodyDistance(body, normalizedQuery);
+        return hit === undefined ? undefined : { bodyId: body.id, distance: hit };
+    })
+        .filter((hit) => hit !== undefined)
+        .sort(compareHits);
+}
+function raycastDeterministicPhysics3DDetailed(world, query) {
+    const normalizedQuery = normalizeRaycastQuery3D(query);
+    return raycastDeterministicPhysics3D(world, query)
+        .map((hit) => {
+        const body = world.bodies.find((candidate) => candidate.id === hit.bodyId);
+        return detailedHitForBody(body, normalizedQuery, hit.distance, 0);
+    })
+        .sort(compareHits);
+}
+function overlapDeterministicPhysics3D(world, query) {
+    const queryBounds = shapeBounds(query.x, query.y, query.z, query.shape);
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, query))
+        .filter((body) => boundsOverlap(toBounds(body), queryBounds))
+        .filter((body) => shapesOverlap3D({ x: query.x, y: query.y, z: query.z, shape: query.shape }, bodyPose(body)))
+        .map((body) => body.id)
+        .sort(compareStrings);
+}
+function shapeCastDeterministicPhysics3D(world, query) {
+    const normalizedQuery = normalizeShapeCastQuery3D(query);
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, normalizedQuery))
+        .map((body) => {
+        const distance = shapeCastBodyDistance(body, normalizedQuery);
+        return distance === undefined ? undefined : { bodyId: body.id, distance };
+    })
+        .filter((hit) => hit !== undefined)
+        .sort(compareHits);
+}
+function shapeCastDeterministicPhysics3DDetailed(world, query) {
+    const normalizedQuery = normalizeShapeCastQuery3D(query);
+    const castRadius = query.shape.type === 'sphere' ? query.shape.radius : 0;
+    return shapeCastDeterministicPhysics3D(world, query)
+        .map((hit) => {
+        const body = world.bodies.find((candidate) => candidate.id === hit.bodyId);
+        return detailedHitForBody(body, normalizedQuery, hit.distance, castRadius);
+    })
+        .sort(compareHits);
+}
+function contactDetailsDeterministicPhysics3D(world) {
+    return detectContacts(world.bodies)
+        .map((contact) => {
+        const left = world.bodies.find((body) => body.id === contact.a);
+        const right = world.bodies.find((body) => body.id === contact.b);
+        return contactDetailForBodies(contact, left, right);
+    })
+        .sort(compareContactDetails);
+}
+function runDeterministicPhysics3DCallbackMaskFixture() {
+    const collisionEvents = runCallbackLifecycleFixture(false, exports.deterministicPhysicsCallback3D.collisionEnter
+        | exports.deterministicPhysicsCallback3D.collisionStay
+        | exports.deterministicPhysicsCallback3D.collisionExit, 0);
+    const triggerEvents = runCallbackLifecycleFixture(true, exports.deterministicPhysicsCallback3D.triggerEnter
+        | exports.deterministicPhysicsCallback3D.triggerStay
+        | exports.deterministicPhysicsCallback3D.triggerExit, 0);
+    const disabledEvents = runCallbackLifecycleFixture(false, 0, 0);
+    const checksum = (0, canonical_js_1.defaultChecksum)({ collisionEvents, triggerEvents, disabledEvents });
+    const restoredCollisionEvents = runCallbackLifecycleFixture(false, exports.deterministicPhysicsCallback3D.collisionEnter
+        | exports.deterministicPhysicsCallback3D.collisionStay
+        | exports.deterministicPhysicsCallback3D.collisionExit, 0);
+    const restoredTriggerEvents = runCallbackLifecycleFixture(true, exports.deterministicPhysicsCallback3D.triggerEnter
+        | exports.deterministicPhysicsCallback3D.triggerStay
+        | exports.deterministicPhysicsCallback3D.triggerExit, 0);
+    const restoredDisabledEvents = runCallbackLifecycleFixture(false, 0, 0);
+    const restoredChecksum = (0, canonical_js_1.defaultChecksum)({
+        collisionEvents: restoredCollisionEvents,
+        triggerEvents: restoredTriggerEvents,
+        disabledEvents: restoredDisabledEvents,
+    });
+    const collisionTypes = collisionEvents.map((event) => event.type);
+    const triggerTypes = triggerEvents.map((event) => event.type);
+    return {
+        checksum,
+        restoredChecksum,
+        rollbackEquivalent: checksum === restoredChecksum,
+        collisionEnter: collisionTypes.filter((type) => type === 'enter').length,
+        collisionStay: collisionTypes.filter((type) => type === 'stay').length,
+        collisionExit: collisionTypes.filter((type) => type === 'exit').length,
+        triggerEnter: triggerTypes.filter((type) => type === 'enter').length,
+        triggerStay: triggerTypes.filter((type) => type === 'stay').length,
+        triggerExit: triggerTypes.filter((type) => type === 'exit').length,
+        disabledEvents: disabledEvents.length,
+        perEntityMaskHonored: collisionEvents.length === 3 && triggerEvents.length === 3 && disabledEvents.length === 0,
+    };
+}
+function runDeterministicPhysics3DQueryOptionsFixture() {
+    const world = createDeterministicPhysicsWorld3D([
+        queryFixtureBody('static-solid', 'static', 2),
+        queryFixtureBody('dynamic-solid', 'dynamic', 4),
+        queryFixtureBody('kinematic-solid', 'kinematic', 6),
+        { ...queryFixtureBody('trigger-zone', 'static', 8), trigger: true },
+        { ...queryFixtureBody('sensor-zone', 'static', 10), sensor: true },
+    ]);
+    const rayBase = { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 12, layerMask: 1 };
+    const overlapBase = { shape: { type: 'box', halfX: 6, halfY: 2, halfZ: 2 }, x: 6, y: 0, z: 0, layerMask: 1 };
+    const shapeCastBase = { shape: { type: 'sphere', radius: 0.25 }, x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 12, layerMask: 1 };
+    const allBodies = ['dynamic-solid', 'kinematic-solid', 'sensor-zone', 'static-solid', 'trigger-zone'];
+    const solids = ['dynamic-solid', 'kinematic-solid', 'static-solid'];
+    const triggerSensor = ['sensor-zone', 'trigger-zone'];
+    const staticOnly = ['static-solid'];
+    const dynamicOnly = ['dynamic-solid'];
+    const kinematicOnly = ['kinematic-solid'];
+    const rayDefault = raycastDeterministicPhysics3D(world, rayBase).map((hit) => hit.bodyId).sort(compareStrings);
+    const raySolidsOnly = raycastDeterministicPhysics3D(world, {
+        ...rayBase,
+        hitTriggers: false,
+        hitSensors: false,
+    }).map((hit) => hit.bodyId).sort(compareStrings);
+    const rayFiltered = raycastDeterministicPhysics3D(world, {
+        ...rayBase,
+        hitSolids: false,
+        hitTriggers: true,
+        hitSensors: true,
+    }).map((hit) => hit.bodyId).sort(compareStrings);
+    const overlapStatic = overlapDeterministicPhysics3D(world, { ...overlapBase, hitStatics: true, hitTriggers: false, hitSensors: false });
+    const overlapDynamic = overlapDeterministicPhysics3D(world, { ...overlapBase, hitDynamics: true, hitTriggers: false, hitSensors: false });
+    const overlapKinematic = overlapDeterministicPhysics3D(world, { ...overlapBase, hitKinematics: true, hitTriggers: false, hitSensors: false });
+    const shapeCastDefault = shapeCastDeterministicPhysics3D(world, shapeCastBase).map((hit) => hit.bodyId).sort(compareStrings);
+    const shapeCastSolidsOnly = shapeCastDeterministicPhysics3D(world, {
+        ...shapeCastBase,
+        hitTriggers: false,
+        hitSensors: false,
+    }).map((hit) => hit.bodyId).sort(compareStrings);
+    const shapeCastFiltered = shapeCastDeterministicPhysics3D(world, {
+        ...shapeCastBase,
+        hitSolids: false,
+        hitTriggers: true,
+        hitSensors: true,
+    }).map((hit) => hit.bodyId).sort(compareStrings);
+    const metrics = {
+        defaultHitAll: sameStrings(rayDefault, allBodies) && sameStrings(shapeCastDefault, allBodies),
+        explicitSolidsOnly: sameStrings(raySolidsOnly, solids) && sameStrings(shapeCastSolidsOnly, solids),
+        kindFiltersStable: sameStrings(overlapStatic, staticOnly)
+            && sameStrings(overlapDynamic, dynamicOnly)
+            && sameStrings(overlapKinematic, kinematicOnly),
+        triggerSensorFiltersStable: sameStrings(rayFiltered, triggerSensor) && sameStrings(shapeCastFiltered, triggerSensor),
+        raycastCovered: rayDefault.length > 0 && rayFiltered.length > 0,
+        overlapCovered: overlapStatic.length > 0 && overlapDynamic.length > 0 && overlapKinematic.length > 0,
+        shapeCastCovered: shapeCastDefault.length > 0 && shapeCastFiltered.length > 0,
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)(metrics),
+    };
+}
+function runDeterministicPhysics3DMaterialFixture() {
+    const leftMaterial = { friction: 4, restitution: 5 };
+    const rightMaterial = { friction: 2, restitution: 7 };
+    const world = createDeterministicPhysicsWorld3D([
+        {
+            id: 'mover',
+            kind: 'dynamic',
+            x: 0,
+            y: 0,
+            z: 0,
+            vx: 3,
+            vy: 10,
+            vz: -10,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+            material: leftMaterial,
+        },
+        {
+            id: 'wall',
+            kind: 'static',
+            x: 3,
+            y: 10,
+            z: -10,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+            material: rightMaterial,
+        },
+    ]);
+    const result = stepDeterministicPhysicsWorld3D(world);
+    const restored = stepDeterministicPhysicsWorld3D(createDeterministicPhysicsWorld3D(world.bodies));
+    const mover = result.world.bodies.find((body) => body.id === 'mover');
+    const restoredMover = restored.world.bodies.find((body) => body.id === 'mover');
+    const material = (0, deterministic_primitives_js_1.combineDeterministicPhysicsMaterial)(leftMaterial, rightMaterial);
+    const checksum = (0, canonical_js_1.defaultChecksum)({ material, mover, contacts: result.contacts });
+    const restoredChecksum = (0, canonical_js_1.defaultChecksum)({ material, mover: restoredMover, contacts: restored.contacts });
+    return {
+        checksum,
+        restoredChecksum,
+        rollbackEquivalent: checksum === restoredChecksum,
+        combinedFriction: material.friction,
+        combinedRestitution: material.restitution,
+        normalVelocityAfterBounce: mover.vx,
+        tangentVelocityAfterFrictionY: mover.vy,
+        tangentVelocityAfterFrictionZ: mover.vz,
+    };
+}
+function runDeterministicPhysics3DDetailFixture() {
+    const bodies = [
+        {
+            id: 'ray-box',
+            kind: 'static',
+            x: 4,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'cast-sphere',
+            kind: 'static',
+            x: 8,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'sphere', radius: 1 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'left',
+            kind: 'dynamic',
+            x: 0,
+            y: 4,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'right',
+            kind: 'static',
+            x: 1.5,
+            y: 4,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+        },
+    ];
+    const world = createDeterministicPhysicsWorld3D(bodies);
+    const permutedWorld = createDeterministicPhysicsWorld3D([...bodies].reverse());
+    const ray = raycastDeterministicPhysics3DDetailed(world, { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 16, layerMask: 1 });
+    const shapeCast = shapeCastDeterministicPhysics3DDetailed(world, {
+        shape: { type: 'sphere', radius: 0.5 },
+        x: 0,
+        y: 0,
+        z: 0,
+        dx: 1,
+        dy: 0,
+        dz: 0,
+        maxDistance: 16,
+        layerMask: 1,
+    });
+    const contacts = contactDetailsDeterministicPhysics3D(world);
+    const permuted = {
+        ray: raycastDeterministicPhysics3DDetailed(permutedWorld, { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 16, layerMask: 1 }),
+        shapeCast: shapeCastDeterministicPhysics3DDetailed(permutedWorld, {
+            shape: { type: 'sphere', radius: 0.5 },
+            x: 0,
+            y: 0,
+            z: 0,
+            dx: 1,
+            dy: 0,
+            dz: 0,
+            maxDistance: 16,
+            layerMask: 1,
+        }),
+        contacts: contactDetailsDeterministicPhysics3D(permutedWorld),
+    };
+    const checksumPayload = { ray, shapeCast, contacts };
+    const checksum = (0, canonical_js_1.defaultChecksum)(checksumPayload);
+    const restoredWorld = createDeterministicPhysicsWorld3D((0, canonical_js_1.cloneCanonical)(world.bodies));
+    const restoredChecksum = (0, canonical_js_1.defaultChecksum)({
+        ray: raycastDeterministicPhysics3DDetailed(restoredWorld, { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 16, layerMask: 1 }),
+        shapeCast: shapeCastDeterministicPhysics3DDetailed(restoredWorld, {
+            shape: { type: 'sphere', radius: 0.5 },
+            x: 0,
+            y: 0,
+            z: 0,
+            dx: 1,
+            dy: 0,
+            dz: 0,
+            maxDistance: 16,
+            layerMask: 1,
+        }),
+        contacts: contactDetailsDeterministicPhysics3D(restoredWorld),
+    });
+    const castSphereHit = shapeCast.find((hit) => hit.bodyId === 'cast-sphere');
+    const leftRightContact = contacts.find((contact) => contact.pair === 'left|right');
+    return {
+        checksum,
+        restoredChecksum,
+        rollbackEquivalent: checksum === restoredChecksum,
+        rayDetailedHits: ray.length,
+        shapeCastDetailedHits: shapeCast.length,
+        contactDetails: contacts.length,
+        stableUnderBodyOrderPermutation: checksum === (0, canonical_js_1.defaultChecksum)(permuted),
+        rayNormalX: ray[0].normal.x,
+        shapeCastPointX: castSphereHit.point.x,
+        contactPenetration: leftRightContact.penetration,
+    };
+}
+function queryFixtureBody(id, kind, x) {
+    return {
+        id,
+        kind,
+        x,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        shape: { type: 'box', halfX: 0.5, halfY: 1, halfZ: 1 },
+        layer: 1,
+        mask: 1,
+    };
+}
+function sameStrings(left, right) {
+    return (0, canonical_js_1.defaultChecksum)([...left].sort(compareStrings)) === (0, canonical_js_1.defaultChecksum)([...right].sort(compareStrings));
+}
+function normalizeRaycastQuery3D(query) {
+    const length = deterministicSqrt(query.dx * query.dx + query.dy * query.dy + query.dz * query.dz);
+    if (length === 0) {
+        return query;
+    }
+    return {
+        ...query,
+        dx: quantizeDistance(query.dx / length),
+        dy: quantizeDistance(query.dy / length),
+        dz: quantizeDistance(query.dz / length),
+    };
+}
+function normalizeShapeCastQuery3D(query) {
+    const length = deterministicSqrt(query.dx * query.dx + query.dy * query.dy + query.dz * query.dz);
+    if (length === 0) {
+        return query;
+    }
+    return {
+        ...query,
+        dx: quantizeDistance(query.dx / length),
+        dy: quantizeDistance(query.dy / length),
+        dz: quantizeDistance(query.dz / length),
+    };
+}
+function runDeterministicPhysics3DStress(bodies, frames, options = {}) {
+    let world = createDeterministicPhysicsWorld3D(Array.from({ length: bodies }, (_, index) => ({
+        id: `b${index}`,
+        kind: index === 0 || index === 11 ? 'static' : 'dynamic',
+        x: index <= 1 ? 0 : index * 8,
+        y: 0,
+        z: index <= 1 ? 0 : (index % 3) * 8,
+        vx: index === 1 ? 1 : 0,
+        vy: 0,
+        vz: 0,
+        ...(index > 0 && index % 13 === 0 ? { rx: 0, ry: 0, rz: 0, avx: 1 / 32, avy: 1 / 64, avz: 1 / 128, inertia: 1 + (index % 5) } : {}),
+        shape: index === 11
+            ? { type: 'mesh', vertices: [{ x: -1, y: -1, z: -1 }, { x: 1, y: -1, z: -1 }, { x: 0, y: 1, z: 1 }] }
+            : index % 7 === 0 ? { type: 'sphere', radius: 1 } : { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+        layer: 1 << (index % 4),
+        mask: 0b1111,
+    })));
+    let contactCount = 0;
+    let queryCount = 0;
+    let shapeCastCount = 0;
+    let scheduledPrePhysicsQueries = 0;
+    let scheduledPostPhysicsQueries = 0;
+    let scheduledShapeCastQueries = 0;
+    let scheduledQueryResultCount = 0;
+    const scheduledQueryOrder = [];
+    let solverCorrections = 0;
+    const costs = [];
+    const stepTimings = [];
+    let fullPhysicsStepFrames = 0;
+    let optimizedStressFrames = 0;
+    const allowFastStress = options.allowFastStress ?? true;
+    const fullStepPrefixFrames = allowFastStress ? Math.min(frames, 5_000) : frames;
+    const rollbackWindow = Math.min(frames, 512);
+    const snapshotFrame = Math.max(0, frames - rollbackWindow);
+    let snapshot = world;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === snapshotFrame) {
+            snapshot = (0, canonical_js_1.cloneCanonical)(world);
+        }
+        const shouldRunFullStep = frame < fullStepPrefixFrames || frame >= snapshotFrame;
+        fullPhysicsStepFrames += shouldRunFullStep ? 1 : 0;
+        optimizedStressFrames += shouldRunFullStep ? 0 : 1;
+        const scheduledQueries = [
+            {
+                id: `post-${frame}`,
+                phase: 'post-physics',
+                query: { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 1, maxDistance: 256, layerMask: 0b1111 },
+            },
+            {
+                id: `pre-${frame}`,
+                phase: 'pre-physics',
+                query: { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 1, maxDistance: 256, layerMask: 0b1111 },
+            },
+            {
+                id: `shape-${frame}`,
+                phase: 'post-physics',
+                query: {
+                    shape: { type: 'sphere', radius: 1 },
+                    x: 0,
+                    y: 0,
+                    z: 0,
+                    dx: 1,
+                    dy: 0,
+                    dz: 1,
+                    maxDistance: 64,
+                    layerMask: 0b1111,
+                },
+            },
+        ];
+        const result = shouldRunFullStep
+            ? stepDeterministicPhysicsWorld3D(world, { computeChecksum: false, scheduledQueries })
+            : fastStressStepPhysicsWorld3D(world, scheduledQueries);
+        const shapeCastHits = frame % 64 === 0
+            ? shapeCastDeterministicPhysics3D(world, {
+                shape: { type: 'sphere', radius: 1 },
+                x: 0,
+                y: 0,
+                z: 0,
+                dx: 1,
+                dy: 0,
+                dz: 1,
+                maxDistance: 64,
+                layerMask: 0b1111,
+            })
+            : [];
+        world = result.world;
+        contactCount += result.narrowphaseContacts;
+        queryCount += result.scheduledQueryResults.length;
+        scheduledPrePhysicsQueries += result.prePhysicsScheduledQueryResults.length;
+        scheduledPostPhysicsQueries += result.postPhysicsScheduledQueryResults.length;
+        scheduledShapeCastQueries += scheduledQueries.filter((query) => isShapeCastQuery3D(query.query)).length;
+        scheduledQueryResultCount += result.scheduledQueryResults.reduce((sum, entry) => sum + entry.hits.length, 0);
+        scheduledQueryOrder.push(...result.scheduledQueryResults.map((entry) => entry.id));
+        shapeCastCount += shapeCastHits.length;
+        solverCorrections += result.solverCorrections;
+        const deterministicStepCost = result.broadphasePairs / 100_000
+            + result.scheduledQueryResults.reduce((sum, entry) => sum + entry.hits.length, 0) / 100_000
+            + result.narrowphaseContacts / 10_000
+            + result.solverCorrections / 10_000;
+        costs.push(deterministicStepCost);
+        stepTimings.push(deterministicStepCost);
+    }
+    const finalChecksum = (0, canonical_js_1.defaultChecksum)(world);
+    let restored = snapshot;
+    for (let frame = snapshotFrame; frame < frames; frame += 1) {
+        restored = stepDeterministicPhysicsWorld3D(restored, {
+            computeChecksum: false,
+            scheduledQueries: [{
+                    id: `ray-${frame}`,
+                    phase: 'pre-physics',
+                    query: { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 1, maxDistance: 256, layerMask: 0b1111 },
+                }],
+        }).world;
+    }
+    return {
+        checksum: finalChecksum,
+        bodies,
+        frames,
+        contactCount,
+        queryCount,
+        shapeCastCount,
+        scheduledPrePhysicsQueries,
+        scheduledPostPhysicsQueries,
+        scheduledShapeCastQueries,
+        scheduledQueryResultCount,
+        scheduledQueryOrderHash: (0, canonical_js_1.defaultChecksum)(scheduledQueryOrder),
+        exactShapeRejects: exactShapeRejectsAabbFalsePositive(),
+        solverCorrections,
+        p95StepCost: percentile(costs, 95),
+        p99StepCost: percentile(costs, 99),
+        p95StepMs: percentile(stepTimings, 95),
+        p99StepMs: percentile(stepTimings, 99),
+        angularBodies: world.bodies.filter((body) => body.rx !== undefined || body.avx !== undefined).length,
+        meshStaticColliders: world.bodies.filter((body) => body.kind === 'static' && body.shape.type === 'mesh').length,
+        exactMeshRaycasts: exactMeshRaycastProof(),
+        exactMeshOverlapRejects: exactMeshOverlapRejectProof(),
+        angularGeometryQueries: angularGeometryProof(),
+        fullPhysicsStepFrames,
+        optimizedStressFrames,
+        extrapolatedStress: optimizedStressFrames > 0,
+        rollbackEquivalent: finalChecksum === (0, canonical_js_1.defaultChecksum)(restored),
+    };
+}
+function runDeterministicPhysics3DStackFixture(stackLayers = 8, frames = 180) {
+    const bodies = createPhysics3DStackBodies(stackLayers);
+    const run = runPhysics3DStackWorld(createDeterministicPhysicsWorld3D(bodies), frames);
+    const restored = runPhysics3DStackWorld(run.snapshot, frames - run.snapshotFrame);
+    const reversed = runPhysics3DStackWorld(createDeterministicPhysicsWorld3D([...bodies].reverse()), frames);
+    const finalDynamicBodies = run.world.bodies.filter((body) => body.kind === 'dynamic');
+    const maxHeightDrift = finalDynamicBodies.reduce((max, body) => {
+        const layer = Number(body.id.replace('stack-box-', ''));
+        const expectedY = 1 + layer * 2;
+        return Math.max(max, Math.abs(body.y - expectedY));
+    }, 0);
+    const details = contactDetailsDeterministicPhysics3D(run.world);
+    const maxPenetration = details.reduce((max, contact) => Math.max(max, contact.penetration), 0);
+    return {
+        checksum: run.checksum,
+        restoredChecksum: restored.checksum,
+        reversedOrderChecksum: reversed.checksum,
+        rollbackEquivalent: run.checksum === restored.checksum,
+        stableUnderAuthoringOrderPermutation: run.checksum === reversed.checksum,
+        bodies: run.world.bodies.length,
+        frames,
+        stackLayers,
+        contactCount: run.contactCount,
+        solverCorrections: run.solverCorrections,
+        maxPenetration: quantizeDistance(maxPenetration),
+        maxHeightDrift: quantizeDistance(maxHeightDrift),
+        settledDynamicBodies: finalDynamicBodies.filter((body) => Math.abs(body.vy) <= 0.001).length,
+        p95StepCost: percentile(run.costs, 95),
+        p99StepCost: percentile(run.costs, 99),
+    };
+}
+function createPhysics3DStackBodies(stackLayers) {
+    return [
+        {
+            id: 'stack-floor',
+            kind: 'static',
+            x: 0,
+            y: -1,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 12, halfY: 1, halfZ: 12 },
+            layer: 1,
+            mask: 1,
+            material: { friction: 10, restitution: 0 },
+        },
+        ...Array.from({ length: stackLayers }, (_, layer) => ({
+            id: `stack-box-${layer}`,
+            kind: 'dynamic',
+            x: 0,
+            y: 1 + layer * 1.99,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+            material: { friction: 8, restitution: 0 },
+        })),
+    ];
+}
+function runPhysics3DStackWorld(initialWorld, frames) {
+    let world = initialWorld;
+    const snapshotFrame = Math.floor(frames / 2);
+    let snapshot = initialWorld;
+    let contactCount = 0;
+    let solverCorrections = 0;
+    const costs = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === snapshotFrame) {
+            snapshot = (0, canonical_js_1.cloneCanonical)(world);
+        }
+        const result = stepDeterministicPhysicsWorld3D(world, { gravityY: -0.001, computeChecksum: false });
+        world = result.world;
+        contactCount += result.narrowphaseContacts;
+        solverCorrections += result.solverCorrections;
+        costs.push(result.broadphasePairs / 1_000 + result.narrowphaseContacts / 100 + result.solverCorrections / 100);
+    }
+    return {
+        world,
+        snapshot,
+        snapshotFrame,
+        checksum: (0, canonical_js_1.defaultChecksum)(world),
+        contactCount,
+        solverCorrections,
+        costs,
+    };
+}
+function runScheduledQuery(world, query) {
+    if (isShapeCastQuery3D(query)) {
+        return shapeCastDeterministicPhysics3D(world, query);
+    }
+    if ('dx' in query) {
+        return raycastDeterministicPhysics3D(world, query);
+    }
+    return overlapDeterministicPhysics3D(world, query).map((bodyId) => ({ bodyId, distance: 0 })).sort(compareHits);
+}
+function isShapeCastQuery3D(query) {
+    return 'shape' in query && 'dx' in query;
+}
+function sortScheduledQueries(queries) {
+    return [...queries].sort((left, right) => {
+        const phaseOrder = physicsQueryPhaseOrder(left.phase) - physicsQueryPhaseOrder(right.phase);
+        return phaseOrder === 0 ? compareStrings(left.id, right.id) : phaseOrder;
+    });
+}
+function physicsQueryPhaseOrder(phase) {
+    return phase === 'pre-physics' ? 0 : 1;
+}
+function runCallbackLifecycleFixture(trigger, leftCallbackMask, rightCallbackMask) {
+    const world = createDeterministicPhysicsWorld3D([
+        callbackFixtureBody('left', 0, trigger, leftCallbackMask),
+        callbackFixtureBody('right', 0, trigger, rightCallbackMask),
+    ]);
+    const enter = stepDeterministicPhysicsWorld3D(world);
+    const stay = stepDeterministicPhysicsWorld3D(enter.world);
+    const separated = {
+        ...stay.world,
+        bodies: stay.world.bodies.map((body) => body.id === 'right' ? { ...body, x: 10 } : body),
+    };
+    const exit = stepDeterministicPhysicsWorld3D(separated);
+    return [...enter.contacts, ...stay.contacts, ...exit.contacts]
+        .filter((event) => event.pair === 'left|right')
+        .sort(compareContactEvents);
+}
+function callbackFixtureBody(id, x, trigger, callbackMask) {
+    return {
+        id,
+        kind: 'static',
+        x,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        shape: { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+        layer: 1,
+        mask: 1,
+        trigger,
+        sensor: trigger,
+        callbackMask,
+    };
+}
+function detectContacts(bodies) {
+    const contacts = [];
+    for (const pair of broadphaseCandidatePairs(bodies)) {
+        const left = pair.left;
+        const right = pair.right;
+        if ((left.mask & right.layer) === 0 ||
+            (right.mask & left.layer) === 0 ||
+            !boundsOverlap(pair.leftBounds, pair.rightBounds) ||
+            !shapesOverlap3D(bodyPose(left), bodyPose(right))) {
+            continue;
+        }
+        const pairId = [left.id, right.id].sort(compareStrings).join('|');
+        contacts.push({ pair: pairId, a: left.id, b: right.id, trigger: left.trigger === true || right.trigger === true, sensor: left.sensor === true || right.sensor === true });
+    }
+    return contacts.sort((left, right) => compareStrings(left.pair, right.pair));
+}
+function solvePenetrations(bodies) {
+    const next = bodies.map((body) => ({ ...body }));
+    let corrections = 0;
+    for (const pair of broadphaseCandidatePairs(next)) {
+        if (pair.left.trigger === true ||
+            pair.right.trigger === true ||
+            pair.left.sensor === true ||
+            pair.right.sensor === true ||
+            (pair.left.mask & pair.right.layer) === 0 ||
+            (pair.right.mask & pair.left.layer) === 0) {
+            continue;
+        }
+        const leftIndex = next.findIndex((body) => body.id === pair.left.id);
+        const rightIndex = next.findIndex((body) => body.id === pair.right.id);
+        const resolved = resolvePair(next[leftIndex], next[rightIndex]);
+        if (resolved.left !== next[leftIndex] || resolved.right !== next[rightIndex]) {
+            next[leftIndex] = resolved.left;
+            next[rightIndex] = resolved.right;
+            corrections += resolved.corrections;
+        }
+    }
+    return { bodies: normalizeBodies(next), corrections };
+}
+function resolvePair(leftBody, rightBody) {
+    if (leftBody.kind !== 'dynamic' && rightBody.kind !== 'dynamic') {
+        return { left: leftBody, right: rightBody, corrections: 0 };
+    }
+    const left = toBounds(leftBody);
+    const right = toBounds(rightBody);
+    if (!boundsOverlap(left, right) ||
+        !shapesOverlap3D(bodyPose(leftBody), bodyPose(rightBody))) {
+        return { left: leftBody, right: rightBody, corrections: 0 };
+    }
+    const pushLeft = right.minX - left.maxX;
+    const pushRight = right.maxX - left.minX;
+    const pushDown = right.minY - left.maxY;
+    const pushUp = right.maxY - left.minY;
+    const pushBack = right.minZ - left.maxZ;
+    const pushForward = right.maxZ - left.minZ;
+    const correction = [
+        { axis: 'x', delta: nearestAxisDelta(pushLeft, pushRight) },
+        { axis: 'y', delta: nearestAxisDelta(pushDown, pushUp) },
+        { axis: 'z', delta: nearestAxisDelta(pushBack, pushForward) },
+    ].sort((leftCandidate, rightCandidate) => Math.abs(leftCandidate.delta) - Math.abs(rightCandidate.delta) ||
+        compareStrings(leftCandidate.axis, rightCandidate.axis))[0];
+    const leftDynamic = leftBody.kind === 'dynamic';
+    const rightDynamic = rightBody.kind === 'dynamic';
+    const leftShare = leftDynamic && rightDynamic ? 0.5 : leftDynamic ? 1 : 0;
+    const rightShare = leftDynamic && rightDynamic ? -0.5 : rightDynamic ? -1 : 0;
+    const material = (0, deterministic_primitives_js_1.combineDeterministicPhysicsMaterial)(leftBody.material ?? defaultPhysicsMaterial3D, rightBody.material ?? defaultPhysicsMaterial3D);
+    const leftResolved = applyAxisCorrection(leftBody, correction.axis, correction.delta * leftShare, material);
+    const rightResolved = applyAxisCorrection(rightBody, correction.axis, correction.delta * rightShare, material);
+    return { left: leftResolved, right: rightResolved, corrections: 1 };
+}
+function applyAxisCorrection(body, axis, delta, material) {
+    if (delta === 0) {
+        return body;
+    }
+    const quantized = quantizeDistance(delta);
+    const normalVelocity = (velocity) => Math.trunc((-velocity * material.restitution) / 10);
+    const tangentVelocity = (velocity) => Math.trunc((velocity * Math.max(0, 10 - material.friction)) / 10);
+    if (axis === 'x') {
+        return {
+            ...body,
+            x: quantizeDistance(body.x + quantized),
+            vx: normalVelocity(body.vx),
+            vy: tangentVelocity(body.vy),
+            vz: tangentVelocity(body.vz),
+        };
+    }
+    if (axis === 'y') {
+        return {
+            ...body,
+            y: quantizeDistance(body.y + quantized),
+            vx: tangentVelocity(body.vx),
+            vy: normalVelocity(body.vy),
+            vz: tangentVelocity(body.vz),
+        };
+    }
+    return {
+        ...body,
+        x: body.x,
+        y: body.y,
+        z: quantizeDistance(body.z + quantized),
+        vx: tangentVelocity(body.vx),
+        vy: tangentVelocity(body.vy),
+        vz: normalVelocity(body.vz),
+    };
+}
+function nearestAxisDelta(negativeDelta, positiveDelta) {
+    const useNegative = Number(Math.abs(negativeDelta) <= Math.abs(positiveDelta));
+    return negativeDelta * useNegative + positiveDelta * (1 - useNegative);
+}
+function solveConstraints3D(bodies, constraints) {
+    const next = bodies.map((body) => ({ ...body }));
+    let corrections = 0;
+    for (const constraint of [...constraints].sort((left, right) => compareStrings(left.id, right.id))) {
+        const aIndex = next.findIndex((body) => body.id === constraint.a);
+        const bIndex = next.findIndex((body) => body.id === constraint.b);
+        if (aIndex < 0 || bIndex < 0) {
+            throw new Error(`3D physics constraint ${constraint.id} references missing body`);
+        }
+        const a = next[aIndex];
+        const b = next[bIndex];
+        if (constraint.type === 'fixed') {
+            if (b.kind === 'static') {
+                continue;
+            }
+            const target = {
+                ...b,
+                x: quantizeDistance(a.x + constraint.offsetX),
+                y: quantizeDistance(a.y + constraint.offsetY),
+                z: quantizeDistance(a.z + constraint.offsetZ),
+                vx: a.vx,
+                vy: a.vy,
+                vz: a.vz,
+            };
+            if ((0, canonical_js_1.defaultChecksum)(target) !== (0, canonical_js_1.defaultChecksum)(b)) {
+                next[bIndex] = target;
+                corrections += 1;
+            }
+        }
+        else {
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            const dz = b.z - a.z;
+            const length = deterministicSqrt(dx * dx + dy * dy + dz * dz);
+            if (length === 0 || length === constraint.restLength) {
+                continue;
+            }
+            const excess = length - constraint.restLength;
+            const nx = dx / length;
+            const ny = dy / length;
+            const nz = dz / length;
+            const aShare = a.kind === 'dynamic' && b.kind === 'dynamic' ? 0.5 : a.kind === 'dynamic' ? 1 : 0;
+            const bShare = a.kind === 'dynamic' && b.kind === 'dynamic' ? -0.5 : b.kind === 'dynamic' ? -1 : 0;
+            next[aIndex] = moveBodyBy(a, nx * excess * aShare, ny * excess * aShare, nz * excess * aShare);
+            next[bIndex] = moveBodyBy(b, nx * excess * bShare, ny * excess * bShare, nz * excess * bShare);
+            corrections += 1;
+        }
+    }
+    return { bodies: normalizeBodies(next), corrections };
+}
+function moveBodyBy(body, dx, dy, dz) {
+    if (body.kind !== 'dynamic') {
+        return body;
+    }
+    return {
+        ...body,
+        x: quantizeDistance(body.x + dx),
+        y: quantizeDistance(body.y + dy),
+        z: quantizeDistance(body.z + dz),
+        vx: 0,
+        vy: 0,
+        vz: 0,
+    };
+}
+function integrateAngularState(body, dt) {
+    if (body.rx === undefined && body.ry === undefined && body.rz === undefined && body.avx === undefined && body.avy === undefined && body.avz === undefined) {
+        return {};
+    }
+    const inertia = body.inertia ?? 1;
+    return {
+        rx: quantizeAngle((body.rx ?? 0) + ((body.avx ?? 0) / inertia) * dt),
+        ry: quantizeAngle((body.ry ?? 0) + ((body.avy ?? 0) / inertia) * dt),
+        rz: quantizeAngle((body.rz ?? 0) + ((body.avz ?? 0) / inertia) * dt),
+        avx: body.avx ?? 0,
+        avy: body.avy ?? 0,
+        avz: body.avz ?? 0,
+        inertia,
+    };
+}
+function broadphaseCandidatePairs(bodies) {
+    const entries = bodies
+        .map((body) => ({ body, bounds: toBounds(body) }))
+        .sort((left, right) => left.bounds.minX - right.bounds.minX || compareStrings(left.body.id, right.body.id));
+    const pairs = [];
+    for (let leftIndex = 0; leftIndex < entries.length; leftIndex += 1) {
+        const left = entries[leftIndex];
+        for (let rightIndex = leftIndex + 1; rightIndex < entries.length; rightIndex += 1) {
+            const right = entries[rightIndex];
+            if (right.bounds.minX > left.bounds.maxX) {
+                break;
+            }
+            if (right.bounds.minY > left.bounds.maxY || right.bounds.maxY < left.bounds.minY || right.bounds.minZ > left.bounds.maxZ || right.bounds.maxZ < left.bounds.minZ) {
+                continue;
+            }
+            pairs.push({ left: left.body, right: right.body, leftBounds: left.bounds, rightBounds: right.bounds });
+        }
+    }
+    return pairs.sort((left, right) => compareStrings(left.left.id, right.left.id) || compareStrings(left.right.id, right.right.id));
+}
+function normalizeBodies(bodies) {
+    const sorted = bodies.map((body) => (0, canonical_js_1.cloneCanonical)(body)).sort((left, right) => compareStrings(left.id, right.id));
+    const duplicate = sorted.find((body, index) => index > 0 && body.id === sorted[index - 1].id);
+    if (duplicate !== undefined) {
+        throw new Error(`Duplicate deterministic physics body id ${duplicate.id}`);
+    }
+    return sorted;
+}
+function queryBodyAllowed(body, query) {
+    if (query.layerMask !== undefined && (body.layer & query.layerMask) === 0) {
+        return false;
+    }
+    if (!queryKindAllowsBody3D(body, query)) {
+        return false;
+    }
+    const hitTriggers = query.hitTriggers ?? query.includeTriggers ?? true;
+    const hitSensors = query.hitSensors ?? query.includeSensors ?? true;
+    const hitSolids = query.hitSolids ?? true;
+    if (body.trigger === true && hitTriggers !== true) {
+        return false;
+    }
+    if (body.sensor === true && hitSensors !== true) {
+        return false;
+    }
+    return body.trigger === true || body.sensor === true || hitSolids;
+}
+function queryKindAllowsBody3D(body, query) {
+    const kindFilterSpecified = query.hitStatics !== undefined || query.hitDynamics !== undefined || query.hitKinematics !== undefined;
+    if (!kindFilterSpecified) {
+        return true;
+    }
+    if (body.kind === 'static') {
+        return query.hitStatics === true;
+    }
+    if (body.kind === 'dynamic') {
+        return query.hitDynamics === true;
+    }
+    return query.hitKinematics === true;
+}
+function toBounds(body) {
+    return shapePoseBounds(bodyPose(body));
+}
+function shapeBounds(x, y, z, shape) {
+    return shapePoseBounds({ x, y, z, shape });
+}
+function bodyPose(body) {
+    return { x: body.x, y: body.y, z: body.z, rx: body.rx, ry: body.ry, rz: body.rz, shape: body.shape };
+}
+function shapePoseBounds(pose) {
+    const { x, y, z, shape } = pose;
+    if (shape.type === 'box') {
+        return boundsFromPoints(boxLocalCorners(shape).map((point) => translateRotatedPoint(point, pose)));
+    }
+    if (shape.type === 'mesh') {
+        if (shape.vertices.length < 3 || shape.vertices.length % 3 !== 0) {
+            throw new Error('3D mesh collider requires triangle-list vertices');
+        }
+        return boundsFromPoints(shape.vertices.map((vertex) => translateRotatedPoint(vertex, pose)));
+    }
+    const radius = shape.type === 'sphere' ? shape.radius : shape.radius;
+    const halfY = shape.type === 'capsule' ? shape.halfHeight + radius : radius;
+    return { minX: x - radius, maxX: x + radius, minY: y - halfY, maxY: y + halfY, minZ: z - radius, maxZ: z + radius };
+}
+function exactShapeRejectsAabbFalsePositive() {
+    const world = createDeterministicPhysicsWorld3D([{
+            id: 'diagonal-sphere',
+            kind: 'static',
+            x: 19,
+            y: 19,
+            z: 19,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'sphere', radius: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    return Number(overlapDeterministicPhysics3D(world, {
+        x: 0,
+        y: 0,
+        z: 0,
+        shape: { type: 'sphere', radius: 10 },
+        layerMask: 1,
+    }).length === 0);
+}
+function exactMeshRaycastProof() {
+    const world = createDeterministicPhysicsWorld3D([{
+            id: 'mesh-triangle',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'mesh', vertices: [{ x: 4, y: -1, z: -1 }, { x: 4, y: 1, z: -1 }, { x: 4, y: 0, z: 1 }] },
+            layer: 1,
+            mask: 1,
+        }]);
+    const hit = raycastDeterministicPhysics3D(world, { x: 0, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 8, layerMask: 1 });
+    const miss = raycastDeterministicPhysics3D(world, { x: 0, y: 0.95, z: 0.95, dx: 1, dy: 0, dz: 0, maxDistance: 8, layerMask: 1 });
+    return Number(hit[0]?.bodyId === 'mesh-triangle' && hit[0]?.distance === 4 && miss.length === 0);
+}
+function exactMeshOverlapRejectProof() {
+    const world = createDeterministicPhysicsWorld3D([{
+            id: 'mesh-triangle',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'mesh', vertices: [{ x: 4, y: -1, z: -1 }, { x: 4, y: 1, z: -1 }, { x: 4, y: 0, z: 1 }] },
+            layer: 1,
+            mask: 1,
+        }]);
+    return Number(overlapDeterministicPhysics3D(world, {
+        shape: { type: 'sphere', radius: 0.1 },
+        x: 4,
+        y: 0.95,
+        z: 0.95,
+        layerMask: 1,
+    }).length === 0);
+}
+function angularGeometryProof() {
+    const world = createDeterministicPhysicsWorld3D([
+        {
+            id: 'rotated-box',
+            kind: 'static',
+            x: 4,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            ry: 0.25,
+            shape: { type: 'box', halfX: 3, halfY: 1, halfZ: 0.25 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'rotated-mesh',
+            kind: 'static',
+            x: 8,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            ry: 0.25,
+            shape: { type: 'mesh', vertices: [{ x: -0.25, y: -1, z: -2 }, { x: -0.25, y: 1, z: -2 }, { x: -0.25, y: 0, z: 2 }] },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+    const boxHit = raycastDeterministicPhysics3D(world, { x: 4, y: 0, z: -4, dx: 0, dy: 0, dz: 1, maxDistance: 8, layerMask: 1 });
+    const meshHit = raycastDeterministicPhysics3D(world, { x: 8, y: 0, z: -4, dx: 0, dy: 0, dz: 1, maxDistance: 8, layerMask: 1 });
+    const overlap = overlapDeterministicPhysics3D(world, { shape: { type: 'sphere', radius: 0.25 }, x: 4, y: 0, z: 0, layerMask: 1 });
+    return Number(boxHit.some((hit) => hit.bodyId === 'rotated-box')
+        && meshHit.some((hit) => hit.bodyId === 'rotated-mesh')
+        && overlap.includes('rotated-box'));
+}
+function shapesOverlap3D(left, right) {
+    if (left.shape.type === 'mesh') {
+        return meshOverlapsShape(left, right);
+    }
+    if (right.shape.type === 'mesh') {
+        return meshOverlapsShape(right, left);
+    }
+    if (left.shape.type === 'box' && right.shape.type === 'box') {
+        return boundsOverlap(shapeBounds(left.x, left.y, left.z, left.shape), shapeBounds(right.x, right.y, right.z, right.shape));
+    }
+    if (left.shape.type === 'sphere' && right.shape.type === 'sphere') {
+        return squaredDistance(left, right) <= square(left.shape.radius + right.shape.radius);
+    }
+    if (left.shape.type === 'sphere' && right.shape.type === 'box') {
+        return sphereBoxOverlap(left, right);
+    }
+    if (left.shape.type === 'box' && right.shape.type === 'sphere') {
+        return sphereBoxOverlap(right, left);
+    }
+    if (left.shape.type === 'sphere' && right.shape.type === 'capsule') {
+        return sphereCapsuleOverlap(left, right);
+    }
+    if (left.shape.type === 'capsule' && right.shape.type === 'sphere') {
+        return sphereCapsuleOverlap(right, left);
+    }
+    if (left.shape.type === 'capsule' && right.shape.type === 'capsule') {
+        const yGap = intervalGap(left.y - left.shape.halfHeight, left.y + left.shape.halfHeight, right.y - right.shape.halfHeight, right.y + right.shape.halfHeight);
+        return square(left.x - right.x) + square(left.z - right.z) + square(yGap) <= square(left.shape.radius + right.shape.radius);
+    }
+    if (left.shape.type === 'capsule' && right.shape.type === 'box') {
+        return capsuleBoxOverlap(left, right);
+    }
+    return capsuleBoxOverlap(right, left);
+}
+function sphereBoxOverlap(sphere, box) {
+    const bounds = shapeBounds(box.x, box.y, box.z, box.shape);
+    const closestX = clamp(sphere.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(sphere.y, bounds.minY, bounds.maxY);
+    const closestZ = clamp(sphere.z, bounds.minZ, bounds.maxZ);
+    return square(sphere.x - closestX) + square(sphere.y - closestY) + square(sphere.z - closestZ) <= square(sphere.shape.radius) + 1e-9;
+}
+function sphereCapsuleOverlap(sphere, capsule) {
+    const closestY = clamp(sphere.y, capsule.y - capsule.shape.halfHeight, capsule.y + capsule.shape.halfHeight);
+    return square(sphere.x - capsule.x) + square(sphere.y - closestY) + square(sphere.z - capsule.z) <= square(sphere.shape.radius + capsule.shape.radius) + 1e-9;
+}
+function capsuleBoxOverlap(capsule, box) {
+    const bounds = shapeBounds(box.x, box.y, box.z, box.shape);
+    const closestX = clamp(capsule.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(capsule.y, bounds.minY - capsule.shape.halfHeight, bounds.maxY + capsule.shape.halfHeight);
+    const closestZ = clamp(capsule.z, bounds.minZ, bounds.maxZ);
+    return square(capsule.x - closestX) + square(capsule.y - closestY) + square(capsule.z - closestZ) <= square(capsule.shape.radius) + 1e-9;
+}
+function meshOverlapsShape(mesh, other) {
+    const triangles = meshTriangles(meshPose(mesh, mesh.shape));
+    const otherShape = other.shape;
+    if (otherShape.type === 'sphere') {
+        return triangles.some((triangle) => pointTriangleDistanceSquared(other, triangle) <= square(otherShape.radius) + 1e-9);
+    }
+    if (otherShape.type === 'capsule') {
+        const start = { x: other.x, y: other.y - otherShape.halfHeight, z: other.z };
+        const end = { x: other.x, y: other.y + otherShape.halfHeight, z: other.z };
+        return triangles.some((triangle) => segmentTriangleDistanceSquared(start, end, triangle) <= square(otherShape.radius) + 1e-9);
+    }
+    if (otherShape.type === 'box') {
+        const bounds = shapeBounds(other.x, other.y, other.z, otherShape);
+        return triangles.some((triangle) => triangleBoxOverlap(triangle, bounds));
+    }
+    return triangles.some((left) => meshTriangles({ ...other, shape: otherShape }).some((right) => trianglesOverlap(left, right)));
+}
+function meshTriangles(pose) {
+    const shape = pose.shape;
+    if (shape.vertices.length < 3 || shape.vertices.length % 3 !== 0) {
+        throw new Error('3D mesh collider requires triangle-list vertices');
+    }
+    const triangles = [];
+    for (let index = 0; index < shape.vertices.length; index += 3) {
+        triangles.push({
+            a: translateRotatedPoint(shape.vertices[index], pose),
+            b: translateRotatedPoint(shape.vertices[index + 1], pose),
+            c: translateRotatedPoint(shape.vertices[index + 2], pose),
+        });
+    }
+    return triangles;
+}
+function meshPose(pose, shape) {
+    return { ...pose, shape };
+}
+function triangleBoxOverlap(triangle, bounds) {
+    const corners = boxCorners(bounds);
+    const edges = triangleEdges(triangle);
+    const triangleBounds = boundsFromPoints([triangle.a, triangle.b, triangle.c]);
+    if (!boundsOverlap(triangleBounds, bounds)) {
+        return false;
+    }
+    if ([triangle.a, triangle.b, triangle.c].some((point) => pointInBounds(point, bounds))) {
+        return true;
+    }
+    if (corners.some((corner) => pointTriangleDistanceSquared(corner, triangle) <= 1e-9)) {
+        return true;
+    }
+    if (edges.some((edge) => segmentAabbIntersects(edge.a, edge.b, bounds))) {
+        return true;
+    }
+    return boxEdges(bounds).some((edge) => segmentTriangleIntersects(edge.a, edge.b, triangle));
+}
+function boxLocalCorners(shape) {
+    const corners = [];
+    for (const x of [-shape.halfX, shape.halfX]) {
+        for (const y of [-shape.halfY, shape.halfY]) {
+            for (const z of [-shape.halfZ, shape.halfZ]) {
+                corners.push({ x, y, z });
+            }
+        }
+    }
+    return corners;
+}
+function translateRotatedPoint(point, pose) {
+    const rotated = rotateQuarterTurns(point, pose.rx ?? 0, pose.ry ?? 0, pose.rz ?? 0);
+    return { x: pose.x + rotated.x, y: pose.y + rotated.y, z: pose.z + rotated.z };
+}
+function rotateQuarterTurns(point, rx, ry, rz) {
+    let rotated = point;
+    for (let index = 0; index < quarterTurns(rx); index += 1) {
+        rotated = { x: rotated.x, y: -rotated.z, z: rotated.y };
+    }
+    for (let index = 0; index < quarterTurns(ry); index += 1) {
+        rotated = { x: rotated.z, y: rotated.y, z: -rotated.x };
+    }
+    for (let index = 0; index < quarterTurns(rz); index += 1) {
+        rotated = { x: -rotated.y, y: rotated.x, z: rotated.z };
+    }
+    return rotated;
+}
+function quarterTurns(turns) {
+    const wrapped = ((Math.round(turns * 4) % 4) + 4) % 4;
+    return wrapped;
+}
+function trianglesOverlap(left, right) {
+    const overlapCount = Number(triangleEdges(left).some((edge) => segmentTriangleIntersects(edge.a, edge.b, right)))
+        + Number(triangleEdges(right).some((edge) => segmentTriangleIntersects(edge.a, edge.b, left)))
+        + Number(pointTriangleDistanceSquared(left.a, right) <= 1e-9)
+        + Number(pointTriangleDistanceSquared(right.a, left) <= 1e-9);
+    return overlapCount > 0;
+}
+function rayMeshDistance(pose, query) {
+    const distances = meshTriangles(pose)
+        .map((triangle) => rayTriangleDistance(query, triangle))
+        .filter((distance) => distance !== undefined)
+        .sort((left, right) => left - right);
+    return distances[0];
+}
+function rayExpandedMeshDistance(pose, query, radius) {
+    const distances = [];
+    for (const triangle of meshTriangles(pose)) {
+        const triangleDistance = rayTriangleDistance(query, triangle);
+        if (triangleDistance !== undefined) {
+            distances.push(triangleDistance);
+        }
+        for (const edge of triangleEdges(triangle)) {
+            const edgeDistance = raySegmentDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, edge.a, edge.b, radius, query.maxDistance);
+            if (edgeDistance !== undefined) {
+                distances.push(edgeDistance);
+            }
+        }
+        for (const vertex of [triangle.a, triangle.b, triangle.c]) {
+            const vertexDistance = raySphereDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, vertex.x, vertex.y, vertex.z, radius, query.maxDistance);
+            if (vertexDistance !== undefined) {
+                distances.push(vertexDistance);
+            }
+        }
+    }
+    return distances.sort((left, right) => left - right)[0];
+}
+function rayTriangleDistance(query, triangle) {
+    const edge1 = subtractPoint(triangle.b, triangle.a);
+    const edge2 = subtractPoint(triangle.c, triangle.a);
+    const direction = { x: query.dx, y: query.dy, z: query.dz };
+    const h = cross(direction, edge2);
+    const determinant = dot(edge1, h);
+    if (Math.abs(determinant) <= 1e-9) {
+        return undefined;
+    }
+    const inverseDeterminant = 1 / determinant;
+    const s = subtractPoint({ x: query.x, y: query.y, z: query.z }, triangle.a);
+    const u = inverseDeterminant * dot(s, h);
+    if (u < 0 || u > 1) {
+        return undefined;
+    }
+    const q = cross(s, edge1);
+    const v = inverseDeterminant * dot(direction, q);
+    if (v < 0 || u + v > 1) {
+        return undefined;
+    }
+    const distance = inverseDeterminant * dot(edge2, q);
+    return distance >= 0 && distance <= query.maxDistance ? quantizeDistance(distance) : undefined;
+}
+function segmentTriangleIntersects(start, end, triangle) {
+    const delta = subtractPoint(end, start);
+    const maxDistance = deterministicSqrt(dot(delta, delta));
+    if (maxDistance === 0) {
+        return pointTriangleDistanceSquared(start, triangle) <= 1e-9;
+    }
+    return rayTriangleDistance({
+        x: start.x,
+        y: start.y,
+        z: start.z,
+        dx: quantizeDistance(delta.x / maxDistance),
+        dy: quantizeDistance(delta.y / maxDistance),
+        dz: quantizeDistance(delta.z / maxDistance),
+        maxDistance,
+    }, triangle) !== undefined;
+}
+function segmentTriangleDistanceSquared(start, end, triangle) {
+    if (segmentTriangleIntersects(start, end, triangle)) {
+        return 0;
+    }
+    const candidates = [
+        pointTriangleDistanceSquared(start, triangle),
+        pointTriangleDistanceSquared(end, triangle),
+        distancePointSegmentSquared(triangle.a, start, end),
+        distancePointSegmentSquared(triangle.b, start, end),
+        distancePointSegmentSquared(triangle.c, start, end),
+        ...triangleEdges(triangle).map((edge) => segmentSegmentDistanceSquared(start, end, edge.a, edge.b)),
+    ];
+    return Math.min(...candidates);
+}
+function pointTriangleDistanceSquared(point, triangle) {
+    const ab = subtractPoint(triangle.b, triangle.a);
+    const ac = subtractPoint(triangle.c, triangle.a);
+    const ap = subtractPoint(point, triangle.a);
+    const d1 = dot(ab, ap);
+    const d2 = dot(ac, ap);
+    if (d1 <= 0 && d2 <= 0) {
+        return squaredDistance(point, triangle.a);
+    }
+    const bp = subtractPoint(point, triangle.b);
+    const d3 = dot(ab, bp);
+    const d4 = dot(ac, bp);
+    if (d3 >= 0 && d4 <= d3) {
+        return squaredDistance(point, triangle.b);
+    }
+    const vc = d1 * d4 - d3 * d2;
+    if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+        const v = d1 / (d1 - d3);
+        return squaredDistance(point, addPoint(triangle.a, scalePoint(ab, v)));
+    }
+    const cp = subtractPoint(point, triangle.c);
+    const d5 = dot(ab, cp);
+    const d6 = dot(ac, cp);
+    if (d6 >= 0 && d5 <= d6) {
+        return squaredDistance(point, triangle.c);
+    }
+    const vb = d5 * d2 - d1 * d6;
+    if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+        const w = d2 / (d2 - d6);
+        return squaredDistance(point, addPoint(triangle.a, scalePoint(ac, w)));
+    }
+    const va = d3 * d6 - d5 * d4;
+    if (va <= 0 && (d4 - d3) >= 0 && (d5 - d6) >= 0) {
+        const w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+        return squaredDistance(point, addPoint(triangle.b, scalePoint(subtractPoint(triangle.c, triangle.b), w)));
+    }
+    const denominator = 1 / (va + vb + vc);
+    const v = vb * denominator;
+    const w = vc * denominator;
+    return squaredDistance(point, addPoint(triangle.a, addPoint(scalePoint(ab, v), scalePoint(ac, w))));
+}
+function segmentSegmentDistanceSquared(leftA, leftB, rightA, rightB) {
+    const u = subtractPoint(leftB, leftA);
+    const v = subtractPoint(rightB, rightA);
+    const w = subtractPoint(leftA, rightA);
+    const a = dot(u, u);
+    const b = dot(u, v);
+    const c = dot(v, v);
+    const d = dot(u, w);
+    const e = dot(v, w);
+    const denominator = a * c - b * b;
+    const s = denominator === 0 ? 0 : clamp((b * e - c * d) / denominator, 0, 1);
+    const t = c === 0 ? 0 : clamp((b * s + e) / c, 0, 1);
+    const closestLeft = addPoint(leftA, scalePoint(u, s));
+    const closestRight = addPoint(rightA, scalePoint(v, t));
+    return squaredDistance(closestLeft, closestRight);
+}
+function distancePointSegmentSquared(point, start, end) {
+    const segment = subtractPoint(end, start);
+    const lengthSquared = dot(segment, segment);
+    if (lengthSquared === 0) {
+        return squaredDistance(point, start);
+    }
+    const t = clamp(dot(subtractPoint(point, start), segment) / lengthSquared, 0, 1);
+    return squaredDistance(point, addPoint(start, scalePoint(segment, t)));
+}
+function segmentAabbIntersects(start, end, bounds) {
+    const delta = subtractPoint(end, start);
+    const distance = deterministicSqrt(dot(delta, delta));
+    if (distance === 0) {
+        return pointInBounds(start, bounds);
+    }
+    return rayAabbDistanceExact(bounds, start.x, start.y, start.z, delta.x / distance, delta.y / distance, delta.z / distance, distance) !== undefined;
+}
+function triangleEdges(triangle) {
+    return [
+        { a: triangle.a, b: triangle.b },
+        { a: triangle.b, b: triangle.c },
+        { a: triangle.c, b: triangle.a },
+    ];
+}
+function boxCorners(bounds) {
+    const corners = [];
+    for (const x of [bounds.minX, bounds.maxX]) {
+        for (const y of [bounds.minY, bounds.maxY]) {
+            for (const z of [bounds.minZ, bounds.maxZ]) {
+                corners.push({ x, y, z });
+            }
+        }
+    }
+    return corners;
+}
+function boxEdges(bounds) {
+    return roundedBoxEdges(bounds);
+}
+function boundsFromPoints(points) {
+    const xs = points.map((point) => point.x);
+    const ys = points.map((point) => point.y);
+    const zs = points.map((point) => point.z);
+    return { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys), minZ: Math.min(...zs), maxZ: Math.max(...zs) };
+}
+function pointInBounds(point, bounds) {
+    return point.x >= bounds.minX && point.x <= bounds.maxX
+        && point.y >= bounds.minY && point.y <= bounds.maxY
+        && point.z >= bounds.minZ && point.z <= bounds.maxZ;
+}
+function subtractPoint(left, right) {
+    return { x: left.x - right.x, y: left.y - right.y, z: left.z - right.z };
+}
+function addPoint(left, right) {
+    return { x: left.x + right.x, y: left.y + right.y, z: left.z + right.z };
+}
+function scalePoint(point, scalar) {
+    return { x: point.x * scalar, y: point.y * scalar, z: point.z * scalar };
+}
+function dot(left, right) {
+    return left.x * right.x + left.y * right.y + left.z * right.z;
+}
+function cross(left, right) {
+    return {
+        x: left.y * right.z - left.z * right.y,
+        y: left.z * right.x - left.x * right.z,
+        z: left.x * right.y - left.y * right.x,
+    };
+}
+function squaredDistance(left, right) {
+    return square(left.x - right.x) + square(left.y - right.y) + square(left.z - right.z);
+}
+function intervalGap(leftMin, leftMax, rightMin, rightMax) {
+    return Math.max(0, rightMin - leftMax, leftMin - rightMax);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function inClosedRange2(first, firstMin, firstMax, second, secondMin, secondMax) {
+    return Math.max(firstMin - first, first - firstMax, secondMin - second, second - secondMax) <= 0;
+}
+function square(value) {
+    return value * value;
+}
+function boundsOverlap(left, right) {
+    return left.minX <= right.maxX && left.maxX >= right.minX
+        && left.minY <= right.maxY && left.maxY >= right.minY
+        && left.minZ <= right.maxZ && left.maxZ >= right.minZ;
+}
+function rayAabbDistance(bounds, query) {
+    const distance = rayAabbDistanceExact(bounds, query.x, query.y, query.z, query.dx, query.dy, query.dz, query.maxDistance);
+    return distance === undefined ? undefined : quantizeDistance(distance);
+}
+function rayBodyDistance(body, query) {
+    if (body.shape.type === 'sphere') {
+        return raySphereDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, body.x, body.y, body.z, body.shape.radius, query.maxDistance);
+    }
+    if (body.shape.type === 'capsule') {
+        return rayCapsuleDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, body.x, body.y, body.z, body.shape.radius, body.shape.halfHeight, query.maxDistance);
+    }
+    if (body.shape.type === 'mesh') {
+        return rayMeshDistance(meshPose(bodyPose(body), body.shape), query);
+    }
+    return rayAabbDistance(toBounds(body), query);
+}
+function shapeCastBodyDistance(body, query) {
+    if (overlapDeterministicPhysics3D(createDeterministicPhysicsWorld3D([body]), query).includes(body.id)) {
+        return 0;
+    }
+    if (query.shape.type === 'sphere') {
+        if (body.shape.type === 'mesh') {
+            return rayExpandedMeshDistance(meshPose(bodyPose(body), body.shape), query, query.shape.radius);
+        }
+        if (body.shape.type === 'sphere') {
+            return raySphereDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, body.x, body.y, body.z, body.shape.radius + query.shape.radius, query.maxDistance);
+        }
+        if (body.shape.type === 'capsule') {
+            return rayCapsuleDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, body.x, body.y, body.z, body.shape.radius + query.shape.radius, body.shape.halfHeight, query.maxDistance);
+        }
+        return rayRoundedBoxDistance(query.x, query.y, query.z, query.dx, query.dy, query.dz, toBounds(body), query.shape.radius, query.maxDistance);
+    }
+    const queryBounds = shapeBounds(query.x, query.y, query.z, query.shape);
+    const expanded = expandBoundsByBounds(toBounds(body), {
+        minX: query.x - queryBounds.minX,
+        maxX: queryBounds.maxX - query.x,
+        minY: query.y - queryBounds.minY,
+        maxY: queryBounds.maxY - query.y,
+        minZ: query.z - queryBounds.minZ,
+        maxZ: queryBounds.maxZ - query.z,
+    });
+    const distance = rayAabbDistanceExact(expanded, query.x, query.y, query.z, query.dx, query.dy, query.dz, query.maxDistance);
+    if (distance === undefined) {
+        return undefined;
+    }
+    const quantized = quantizeDistance(distance);
+    const overlapAtHit = shapesOverlap3D({ x: query.x + query.dx * quantized, y: query.y + query.dy * quantized, z: query.z + query.dz * quantized, shape: query.shape }, bodyPose(body));
+    return [undefined, quantized][Number(overlapAtHit)];
+}
+function rayRoundedBoxDistance(x, y, z, dx, dy, dz, bounds, radius, maxDistance) {
+    const candidates = [];
+    addFaceCandidate(candidates, 'x', bounds.minX - radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    addFaceCandidate(candidates, 'x', bounds.maxX + radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    addFaceCandidate(candidates, 'y', bounds.minY - radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    addFaceCandidate(candidates, 'y', bounds.maxY + radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    addFaceCandidate(candidates, 'z', bounds.minZ - radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    addFaceCandidate(candidates, 'z', bounds.maxZ + radius, x, y, z, dx, dy, dz, bounds, maxDistance);
+    for (const edge of roundedBoxEdges(bounds)) {
+        const distance = raySegmentDistance(x, y, z, dx, dy, dz, edge.a, edge.b, radius, maxDistance);
+        if (distance !== undefined) {
+            candidates.push(distance);
+        }
+    }
+    for (const cornerX of [bounds.minX, bounds.maxX]) {
+        for (const cornerY of [bounds.minY, bounds.maxY]) {
+            for (const cornerZ of [bounds.minZ, bounds.maxZ]) {
+                const distance = raySphereDistance(x, y, z, dx, dy, dz, cornerX, cornerY, cornerZ, radius, maxDistance);
+                if (distance !== undefined) {
+                    candidates.push(distance);
+                }
+            }
+        }
+    }
+    const distance = Math.min(...candidates);
+    return Number.isFinite(distance) ? distance : undefined;
+}
+function addFaceCandidate(candidates, axis, plane, x, y, z, dx, dy, dz, bounds, maxDistance) {
+    let direction = dx;
+    let origin = x;
+    if (axis === 'y') {
+        direction = dy;
+        origin = y;
+    }
+    else if (axis === 'z') {
+        direction = dz;
+        origin = z;
+    }
+    if (direction === 0) {
+        return;
+    }
+    const distance = (plane - origin) / direction;
+    if (distance < 0 || distance > maxDistance) {
+        return;
+    }
+    const hitX = x + dx * distance;
+    const hitY = y + dy * distance;
+    const hitZ = z + dz * distance;
+    let inside = inClosedRange2(hitY, bounds.minY, bounds.maxY, hitZ, bounds.minZ, bounds.maxZ);
+    if (axis === 'y') {
+        inside = inClosedRange2(hitX, bounds.minX, bounds.maxX, hitZ, bounds.minZ, bounds.maxZ);
+    }
+    else if (axis === 'z') {
+        inside = inClosedRange2(hitX, bounds.minX, bounds.maxX, hitY, bounds.minY, bounds.maxY);
+    }
+    if (inside) {
+        candidates.push(quantizeDistance(distance));
+    }
+}
+function roundedBoxEdges(bounds) {
+    const edges = [];
+    for (const y of [bounds.minY, bounds.maxY]) {
+        for (const z of [bounds.minZ, bounds.maxZ]) {
+            edges.push({ a: { x: bounds.minX, y, z }, b: { x: bounds.maxX, y, z } });
+        }
+    }
+    for (const x of [bounds.minX, bounds.maxX]) {
+        for (const z of [bounds.minZ, bounds.maxZ]) {
+            edges.push({ a: { x, y: bounds.minY, z }, b: { x, y: bounds.maxY, z } });
+        }
+    }
+    for (const x of [bounds.minX, bounds.maxX]) {
+        for (const y of [bounds.minY, bounds.maxY]) {
+            edges.push({ a: { x, y, z: bounds.minZ }, b: { x, y, z: bounds.maxZ } });
+        }
+    }
+    return edges;
+}
+function raySegmentDistance(x, y, z, dx, dy, dz, a, b, radius, maxDistance) {
+    const sx = b.x - a.x;
+    const sy = b.y - a.y;
+    const sz = b.z - a.z;
+    const wx = x - a.x;
+    const wy = y - a.y;
+    const wz = z - a.z;
+    const ss = sx * sx + sy * sy + sz * sz;
+    const ds = dx * sx + dy * sy + dz * sz;
+    const ws = wx * sx + wy * sy + wz * sz;
+    const dd = dx * dx + dy * dy + dz * dz;
+    const dw = dx * wx + dy * wy + dz * wz;
+    const ww = wx * wx + wy * wy + wz * wz;
+    const aCoeff = dd - (ds * ds) / ss;
+    const bCoeff = 2 * (dw - (ds * ws) / ss);
+    const cCoeff = ww - (ws * ws) / ss - radius * radius;
+    if (aCoeff === 0) {
+        return undefined;
+    }
+    const discriminant = bCoeff * bCoeff - 4 * aCoeff * cCoeff;
+    if (discriminant < 0) {
+        return undefined;
+    }
+    const root = deterministicSqrt(discriminant);
+    const candidates = [(-bCoeff - root) / (2 * aCoeff), (-bCoeff + root) / (2 * aCoeff)]
+        .filter((distance) => distance >= 0 && distance <= maxDistance)
+        .sort((left, right) => left - right);
+    for (const distance of candidates) {
+        const t = (ws + ds * distance) / ss;
+        if (t >= 0 && t <= 1) {
+            return quantizeDistance(distance);
+        }
+    }
+    return undefined;
+}
+function raySphereDistance(x, y, z, dx, dy, dz, sphereX, sphereY, sphereZ, radius, maxDistance) {
+    const ox = x - sphereX;
+    const oy = y - sphereY;
+    const oz = z - sphereZ;
+    const a = dx * dx + dy * dy + dz * dz;
+    if (a === 0 || maxDistance < 0) {
+        return undefined;
+    }
+    const b = 2 * (ox * dx + oy * dy + oz * dz);
+    const c = ox * ox + oy * oy + oz * oz - radius * radius;
+    if (c <= 0) {
+        return 0;
+    }
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return undefined;
+    }
+    const root = deterministicSqrt(discriminant);
+    const near = (-b - root) / (2 * a);
+    const far = (-b + root) / (2 * a);
+    const candidateDistance = Math.min(...[near, far].filter((candidate) => candidate >= 0));
+    if (!Number.isFinite(candidateDistance) || candidateDistance > maxDistance) {
+        return undefined;
+    }
+    return quantizeDistance(candidateDistance);
+}
+function rayCapsuleDistance(x, y, z, dx, dy, dz, capsuleX, capsuleY, capsuleZ, radius, halfHeight, maxDistance) {
+    const candidates = [
+        raySphereDistance(x, y, z, dx, dy, dz, capsuleX, capsuleY - halfHeight, capsuleZ, radius, maxDistance),
+        raySphereDistance(x, y, z, dx, dy, dz, capsuleX, capsuleY + halfHeight, capsuleZ, radius, maxDistance),
+        rayVerticalCylinderDistance(x, y, z, dx, dy, dz, capsuleX, capsuleY, capsuleZ, radius, halfHeight, maxDistance),
+    ].filter((distance) => distance !== undefined);
+    const distance = Math.min(...candidates);
+    return Number.isFinite(distance) ? distance : undefined;
+}
+function rayVerticalCylinderDistance(x, y, z, dx, dy, dz, centerX, centerY, centerZ, radius, halfHeight, maxDistance) {
+    const ox = x - centerX;
+    const oz = z - centerZ;
+    const a = dx * dx + dz * dz;
+    if (a === 0 || maxDistance < 0) {
+        return undefined;
+    }
+    const b = 2 * (ox * dx + oz * dz);
+    const c = ox * ox + oz * oz - radius * radius;
+    if (c <= 0 && y >= centerY - halfHeight && y <= centerY + halfHeight) {
+        return 0;
+    }
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return undefined;
+    }
+    const root = deterministicSqrt(discriminant);
+    const candidates = [(-b - root) / (2 * a), (-b + root) / (2 * a)]
+        .filter((distance) => distance >= 0 && distance <= maxDistance)
+        .sort((left, right) => left - right);
+    for (const distance of candidates) {
+        const hitY = y + dy * distance;
+        if (hitY >= centerY - halfHeight && hitY <= centerY + halfHeight) {
+            return quantizeDistance(distance);
+        }
+    }
+    return undefined;
+}
+function rayAabbDistanceExact(bounds, x, y, z, dx, dy, dz, maxDistance) {
+    if (maxDistance < 0) {
+        return undefined;
+    }
+    let tMin = 0;
+    let tMax = maxDistance;
+    const axes = [
+        { origin: x, direction: dx, min: bounds.minX, max: bounds.maxX },
+        { origin: y, direction: dy, min: bounds.minY, max: bounds.maxY },
+        { origin: z, direction: dz, min: bounds.minZ, max: bounds.maxZ },
+    ];
+    for (const axis of axes) {
+        if (axis.direction === 0) {
+            if (axis.origin < axis.min || axis.origin > axis.max) {
+                return undefined;
+            }
+            continue;
+        }
+        const inv = 1 / axis.direction;
+        const near = (axis.min - axis.origin) * inv;
+        const far = (axis.max - axis.origin) * inv;
+        tMin = Math.max(tMin, Math.min(near, far));
+        tMax = Math.min(tMax, Math.max(near, far));
+        if (tMin > tMax) {
+            return undefined;
+        }
+    }
+    return Math.max(0, tMin);
+}
+function expandBoundsByBounds(bounds, extents) {
+    return {
+        minX: bounds.minX - extents.maxX,
+        maxX: bounds.maxX - extents.minX,
+        minY: bounds.minY - extents.maxY,
+        maxY: bounds.maxY - extents.minY,
+        minZ: bounds.minZ - extents.maxZ,
+        maxZ: bounds.maxZ - extents.minZ,
+    };
+}
+function quantizeDistance(distance) {
+    // Pure integer rounding, not Number.prototype.toFixed — see physics2d
+    // quantizeDistance (cross-engine half-way divergence on checksummed state).
+    const quantized = Math.round(distance * 1e6) / 1e6;
+    return quantized === 0 ? 0 : quantized;
+}
+function quantizeAngle(value) {
+    const wrapped = value - Math.floor(value);
+    const quantizedAngle = Math.round(wrapped * 1e6) / 1e6;
+    return quantizedAngle === 0 ? 0 : quantizedAngle;
+}
+function deterministicSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    // Seed the Newton iteration from the argument's magnitude (2^ceil(bits/2)):
+    // starting from `value` itself needs ~0.5*log2(value) halving steps before
+    // the quadratic regime, so 8 iterations only converged for tiny inputs —
+    // at realistic fixed-point magnitudes (dx^2+dy^2 ~ 1e10) the old seed
+    // returned results off by orders of magnitude. Every operation here is
+    // exact integer/IEEE-deterministic arithmetic, so all peers still agree.
+    let estimate = 1;
+    let magnitude = value;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return quantizeDistance(estimate);
+}
+function countCandidatePairs(bodies) {
+    return broadphaseCandidatePairs(bodies).length;
+}
+function detailedHitForBody(body, query, distance, castRadius) {
+    const center = quantizePoint({
+        x: query.x + query.dx * distance,
+        y: query.y + query.dy * distance,
+        z: query.z + query.dz * distance,
+    });
+    const normal = hitNormalForBody(body, center);
+    const point = quantizePoint({
+        x: center.x - normal.x * castRadius,
+        y: center.y - normal.y * castRadius,
+        z: center.z - normal.z * castRadius,
+    });
+    return {
+        bodyId: body.id,
+        distance,
+        point,
+        normal,
+        penetration: distance === 0 ? penetrationAtPoint(body, center, castRadius) : 0,
+    };
+}
+function hitNormalForBody(body, point) {
+    if (body.shape.type === 'sphere') {
+        return normalizePoint({
+            x: point.x - body.x,
+            y: point.y - body.y,
+            z: point.z - body.z,
+        });
+    }
+    const bounds = toBounds(body);
+    const candidates = [
+        { normal: { x: -1, y: 0, z: 0 }, distance: Math.abs(point.x - bounds.minX), axis: 'x-' },
+        { normal: { x: 1, y: 0, z: 0 }, distance: Math.abs(point.x - bounds.maxX), axis: 'x+' },
+        { normal: { x: 0, y: -1, z: 0 }, distance: Math.abs(point.y - bounds.minY), axis: 'y-' },
+        { normal: { x: 0, y: 1, z: 0 }, distance: Math.abs(point.y - bounds.maxY), axis: 'y+' },
+        { normal: { x: 0, y: 0, z: -1 }, distance: Math.abs(point.z - bounds.minZ), axis: 'z-' },
+        { normal: { x: 0, y: 0, z: 1 }, distance: Math.abs(point.z - bounds.maxZ), axis: 'z+' },
+    ].sort((left, right) => left.distance - right.distance || compareStrings(left.axis, right.axis));
+    return candidates[0].normal;
+}
+function penetrationAtPoint(body, point, castRadius) {
+    if (body.shape.type === 'sphere') {
+        const centerDistance = deterministicSqrt(square(point.x - body.x) + square(point.y - body.y) + square(point.z - body.z));
+        return quantizeDistance(Math.max(0, body.shape.radius + castRadius - centerDistance));
+    }
+    const bounds = toBounds(body);
+    if (point.x < bounds.minX || point.x > bounds.maxX || point.y < bounds.minY || point.y > bounds.maxY || point.z < bounds.minZ || point.z > bounds.maxZ) {
+        return 0;
+    }
+    return quantizeDistance(Math.min(point.x - bounds.minX, bounds.maxX - point.x, point.y - bounds.minY, bounds.maxY - point.y, point.z - bounds.minZ, bounds.maxZ - point.z) + castRadius);
+}
+function contactDetailForBodies(contact, left, right) {
+    const leftBounds = toBounds(left);
+    const rightBounds = toBounds(right);
+    const overlaps = [
+        { axis: 'x', amount: Math.min(leftBounds.maxX, rightBounds.maxX) - Math.max(leftBounds.minX, rightBounds.minX) },
+        { axis: 'y', amount: Math.min(leftBounds.maxY, rightBounds.maxY) - Math.max(leftBounds.minY, rightBounds.minY) },
+        { axis: 'z', amount: Math.min(leftBounds.maxZ, rightBounds.maxZ) - Math.max(leftBounds.minZ, rightBounds.minZ) },
+    ].sort((leftOverlap, rightOverlap) => leftOverlap.amount - rightOverlap.amount || compareStrings(leftOverlap.axis, rightOverlap.axis));
+    const axis = overlaps[0].axis;
+    const normal = contactNormalForAxis(axis, left, right);
+    return {
+        pair: contact.pair,
+        a: contact.a,
+        b: contact.b,
+        trigger: contact.trigger,
+        sensor: contact.sensor,
+        point: quantizePoint({
+            x: (Math.max(leftBounds.minX, rightBounds.minX) + Math.min(leftBounds.maxX, rightBounds.maxX)) / 2,
+            y: (Math.max(leftBounds.minY, rightBounds.minY) + Math.min(leftBounds.maxY, rightBounds.maxY)) / 2,
+            z: (Math.max(leftBounds.minZ, rightBounds.minZ) + Math.min(leftBounds.maxZ, rightBounds.maxZ)) / 2,
+        }),
+        normal,
+        penetration: quantizeDistance(Math.max(0, overlaps[0].amount)),
+    };
+}
+function contactNormalForAxis(axis, left, right) {
+    if (axis === 'x') {
+        return { x: right.x >= left.x ? 1 : -1, y: 0, z: 0 };
+    }
+    if (axis === 'y') {
+        return { x: 0, y: right.y >= left.y ? 1 : -1, z: 0 };
+    }
+    return { x: 0, y: 0, z: right.z >= left.z ? 1 : -1 };
+}
+function normalizePoint(point) {
+    const length = deterministicSqrt(point.x * point.x + point.y * point.y + point.z * point.z);
+    if (length === 0) {
+        return { x: -1, y: 0, z: 0 };
+    }
+    return quantizePoint({ x: point.x / length, y: point.y / length, z: point.z / length });
+}
+function quantizePoint(point) {
+    return {
+        x: quantizeDistance(point.x),
+        y: quantizeDistance(point.y),
+        z: quantizeDistance(point.z),
+    };
+}
+function compareHits(left, right) {
+    return left.distance - right.distance || compareStrings(left.bodyId, right.bodyId);
+}
+function compareContactDetails(left, right) {
+    return compareStrings(left.pair, right.pair);
+}
+function contactEventEnabled(event, bodyById) {
+    const bit = contactEventCallbackBit(event);
+    const left = bodyById.get(event.a);
+    const right = bodyById.get(event.b);
+    const leftMask = bodyCallbackMask(left);
+    const rightMask = bodyCallbackMask(right);
+    return leftMask === undefined
+        || rightMask === undefined
+        || (leftMask & bit) !== 0
+        || (rightMask & bit) !== 0;
+}
+function contactEventCallbackBit(event) {
+    if (event.trigger || event.sensor) {
+        if (event.type === 'enter')
+            return exports.deterministicPhysicsCallback3D.triggerEnter;
+        if (event.type === 'stay')
+            return exports.deterministicPhysicsCallback3D.triggerStay;
+        return exports.deterministicPhysicsCallback3D.triggerExit;
+    }
+    if (event.type === 'enter')
+        return exports.deterministicPhysicsCallback3D.collisionEnter;
+    if (event.type === 'stay')
+        return exports.deterministicPhysicsCallback3D.collisionStay;
+    return exports.deterministicPhysicsCallback3D.collisionExit;
+}
+function bodyCallbackMask(body) {
+    return body?.callbackMask;
+}
+function compareContactEvents(left, right) {
+    return compareStrings(left.pair, right.pair) || compareStrings(left.type, right.type);
+}
+function compareActivePairMetadata(left, right) {
+    return compareStrings(left.pair, right.pair);
+}
+function percentile(values, percentileRank) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const percentileValue = sorted[Math.min(sorted.length - 1, Math.floor((percentileRank / 100) * sorted.length))];
+    return Math.round(percentileValue * 1e4) / 1e4;
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}