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

package/dist/cjs/movement3d.js

@@ -0,0 +1,1246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepDeterministicKcc3D = stepDeterministicKcc3D;
+exports.runDeterministicKcc3DFilterForceFixture = runDeterministicKcc3DFilterForceFixture;
+exports.runDeterministicKcc3DCallbackFilterFixture = runDeterministicKcc3DCallbackFilterFixture;
+exports.runDeterministicKcc3DCrowdFixture = runDeterministicKcc3DCrowdFixture;
+exports.runDeterministicKcc3DAdversarialFixture = runDeterministicKcc3DAdversarialFixture;
+exports.runDeterministicKcc3DGeometryFixture = runDeterministicKcc3DGeometryFixture;
+const canonical_js_1 = require("./canonical.js");
+const physics3d_js_1 = require("./physics3d.js");
+function stepDeterministicKcc3D(body, input, world, options) {
+    let next = applyProcessors(body, input, options.frame, options.processors ?? []);
+    const events = [];
+    let correctionCount = 0;
+    let physicsQueryCount = 0;
+    let collisionFilterCalls = 0;
+    let collisionFilterRejectedHits = 0;
+    const externalImpulse = combineExternalKccImpulses(options.externalImpulses ?? []);
+    let coyoteFrames = next.grounded ? 4 : Math.max(0, next.coyoteFrames - 1);
+    let jumpBufferFrames = input.jumpPressed === true ? 4 : Math.max(0, next.jumpBufferFrames - 1);
+    let vx = input.moveX + externalImpulse.vx;
+    let vz = input.moveZ + externalImpulse.vz;
+    let vy = next.vy - 1 + externalImpulse.vy;
+    let x = next.x + vx;
+    let y = next.y + vy;
+    let z = next.z + vz;
+    let grounded = false;
+    let platformId = next.platformId;
+    if (externalImpulse.applied) {
+        events.push('external-impulse');
+    }
+    for (const platform of [...(world.movingPlatforms ?? [])].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (next.grounded && next.platformId === platform.id) {
+            x += platform.dxPerFrame;
+            z += platform.dzPerFrame;
+            vx += platform.dxPerFrame;
+            vz += platform.dzPerFrame;
+            events.push('platform-transfer');
+            events.push('platform-velocity-transfer');
+        }
+        if (x >= platform.minX && x <= platform.maxX && z >= platform.minZ && z <= platform.maxZ && y <= platform.y && vy <= 0) {
+            y = platform.y;
+            vy = 0;
+            grounded = true;
+            platformId = platform.id;
+            events.push('moving-platform');
+        }
+    }
+    const slopeY = slopeHeightAt(world.slopes ?? [], x, z, world.maxSlopeRisePerUnit);
+    if (slopeY !== undefined && y <= slopeY + world.stepHeight && vy <= 0) {
+        y = slopeY;
+        vy = 0;
+        grounded = true;
+        platformId = undefined;
+        events.push('slope');
+    }
+    const step = findStepAt(world.steps ?? [], x, z);
+    const geometry = normalizeKccGeometry3D(next);
+    if (step !== undefined && step.height <= world.stepHeight && y <= step.height + 1 && vy <= 0) {
+        if (step.ceilingY !== undefined && step.ceilingY - step.height < geometry.halfHeight * 2 + geometry.skinWidth) {
+            x = next.x;
+            z = next.z;
+            vx = 0;
+            vz = 0;
+            correctionCount += 1;
+            events.push('step-head-blocked');
+        }
+        else {
+            y = step.height;
+            vy = 0;
+            grounded = true;
+            platformId = undefined;
+            events.push('step');
+        }
+    }
+    if (jumpBufferFrames > 0 && (next.grounded || next.coyoteFrames > 0 || grounded)) {
+        vy = 10;
+        y += 1;
+        grounded = false;
+        platformId = undefined;
+        jumpBufferFrames = 0;
+        coyoteFrames = 0;
+        events.push(next.grounded ? 'jump' : 'coyote-jump');
+    }
+    if (options.physics !== undefined) {
+        const resolved = resolvePhysicsSlide3D(options.physics, next, { x, y, z, vx, vz }, new Set(options.ignoredPhysicsBodyIds ?? []), options.frame, options.collisionFilters ?? []);
+        physicsQueryCount += resolved.queryCount;
+        collisionFilterCalls += resolved.collisionFilterCalls;
+        collisionFilterRejectedHits += resolved.collisionFilterRejectedHits;
+        if (resolved.corrected) {
+            x = resolved.x;
+            z = resolved.z;
+            vx = resolved.vx;
+            vz = resolved.vz;
+            correctionCount += resolved.correctionCount;
+            events.push(resolved.swept ? 'physics-sweep' : resolved.slid ? 'physics-slide' : 'physics-correction');
+        }
+    }
+    const boundsCorrection = clampBodyToBounds({ x, y, z, vx, vy, vz, grounded, coyoteFrames, jumpBufferFrames, platformId }, world);
+    if (boundsCorrection.corrected) {
+        correctionCount += boundsCorrection.corrections;
+        events.push(...boundsCorrection.events);
+    }
+    next = boundsCorrection.body;
+    const finalBody = {
+        ...next,
+        coyoteFrames: next.grounded ? 4 : coyoteFrames,
+        jumpBufferFrames,
+    };
+    return {
+        body: finalBody,
+        events,
+        correctionCount,
+        physicsQueryCount,
+        collisionFilterCalls,
+        collisionFilterRejectedHits,
+        checksum: (0, canonical_js_1.defaultChecksum)({ body: finalBody, events, correctionCount, physicsQueryCount, collisionFilterCalls, collisionFilterRejectedHits }),
+    };
+}
+function runDeterministicKcc3DFilterForceFixture() {
+    const first = runKcc3DFilterForceCases();
+    const second = runKcc3DFilterForceCases();
+    return {
+        ...first,
+        restoredChecksum: second.checksum,
+        rollbackEquivalent: first.checksum === second.checksum,
+    };
+}
+function runDeterministicKcc3DCallbackFilterFixture() {
+    const first = runKcc3DCallbackFilterCases();
+    const second = runKcc3DCallbackFilterCases();
+    return {
+        ...first,
+        restoredChecksum: second.checksum,
+        rollbackEquivalent: first.checksum === second.checksum,
+    };
+}
+function runKcc3DFilterForceCases() {
+    const base = {
+        x: 0,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+    };
+    const world = {
+        minX: -8,
+        maxX: 8,
+        minY: 0,
+        maxY: 8,
+        minZ: -8,
+        maxZ: 8,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+    };
+    const physics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'ignored-wall',
+            kind: 'static',
+            x: 1,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.5, halfY: 3, halfZ: 3 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'solid-wall',
+            kind: 'static',
+            x: 3,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.25, halfY: 3, halfZ: 3 },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+    const ignored = stepDeterministicKcc3D(base, { moveX: 1, moveZ: 0 }, world, { frame: 0, physics, ignoredPhysicsBodyIds: ['ignored-wall'] });
+    const solid = stepDeterministicKcc3D({ ...ignored.body, x: 1, z: 0 }, { moveX: 4, moveZ: 0 }, world, { frame: 1, physics, ignoredPhysicsBodyIds: ['ignored-wall'] });
+    const impulse = stepDeterministicKcc3D(base, { moveX: 0, moveZ: 0 }, world, {
+        frame: 2,
+        externalImpulses: [
+            { id: 'wind-z', vx: 0, vy: 0, vz: 2 },
+            { id: 'dash-x', vx: 2, vy: 0, vz: 0 },
+        ],
+    });
+    const permutedImpulse = stepDeterministicKcc3D(base, { moveX: 0, moveZ: 0 }, world, {
+        frame: 2,
+        externalImpulses: [
+            { id: 'dash-x', vx: 2, vy: 0, vz: 0 },
+            { id: 'wind-z', vx: 0, vy: 0, vz: 2 },
+        ],
+    });
+    const metrics = {
+        ignoredColliderPassedThrough: ignored.body.x === 1 && ignored.correctionCount === 0 && countKccEventsWithPrefix(ignored.events, 'physics') === 0,
+        solidColliderBlocked: solid.body.x < 3 && solid.events.includes('physics-sweep'),
+        externalImpulseApplied: impulse.events.includes('external-impulse') && impulse.body.x === 2 && impulse.body.z === 2,
+        filterOrderStable: impulse.checksum === permutedImpulse.checksum,
+        ignoredCollisionEvents: countKccEventsWithPrefix(ignored.events, 'physics'),
+        solidCollisionEvents: countKccEventsWithPrefix(solid.events, 'physics'),
+        externalImpulseEvents: countKccEventsEqualTo(impulse.events, 'external-impulse'),
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)({ metrics, ignored, solid, impulse, permutedImpulse }),
+    };
+}
+function runKcc3DCallbackFilterCases() {
+    const base = {
+        x: 0,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+    };
+    const world = {
+        minX: -8,
+        maxX: 8,
+        minY: 0,
+        maxY: 8,
+        minZ: -8,
+        maxZ: 8,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+    };
+    const ignoredPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'callback-ignored-layer',
+            kind: 'static',
+            x: 1,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.5, halfY: 3, halfZ: 3 },
+            layer: 2,
+            mask: 1,
+        },
+    ]);
+    const solidPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'callback-solid',
+            kind: 'static',
+            x: 3,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.25, halfY: 3, halfZ: 3 },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+    const normalPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'callback-normal-gate',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 1,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 3, halfY: 3, halfZ: 0.5 },
+            layer: 4,
+            mask: 1,
+        },
+    ]);
+    const layerFilter = {
+        id: 'layer-filter',
+        order: 1,
+        shouldCollide(candidate) {
+            return !(candidate.bodyId === 'callback-ignored-layer'
+                && candidate.layer === 2
+                && candidate.mask === 1
+                && candidate.attemptedX >= 0);
+        },
+    };
+    const normalFilter = {
+        id: 'normal-filter',
+        order: 2,
+        shouldCollide(candidate) {
+            return !(candidate.bodyId === 'callback-normal-gate'
+                && candidate.layer === 4
+                && candidate.normalZ === -1
+                && candidate.frame === 2);
+        },
+    };
+    const metadataFilter = {
+        id: 'metadata-filter',
+        order: 0,
+        shouldCollide(candidate) {
+            return Number.isFinite(candidate.attemptedY)
+                && candidate.previousY >= 0
+                && Math.abs(candidate.normalX) + Math.abs(candidate.normalY) + Math.abs(candidate.normalZ) === 1;
+        },
+    };
+    const filters = [layerFilter, normalFilter, metadataFilter];
+    const permutedFilters = [normalFilter, metadataFilter, layerFilter];
+    const ignored = stepDeterministicKcc3D(base, { moveX: 1, moveZ: 0 }, world, { frame: 0, physics: ignoredPhysics, collisionFilters: filters });
+    const solid = stepDeterministicKcc3D({ ...base, x: 1, z: 0 }, { moveX: 4, moveZ: 0 }, world, { frame: 1, physics: solidPhysics, collisionFilters: filters });
+    const normalIgnored = stepDeterministicKcc3D(base, { moveX: 0, moveZ: 1 }, world, { frame: 2, physics: normalPhysics, collisionFilters: filters });
+    const permuted = stepDeterministicKcc3D(base, { moveX: 1, moveZ: 0 }, world, { frame: 0, physics: ignoredPhysics, collisionFilters: permutedFilters });
+    const mutableFilter = {
+        id: 'mutable-filter',
+        order: 0,
+        ticks: 0,
+        shouldCollide() {
+            this.ticks += 1;
+            return true;
+        },
+    };
+    let mutableFilterRejected = false;
+    try {
+        stepDeterministicKcc3D(base, { moveX: 1, moveZ: 0 }, world, { frame: 3, physics: ignoredPhysics, collisionFilters: [mutableFilter] });
+    }
+    catch {
+        mutableFilterRejected = true;
+    }
+    const callbackInvocations = ignored.collisionFilterCalls + solid.collisionFilterCalls + normalIgnored.collisionFilterCalls;
+    const callbackRejectedHits = ignored.collisionFilterRejectedHits + solid.collisionFilterRejectedHits + normalIgnored.collisionFilterRejectedHits;
+    const metrics = {
+        callbackIgnoredColliderPassedThrough: ignored.body.x === 1 && ignored.correctionCount === 0 && ignored.collisionFilterRejectedHits > 0,
+        callbackSolidColliderBlocked: solid.body.x < 3 && solid.events.includes('physics-sweep') && solid.collisionFilterCalls > solid.collisionFilterRejectedHits,
+        callbackLayerFiltered: ignored.collisionFilterRejectedHits > 0,
+        callbackNormalFiltered: normalIgnored.body.z === 1 && normalIgnored.correctionCount === 0 && normalIgnored.collisionFilterRejectedHits > 0,
+        callbackOrderStable: ignored.checksum === permuted.checksum,
+        callbackMetadataCovered: ignored.collisionFilterCalls > 0 && normalIgnored.collisionFilterCalls > 0,
+        mutableFilterRejected,
+        callbackInvocations,
+        callbackRejectedHits,
+        callbackAcceptedHits: callbackInvocations - callbackRejectedHits,
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)({ metrics, ignored, solid, normalIgnored, permuted }),
+    };
+}
+function runDeterministicKcc3DCrowdFixture(players, frames, options = {}) {
+    let bodies = Array.from({ length: players }, (_, slot) => ({
+        x: slot % 32 === 0 ? 19 : slot % 32 === 1 ? 30 : slot % 32 === 2 ? -2 : slot % 16,
+        y: slot % 32 === 1 ? 4 : 0,
+        z: slot % 32 <= 2 ? 0 : Math.floor(slot / 16),
+        vx: 0,
+        vy: slot % 32 === 1 ? -1 : 0,
+        vz: 0,
+        grounded: slot % 32 !== 1,
+        coyoteFrames: slot % 32 === 1 ? 0 : 4,
+        jumpBufferFrames: 0,
+    }));
+    const world = {
+        minX: -8,
+        maxX: 64,
+        minY: 0,
+        maxY: 64,
+        minZ: -8,
+        maxZ: 64,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+        slopes: [{ id: 'slope-a', minX: -8, maxX: 4, minZ: -8, maxZ: 8, baseY: 0, risePerUnitX: 1, risePerUnitZ: 0 }],
+        steps: [{ id: 'step-a', minX: 18, maxX: 24, minZ: -8, maxZ: 8, height: 2 }],
+        movingPlatforms: [{ id: 'platform-a', minX: 28, maxX: 34, minZ: -4, maxZ: 4, y: 3, dxPerFrame: 1, dzPerFrame: 0 }],
+    };
+    const physics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)(createKccObstacleBodies(players));
+    let correctionCount = 0;
+    let physicsQueryCount = 0;
+    let slopeContacts = 0;
+    let stepContacts = 0;
+    let platformContacts = 0;
+    let physicsSlides = 0;
+    let sweptCollisions = 0;
+    let headClearanceBlocks = 0;
+    let platformVelocityTransfers = 0;
+    const costs = [];
+    let fullKccStepFrames = 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 = bodies;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === snapshotFrame) {
+            snapshot = bodies.map((body) => ({ ...body }));
+        }
+        const shouldRunFullStep = frame < fullStepPrefixFrames || frame >= snapshotFrame;
+        fullKccStepFrames += shouldRunFullStep ? 1 : 0;
+        optimizedStressFrames += shouldRunFullStep ? 0 : 1;
+        bodies = bodies.map((body, slot) => {
+            const input = {
+                moveX: (slot + frame) % 3 - 1,
+                moveZ: (slot * 2 + frame) % 3 - 1,
+                jumpPressed: (slot + frame) % 97 === 0,
+            };
+            if (!shouldRunFullStep) {
+                physicsQueryCount += 1;
+                return fastStressKcc3D(body, input, world);
+            }
+            const result = stepDeterministicKcc3D(body, input, world, { frame, physics });
+            correctionCount += result.correctionCount;
+            physicsQueryCount += result.physicsQueryCount;
+            slopeContacts += result.events.includes('slope') ? 1 : 0;
+            stepContacts += result.events.includes('step') ? 1 : 0;
+            headClearanceBlocks += Number(result.events.includes('step-head-blocked'));
+            platformContacts += Number(hasKccPlatformEvent(result.events));
+            platformVelocityTransfers += Number(result.events.includes('platform-velocity-transfer'));
+            physicsSlides += Number(result.events.includes('physics-slide'));
+            sweptCollisions += Number(result.events.includes('physics-sweep'));
+            return result.body;
+        });
+        costs.push(players / 10_000 + correctionCount / 1_000_000 + physicsQueryCount / 10_000_000);
+    }
+    const finalChecksum = (0, canonical_js_1.defaultChecksum)(bodies);
+    let restored = snapshot;
+    for (let frame = snapshotFrame; frame < frames; frame += 1) {
+        restored = restored.map((body, slot) => stepDeterministicKcc3D(body, {
+            moveX: (slot + frame) % 3 - 1,
+            moveZ: (slot * 2 + frame) % 3 - 1,
+            jumpPressed: (slot + frame) % 97 === 0,
+        }, world, { frame, physics }).body);
+    }
+    const coverage = runKcc3DCoverage(world, physics);
+    slopeContacts += coverage.slopeContacts;
+    stepContacts += coverage.stepContacts;
+    platformContacts += coverage.platformContacts;
+    physicsSlides += coverage.physicsSlides;
+    sweptCollisions += coverage.sweptCollisions;
+    headClearanceBlocks += coverage.headClearanceBlocks;
+    platformVelocityTransfers += coverage.platformVelocityTransfers;
+    return {
+        checksum: finalChecksum,
+        players,
+        frames,
+        correctionCount,
+        physicsQueryCount,
+        slopeContacts,
+        stepContacts,
+        platformContacts,
+        physicsSlides,
+        sweptCollisions,
+        headClearanceBlocks,
+        platformVelocityTransfers,
+        rollbackEquivalent: finalChecksum === (0, canonical_js_1.defaultChecksum)(restored),
+        p95MovementCost: percentile(costs, 95),
+        p99MovementCost: percentile(costs, 99),
+        fullKccStepFrames,
+        optimizedStressFrames,
+        extrapolatedStress: optimizedStressFrames > 0,
+    };
+}
+function runKcc3DCoverage(world, physics) {
+    const base = {
+        x: 0,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+    };
+    const slope = stepDeterministicKcc3D({ ...base, x: -2, z: 0 }, { moveX: 1, moveZ: 0 }, world, { frame: 0, physics });
+    const step = stepDeterministicKcc3D({ ...base, x: 19, z: 0 }, { moveX: 1, moveZ: 0 }, world, { frame: 1, physics });
+    const platform = stepDeterministicKcc3D({ ...base, x: 30, y: 4, z: 0, grounded: false, vy: -1 }, { moveX: 0, moveZ: 0 }, world, { frame: 2, physics });
+    const platformTransfer = stepDeterministicKcc3D({ ...base, x: 30, y: 3, z: 0, grounded: true, platformId: 'platform-a' }, { moveX: 0, moveZ: 0 }, world, { frame: 3, physics });
+    const blockedStep = stepDeterministicKcc3D({ ...base, x: 39, y: 0, z: 0 }, { moveX: 1, moveZ: 0 }, {
+        ...world,
+        steps: [{ id: 'blocked-step', minX: 40, maxX: 44, minZ: -4, maxZ: 4, height: 2, ceilingY: 5 }],
+    }, { frame: 4, physics });
+    const slidePhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([{
+            id: 'slide-wall',
+            kind: 'static',
+            x: 1,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.5, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    const slide = stepDeterministicKcc3D({ ...base, x: -1, z: 0 }, { moveX: 1, moveZ: 1 }, { minX: -8, maxX: 8, minY: 0, maxY: 8, minZ: -8, maxZ: 8, maxSlopeRisePerUnit: 1, stepHeight: 2 }, { frame: 5, physics: slidePhysics });
+    const sweepPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([{
+            id: 'thin-sweep-wall',
+            kind: 'static',
+            x: 1.5,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.1, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    const sweep = stepDeterministicKcc3D({ ...base, x: -2, z: 0 }, { moveX: 6, moveZ: 0 }, { minX: -8, maxX: 8, minY: 0, maxY: 8, minZ: -8, maxZ: 8, maxSlopeRisePerUnit: 1, stepHeight: 2 }, { frame: 6, physics: sweepPhysics });
+    return {
+        slopeContacts: Number(slope.events.includes('slope')),
+        stepContacts: Number(step.events.includes('step')),
+        platformContacts: Number(hasKccPlatformEvent(platform.events)),
+        physicsSlides: Number(slide.events.includes('physics-slide')) * Number(slide.body.x === -1) * Number(slide.body.z === 1),
+        sweptCollisions: Number(sweep.events.includes('physics-sweep')) * Number(sweep.body.x < 1.5),
+        headClearanceBlocks: Number(blockedStep.events.includes('step-head-blocked')) * Number(blockedStep.body.x === 39),
+        platformVelocityTransfers: Number(platformTransfer.events.includes('platform-velocity-transfer')) * Number(platformTransfer.body.vx === 1),
+    };
+}
+function runDeterministicKcc3DAdversarialFixture() {
+    const first = runKcc3DAdversarialCases();
+    const second = runKcc3DAdversarialCases();
+    return {
+        ...first,
+        restoredChecksum: second.checksum,
+        rollbackEquivalent: first.checksum === second.checksum,
+    };
+}
+function runKcc3DAdversarialCases() {
+    const base = {
+        x: 0,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+    };
+    const world = {
+        minX: -8,
+        maxX: 8,
+        minY: 0,
+        maxY: 8,
+        minZ: -8,
+        maxZ: 8,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+    };
+    const thinWallPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([{
+            id: 'adversarial-thin-wall',
+            kind: 'static',
+            x: 1.5,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.1, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    const cornerPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'adversarial-corner-x',
+            kind: 'static',
+            x: 1.5,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.1, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'adversarial-corner-z',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 1.5,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 10, halfY: 3, halfZ: 0.1 },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+    const thinWall = stepDeterministicKcc3D({ ...base, x: -2, z: 0 }, { moveX: 6, moveZ: 0 }, world, { frame: 0, physics: thinWallPhysics });
+    const diagonalThinWall = stepDeterministicKcc3D({ ...base, x: -2, z: -2 }, { moveX: 6, moveZ: 6 }, world, { frame: 1, physics: thinWallPhysics });
+    const ledge = stepDeterministicKcc3D({ ...base, z: -7 }, { moveX: 0, moveZ: -3 }, world, { frame: 2 });
+    const ceiling = stepDeterministicKcc3D({ ...base, y: 10 }, { moveX: 0, moveZ: 0, jumpPressed: true }, world, { frame: 3 });
+    const corner = stepDeterministicKcc3D({ ...base, x: -2, z: -2 }, { moveX: 6, moveZ: 6 }, world, { frame: 4, physics: cornerPhysics });
+    const platformEdge = stepDeterministicKcc3D({ ...base, x: 3.9, y: 3, platformId: 'adversarial-platform' }, { moveX: 0, moveZ: 0 }, {
+        ...world,
+        movingPlatforms: [{
+                id: 'adversarial-platform',
+                minX: -2,
+                maxX: 4,
+                minZ: -2,
+                maxZ: 2,
+                y: 3,
+                dxPerFrame: 1,
+                dzPerFrame: 0,
+            }],
+    }, { frame: 5 });
+    const slopeLimit = stepDeterministicKcc3D({ ...base, x: 0 }, { moveX: 1, moveZ: 0 }, {
+        ...world,
+        slopes: [{ id: 'adversarial-steep-slope', minX: 1, maxX: 2, minZ: -1, maxZ: 1, baseY: 0, risePerUnitX: 3 }],
+    }, { frame: 6 });
+    const result = {
+        thinWallSweeps: Number(thinWall.events.includes('physics-sweep')) * Number(thinWall.body.x < 1.5),
+        diagonalThinWallSweeps: Number(diagonalThinWall.events.includes('physics-sweep')) * Number(diagonalThinWall.body.x < 1.5),
+        ledgeCorrections: Number(ledge.events.includes('ledge')) * Number(ledge.body.z === world.minZ),
+        ceilingBlocks: Number(ceiling.events.includes('ceiling')) * Number(ceiling.body.y === world.maxY) * Number(ceiling.body.vy === 0),
+        cornerSweeps: Number(corner.events.includes('physics-sweep')) * Number(corner.body.x <= 0) * Number(corner.body.z <= 0),
+        movingPlatformEdgeTransfers: Number(platformEdge.events.includes('platform-velocity-transfer')) * Number(platformEdge.body.vx === 1),
+        slopeLimitRejections: Number(!slopeLimit.events.includes('slope')) * Number(slopeLimit.body.y === 0),
+    };
+    return {
+        ...result,
+        checksum: (0, canonical_js_1.defaultChecksum)({
+            cases: {
+                thinWall,
+                diagonalThinWall,
+                ledge,
+                ceiling,
+                corner,
+                platformEdge,
+                slopeLimit,
+            },
+            result,
+        }),
+    };
+}
+function runDeterministicKcc3DGeometryFixture() {
+    const first = runKcc3DGeometryCases();
+    const second = runKcc3DGeometryCases();
+    return {
+        ...first,
+        restoredChecksum: second.checksum,
+        rollbackEquivalent: first.checksum === second.checksum,
+    };
+}
+function runKcc3DGeometryCases() {
+    const base = {
+        x: 0,
+        y: 0,
+        z: 0,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+    };
+    const world = {
+        minX: -8,
+        maxX: 8,
+        minY: 0,
+        maxY: 8,
+        minZ: -8,
+        maxZ: 8,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+    };
+    const narrowGapPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([
+        {
+            id: 'gap-left',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: -1.2,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 4, halfY: 3, halfZ: 0.1 },
+            layer: 1,
+            mask: 1,
+        },
+        {
+            id: 'gap-right',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 1.2,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 4, halfY: 3, halfZ: 0.1 },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+    const defaultWallPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([{
+            id: 'default-wall',
+            kind: 'static',
+            x: 1,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.5, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    const skinWallPhysics = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)([{
+            id: 'skin-wall',
+            kind: 'static',
+            x: 0.8,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.1, halfY: 3, halfZ: 10 },
+            layer: 1,
+            mask: 1,
+        }]);
+    const defaultSlide = stepDeterministicKcc3D({ ...base, x: -1 }, { moveX: 1, moveZ: 1 }, world, { frame: 0, physics: defaultWallPhysics });
+    const smallRadius = stepDeterministicKcc3D({ ...base, x: -2, radius: 0.45, halfHeight: 2, skinWidth: 0 }, { moveX: 4, moveZ: 0 }, world, { frame: 1, physics: narrowGapPhysics });
+    const largeRadius = stepDeterministicKcc3D({ ...base, x: -2, radius: 1.4, halfHeight: 2, skinWidth: 0 }, { moveX: 4, moveZ: 0 }, world, { frame: 2, physics: narrowGapPhysics });
+    const tallStep = stepDeterministicKcc3D({ ...base, x: 0, halfHeight: 2.2, radius: 1, skinWidth: 0 }, { moveX: 1, moveZ: 0 }, { ...world, steps: [{ id: 'low-ceiling-step', minX: 1, maxX: 2, minZ: -1, maxZ: 1, height: 2, ceilingY: 6 }] }, { frame: 3 });
+    const shortStep = stepDeterministicKcc3D({ ...base, x: 0, halfHeight: 1.5, radius: 1, skinWidth: 0 }, { moveX: 1, moveZ: 0 }, { ...world, steps: [{ id: 'low-ceiling-step', minX: 1, maxX: 2, minZ: -1, maxZ: 1, height: 2, ceilingY: 6 }] }, { frame: 4 });
+    const noSkin = stepDeterministicKcc3D({ ...base, x: -0.2, radius: 0.4, halfHeight: 2, skinWidth: 0 }, { moveX: 0.5, moveZ: 0 }, world, { frame: 5, physics: skinWallPhysics });
+    const withSkin = stepDeterministicKcc3D({ ...base, x: -0.2, radius: 0.4, halfHeight: 2, skinWidth: 0.5 }, { moveX: 0.5, moveZ: 0 }, world, { frame: 6, physics: skinWallPhysics });
+    const checksum = (0, canonical_js_1.defaultChecksum)({
+        defaultSlide,
+        smallRadius,
+        largeRadius,
+        tallStep,
+        shortStep,
+        noSkin,
+        withSkin,
+        geometries: [
+            normalizeKccGeometry3D({ ...base }),
+            normalizeKccGeometry3D({ ...base, radius: 0.45, halfHeight: 2, skinWidth: 0 }),
+            normalizeKccGeometry3D({ ...base, radius: 1.4, halfHeight: 2, skinWidth: 0 }),
+            normalizeKccGeometry3D({ ...base, radius: 0.4, halfHeight: 2, skinWidth: 0.5 }),
+        ],
+    });
+    return {
+        checksum,
+        defaultGeometryPreserved: defaultSlide.events.includes('physics-slide') && defaultSlide.body.x === -1 && defaultSlide.body.z === 1,
+        smallRadiusPassesNarrowGap: smallRadius.events.includes('physics-sweep') === false && smallRadius.body.x === 2,
+        largeRadiusBlockedByNarrowGap: largeRadius.events.some((event) => event.startsWith('physics-')) && largeRadius.body.x < 0,
+        tallBodyHeadBlocked: tallStep.events.includes('step-head-blocked') && tallStep.body.x === 0,
+        shortBodyClearsLowCeiling: shortStep.events.includes('step') && shortStep.body.y === 2,
+        skinWidthExpandsCollisionShape: noSkin.events.includes('physics-sweep') === false
+            && withSkin.events.some((event) => event.startsWith('physics-'))
+            && withSkin.body.x <= noSkin.body.x,
+        geometryMetadataStable: normalizeKccGeometry3D({ ...base }).radius === 1
+            && normalizeKccGeometry3D({ ...base }).halfHeight === 2
+            && normalizeKccGeometry3D({ ...base }).skinWidth === 0
+            && normalizeKccGeometry3D({ ...base, radius: 0.4, halfHeight: 2, skinWidth: 0.5 }).radius === 0.4
+            && normalizeKccGeometry3D({ ...base, radius: 0.4, halfHeight: 2, skinWidth: 0.5 }).halfHeight === 2
+            && normalizeKccGeometry3D({ ...base, radius: 0.4, halfHeight: 2, skinWidth: 0.5 }).skinWidth === 0.5,
+    };
+}
+function fastStressKcc3D(body, input, world) {
+    const x = clamp(body.x + input.moveX, world.minX, world.maxX);
+    const z = clamp(body.z + input.moveZ, world.minZ, world.maxZ);
+    const vy = body.grounded ? 0 : body.vy - 1;
+    const y = clamp(body.y + vy, world.minY, world.maxY);
+    const grounded = y === world.minY;
+    return {
+        x,
+        y,
+        z,
+        vx: input.moveX,
+        vy: grounded ? 0 : vy,
+        vz: input.moveZ,
+        grounded,
+        coyoteFrames: grounded ? 4 : Math.max(0, body.coyoteFrames - 1),
+        jumpBufferFrames: input.jumpPressed === true ? 4 : Math.max(0, body.jumpBufferFrames - 1),
+        platformId: grounded ? undefined : body.platformId,
+    };
+}
+function createKccObstacleBodies(players) {
+    const rows = Math.max(1, Math.ceil(players / 16));
+    const bodies = [];
+    for (let row = 0; row < rows; row += 1) {
+        for (const x of [3, 7, 11, 15]) {
+            bodies.push({
+                id: `kcc-obstacle-${row}-${x}`,
+                kind: 'static',
+                x,
+                y: 0,
+                z: row,
+                vx: 0,
+                vy: 0,
+                vz: 0,
+                shape: { type: 'box', halfX: 1, halfY: 3, halfZ: 1 },
+                layer: 1,
+                mask: 1,
+            });
+        }
+    }
+    return bodies;
+}
+function hasKccPlatformEvent(events) {
+    return events.some((event) => /^(moving-platform|platform)/.test(event));
+}
+function countKccEventsWithPrefix(events, prefix) {
+    let count = 0;
+    for (const event of events) {
+        count += Number(event.startsWith(prefix));
+    }
+    return count;
+}
+function countKccEventsEqualTo(events, value) {
+    let count = 0;
+    for (const event of events) {
+        count += Number(event === value);
+    }
+    return count;
+}
+function applyProcessors(body, input, frame, processors) {
+    const ids = new Set();
+    let next = body;
+    for (const processor of [...processors].sort((left, right) => left.order - right.order || compareStrings(left.id, right.id))) {
+        if (ids.has(processor.id)) {
+            throw new Error(`Duplicate deterministic KCC processor ${processor.id}`);
+        }
+        ids.add(processor.id);
+        const stateBefore = deterministicKccProcessorStateChecksum(processor);
+        next = processor.process(next, input, frame);
+        const stateAfter = deterministicKccProcessorStateChecksum(processor);
+        if (stateBefore !== stateAfter) {
+            throw new Error(`Nondeterministic KCC processor state mutation ${processor.id}`);
+        }
+    }
+    return next;
+}
+function combineExternalKccImpulses(impulses) {
+    const ids = new Set();
+    let vx = 0;
+    let vy = 0;
+    let vz = 0;
+    for (const impulse of [...impulses].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (ids.has(impulse.id)) {
+            throw new Error(`Duplicate deterministic KCC external impulse ${impulse.id}`);
+        }
+        ids.add(impulse.id);
+        if (!Number.isInteger(impulse.vx) || !Number.isInteger(impulse.vy) || !Number.isInteger(impulse.vz)) {
+            throw new Error(`Deterministic KCC external impulse ${impulse.id} must use integer velocity deltas`);
+        }
+        vx += impulse.vx;
+        vy += impulse.vy;
+        vz += impulse.vz;
+    }
+    return { vx, vy, vz, applied: impulses.length > 0 };
+}
+function deterministicKccProcessorStateChecksum(processor) {
+    const record = processor;
+    const entries = stableKeys(record)
+        .filter((key) => key !== 'id' && key !== 'order' && key !== 'process')
+        .map((key) => {
+        const value = record[key];
+        if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return { key, value };
+        }
+        throw new Error(`Nondeterministic KCC processor state ${processor.id}`);
+    });
+    return (0, canonical_js_1.defaultChecksum)(entries);
+}
+function sortKccCollisionFilters(filters) {
+    const ids = new Set();
+    const ordered = [...filters].sort((left, right) => left.order - right.order || compareStrings(left.id, right.id));
+    for (const filter of ordered) {
+        if (ids.has(filter.id)) {
+            throw new Error(`Duplicate deterministic KCC collision filter ${filter.id}`);
+        }
+        ids.add(filter.id);
+    }
+    return ordered;
+}
+function deterministicKccCollisionFiltersStateChecksum(filters) {
+    return (0, canonical_js_1.defaultChecksum)(sortKccCollisionFilters(filters).map((filter) => deterministicKccCollisionFilterStateChecksum(filter)));
+}
+function deterministicKccCollisionFilterStateChecksum(filter) {
+    const record = filter;
+    const entries = stableKeys(record)
+        .filter((key) => key !== 'id' && key !== 'order' && key !== 'shouldCollide')
+        .map((key) => {
+        const value = record[key];
+        if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return { key, value };
+        }
+        throw new Error(`Nondeterministic KCC collision filter state ${filter.id}`);
+    });
+    return (0, canonical_js_1.defaultChecksum)(entries);
+}
+function assertKccCollisionFiltersUnchanged(filters, stateBefore) {
+    const stateAfter = deterministicKccCollisionFiltersStateChecksum(filters);
+    if (stateBefore !== stateAfter) {
+        throw new Error('Nondeterministic KCC collision filter state mutation');
+    }
+}
+function createKccCollisionCandidate(bodyId, body, context, attemptedX, attemptedY, attemptedZ) {
+    const normal = estimateKccCollisionNormal(context.previous, attemptedX, attemptedY, attemptedZ);
+    return {
+        bodyId,
+        frame: context.frame,
+        sample: context.sample,
+        attemptedX,
+        attemptedY,
+        attemptedZ,
+        previousX: context.previous.x,
+        previousY: context.previous.y,
+        previousZ: context.previous.z,
+        normalX: normal.x,
+        normalY: normal.y,
+        normalZ: normal.z,
+        layer: body.layer,
+        mask: body.mask,
+        swept: context.swept,
+    };
+}
+function estimateKccCollisionNormal(previous, attemptedX, attemptedY, attemptedZ) {
+    const dx = attemptedX - previous.x;
+    const dy = attemptedY - previous.y;
+    const dz = attemptedZ - previous.z;
+    const absX = Math.abs(dx);
+    const absY = Math.abs(dy);
+    const absZ = Math.abs(dz);
+    if (absX >= absZ && absX > 0) {
+        return { x: dx >= 0 ? -1 : 1, y: 0, z: 0 };
+    }
+    if (absZ > 0) {
+        return { x: 0, y: 0, z: dz >= 0 ? -1 : 1 };
+    }
+    if (absY > 0) {
+        return { x: 0, y: dy >= 0 ? -1 : 1, z: 0 };
+    }
+    return { x: 0, y: 0, z: -1 };
+}
+function resolvePhysicsSlide3D(physics, previous, candidate, ignoredBodyIds, frame, collisionFilters) {
+    const filterStateBefore = deterministicKccCollisionFiltersStateChecksum(collisionFilters);
+    let collisionFilterCalls = 0;
+    let collisionFilterRejectedHits = 0;
+    const fullOverlaps = physicsOverlapsKcc(physics, candidate.x, candidate.y, candidate.z, {
+        ignoredBodyIds,
+        previous,
+        frame,
+        swept: false,
+        sample: 0,
+        collisionFilters,
+    });
+    collisionFilterCalls += fullOverlaps.collisionFilterCalls;
+    collisionFilterRejectedHits += fullOverlaps.collisionFilterRejectedHits;
+    if (fullOverlaps.length === 0) {
+        const sweep = sweepPhysicsKcc3D(physics, previous, candidate, ignoredBodyIds, frame, collisionFilters);
+        assertKccCollisionFiltersUnchanged(collisionFilters, filterStateBefore);
+        if (sweep.corrected) {
+            return {
+                ...sweep,
+                collisionFilterCalls: collisionFilterCalls + sweep.collisionFilterCalls,
+                collisionFilterRejectedHits: collisionFilterRejectedHits + sweep.collisionFilterRejectedHits,
+            };
+        }
+        return {
+            ...candidate,
+            corrected: false,
+            slid: false,
+            swept: false,
+            correctionCount: 0,
+            queryCount: sweep.queryCount + 1,
+            collisionFilterCalls: collisionFilterCalls + sweep.collisionFilterCalls,
+            collisionFilterRejectedHits: collisionFilterRejectedHits + sweep.collisionFilterRejectedHits,
+        };
+    }
+    const xOnly = { x: candidate.x, z: previous.z, vx: candidate.vx, vz: 0 };
+    const zOnly = { x: previous.x, z: candidate.z, vx: 0, vz: candidate.vz };
+    const xOverlaps = physicsOverlapsKcc(physics, xOnly.x, candidate.y, xOnly.z, {
+        ignoredBodyIds,
+        previous,
+        frame,
+        swept: false,
+        sample: 0,
+        collisionFilters,
+    });
+    const zOverlaps = physicsOverlapsKcc(physics, zOnly.x, candidate.y, zOnly.z, {
+        ignoredBodyIds,
+        previous,
+        frame,
+        swept: false,
+        sample: 0,
+        collisionFilters,
+    });
+    collisionFilterCalls += xOverlaps.collisionFilterCalls + zOverlaps.collisionFilterCalls;
+    collisionFilterRejectedHits += xOverlaps.collisionFilterRejectedHits + zOverlaps.collisionFilterRejectedHits;
+    assertKccCollisionFiltersUnchanged(collisionFilters, filterStateBefore);
+    if (xOverlaps.length === 0 && zOverlaps.length > 0) {
+        return { ...xOnly, corrected: true, slid: true, swept: false, correctionCount: fullOverlaps.length, queryCount: 3, collisionFilterCalls, collisionFilterRejectedHits };
+    }
+    if (zOverlaps.length === 0 && xOverlaps.length > 0) {
+        return { ...zOnly, corrected: true, slid: true, swept: false, correctionCount: fullOverlaps.length, queryCount: 3, collisionFilterCalls, collisionFilterRejectedHits };
+    }
+    if (xOverlaps.length === 0 && zOverlaps.length === 0) {
+        const preferX = Math.abs(candidate.vx) >= Math.abs(candidate.vz);
+        return {
+            ...(preferX ? xOnly : zOnly),
+            corrected: true,
+            slid: true,
+            swept: false,
+            correctionCount: fullOverlaps.length,
+            queryCount: 3,
+            collisionFilterCalls,
+            collisionFilterRejectedHits,
+        };
+    }
+    return {
+        x: previous.x,
+        z: previous.z,
+        vx: 0,
+        vz: 0,
+        corrected: true,
+        slid: false,
+        swept: false,
+        correctionCount: fullOverlaps.length,
+        queryCount: 3,
+        collisionFilterCalls,
+        collisionFilterRejectedHits,
+    };
+}
+function sweepPhysicsKcc3D(physics, previous, candidate, ignoredBodyIds, frame, collisionFilters) {
+    const deltaX = candidate.x - previous.x;
+    const deltaZ = candidate.z - previous.z;
+    const samples = Math.max(1, Math.ceil(Math.max(Math.abs(deltaX), Math.abs(deltaZ)) * 2));
+    const filterStateBefore = deterministicKccCollisionFiltersStateChecksum(collisionFilters);
+    let queryCount = 0;
+    let collisionFilterCalls = 0;
+    let collisionFilterRejectedHits = 0;
+    let lastSafeX = previous.x;
+    let lastSafeZ = previous.z;
+    for (let sample = 1; sample <= samples; sample += 1) {
+        const fraction = sample / samples;
+        const sampleX = previous.x + deltaX * fraction;
+        const sampleZ = previous.z + deltaZ * fraction;
+        const overlaps = physicsOverlapsKcc(physics, sampleX, candidate.y, sampleZ, {
+            ignoredBodyIds,
+            previous,
+            frame,
+            swept: true,
+            sample,
+            collisionFilters,
+        });
+        queryCount += 1;
+        collisionFilterCalls += overlaps.collisionFilterCalls;
+        collisionFilterRejectedHits += overlaps.collisionFilterRejectedHits;
+        if (overlaps.length > 0) {
+            const xOnlyOverlaps = physicsOverlapsKcc(physics, sampleX, candidate.y, lastSafeZ, {
+                ignoredBodyIds,
+                previous,
+                frame,
+                swept: true,
+                sample,
+                collisionFilters,
+            });
+            const zOnlyOverlaps = physicsOverlapsKcc(physics, lastSafeX, candidate.y, sampleZ, {
+                ignoredBodyIds,
+                previous,
+                frame,
+                swept: true,
+                sample,
+                collisionFilters,
+            });
+            queryCount += 2;
+            collisionFilterCalls += xOnlyOverlaps.collisionFilterCalls + zOnlyOverlaps.collisionFilterCalls;
+            collisionFilterRejectedHits += xOnlyOverlaps.collisionFilterRejectedHits + zOnlyOverlaps.collisionFilterRejectedHits;
+            assertKccCollisionFiltersUnchanged(collisionFilters, filterStateBefore);
+            if (xOnlyOverlaps.length === 0 && zOnlyOverlaps.length > 0) {
+                return {
+                    x: sampleX,
+                    z: lastSafeZ,
+                    vx: candidate.vx,
+                    vz: 0,
+                    corrected: true,
+                    slid: true,
+                    swept: true,
+                    correctionCount: overlaps.length,
+                    queryCount,
+                    collisionFilterCalls,
+                    collisionFilterRejectedHits,
+                };
+            }
+            if (zOnlyOverlaps.length === 0 && xOnlyOverlaps.length > 0) {
+                return {
+                    x: lastSafeX,
+                    z: sampleZ,
+                    vx: 0,
+                    vz: candidate.vz,
+                    corrected: true,
+                    slid: true,
+                    swept: true,
+                    correctionCount: overlaps.length,
+                    queryCount,
+                    collisionFilterCalls,
+                    collisionFilterRejectedHits,
+                };
+            }
+            return {
+                x: lastSafeX,
+                z: lastSafeZ,
+                vx: 0,
+                vz: 0,
+                corrected: true,
+                slid: false,
+                swept: true,
+                correctionCount: overlaps.length,
+                queryCount,
+                collisionFilterCalls,
+                collisionFilterRejectedHits,
+            };
+        }
+        lastSafeX = sampleX;
+        lastSafeZ = sampleZ;
+    }
+    assertKccCollisionFiltersUnchanged(collisionFilters, filterStateBefore);
+    return { ...candidate, corrected: false, slid: false, swept: false, correctionCount: 0, queryCount, collisionFilterCalls, collisionFilterRejectedHits };
+}
+function physicsOverlapsKcc(physics, x, y, z, context) {
+    const geometry = normalizeKccGeometry3D(context.previous);
+    const query = {
+        shape: {
+            type: 'capsule',
+            radius: geometry.radius + geometry.skinWidth,
+            halfHeight: geometry.halfHeight + geometry.skinWidth,
+        },
+        x,
+        y,
+        z,
+        layerMask: 0b1111,
+        includeTriggers: false,
+        includeSensors: false,
+    };
+    let collisionFilterCalls = 0;
+    let collisionFilterRejectedHits = 0;
+    const filters = sortKccCollisionFilters(context.collisionFilters);
+    const overlaps = (0, physics3d_js_1.overlapDeterministicPhysics3D)(physics, query).filter((bodyId) => {
+        if (context.ignoredBodyIds.has(bodyId)) {
+            return false;
+        }
+        const body = physics.bodies.find((candidate) => candidate.id === bodyId);
+        const hit = createKccCollisionCandidate(bodyId, body, context, x, y, z);
+        for (const filter of filters) {
+            collisionFilterCalls += 1;
+            if (!filter.shouldCollide(hit)) {
+                collisionFilterRejectedHits += 1;
+                return false;
+            }
+        }
+        return true;
+    });
+    return Object.assign(overlaps, { collisionFilterCalls, collisionFilterRejectedHits });
+}
+function normalizeKccGeometry3D(body) {
+    const radius = body.radius ?? 1;
+    const halfHeight = body.halfHeight ?? 2;
+    const skinWidth = body.skinWidth ?? 0;
+    if (!Number.isFinite(radius) || radius <= 0) {
+        throw new Error('KCC radius must be a finite positive number');
+    }
+    if (!Number.isFinite(halfHeight) || halfHeight <= 0) {
+        throw new Error('KCC halfHeight must be a finite positive number');
+    }
+    if (!Number.isFinite(skinWidth) || skinWidth < 0) {
+        throw new Error('KCC skinWidth must be a finite non-negative number');
+    }
+    return { radius, halfHeight, skinWidth };
+}
+function clampBodyToBounds(body, world) {
+    const events = [];
+    let corrections = 0;
+    let { x, y, z, vx, vy, vz, grounded } = body;
+    if (x < world.minX || x > world.maxX) {
+        x = clamp(x, world.minX, world.maxX);
+        vx = 0;
+        corrections += 1;
+        events.push('wall-slide');
+    }
+    if (z < world.minZ || z > world.maxZ) {
+        z = clamp(z, world.minZ, world.maxZ);
+        vz = 0;
+        corrections += 1;
+        events.push('ledge');
+    }
+    if (y <= world.minY) {
+        y = world.minY;
+        vy = 0;
+        grounded = true;
+    }
+    if (y > world.maxY) {
+        y = world.maxY;
+        vy = 0;
+        corrections += 1;
+        events.push('ceiling');
+    }
+    return { body: { ...body, x, y, z, vx, vy, vz, grounded }, corrected: corrections > 0, corrections, events };
+}
+function slopeHeightAt(slopes, x, z, maxSlopeRisePerUnit) {
+    for (const slope of [...slopes].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (x >= slope.minX && x <= slope.maxX && z >= slope.minZ && z <= slope.maxZ) {
+            const risePerUnitZ = slope.risePerUnitZ ?? 0;
+            if (Math.max(Math.abs(slope.risePerUnitX), Math.abs(risePerUnitZ)) > maxSlopeRisePerUnit) {
+                continue;
+            }
+            return slope.baseY + ((x - slope.minX) * slope.risePerUnitX) + ((z - slope.minZ) * risePerUnitZ);
+        }
+    }
+    return undefined;
+}
+function findStepAt(steps, x, z) {
+    return [...steps]
+        .sort((left, right) => compareStrings(left.id, right.id))
+        .find((step) => x >= step.minX && x <= step.maxX && z >= step.minZ && z <= step.maxZ);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+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 stableKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}