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

package/dist/cjs/lag-compensation3d.js

@@ -0,0 +1,837 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDeterministicLagCompensation3DFixture = runDeterministicLagCompensation3DFixture;
+exports.createDeterministicLagCompensation3DHistory = createDeterministicLagCompensation3DHistory;
+exports.rewindDeterministicLagCompensatedTargets3D = rewindDeterministicLagCompensatedTargets3D;
+exports.buildDeterministicLagCompensatedHitboxProxies3D = buildDeterministicLagCompensatedHitboxProxies3D;
+exports.validateDeterministicLagCompensatedShot3D = validateDeterministicLagCompensatedShot3D;
+exports.validateDeterministicAuthoritativeLagCompensatedShot3D = validateDeterministicAuthoritativeLagCompensatedShot3D;
+exports.runDeterministicLagCompensation3DApiFixture = runDeterministicLagCompensation3DApiFixture;
+exports.runDeterministicAuthoritativeLagCompensation3DFixture = runDeterministicAuthoritativeLagCompensation3DFixture;
+const canonical_js_1 = require("./canonical.js");
+const physics3d_js_1 = require("./physics3d.js");
+function runDeterministicLagCompensation3DFixture(players = 128, frames = 512, seed = 71) {
+    const primary = simulateLagCompensation3D(players, frames, seed);
+    const restored = simulateLagCompensation3D(players, frames, seed);
+    return {
+        ...primary,
+        restoredChecksum: restored.checksum,
+        rollbackEquivalent: primary.checksum === restored.checksum,
+    };
+}
+function createDeterministicLagCompensation3DHistory(options = {}) {
+    const maxStoredFrames = options.maxStoredFrames ?? 128;
+    if (!Number.isInteger(maxStoredFrames) || maxStoredFrames <= 0) {
+        throw new Error('Deterministic lag compensation history maxStoredFrames must be a positive integer');
+    }
+    let targets = [];
+    let occluders = normalizePhysicsBodies(options.occluders ?? []);
+    const prune = () => {
+        if (targets.length === 0) {
+            return;
+        }
+        const newestFrame = targets.reduce((max, target) => Math.max(max, target.frame), 0);
+        const oldestFrame = newestFrame - maxStoredFrames + 1;
+        targets = targets.filter((target) => target.frame >= oldestFrame).sort(compareLagCompensatedTarget3DByFrame);
+    };
+    return {
+        maxStoredFrames,
+        get frameCount() {
+            return new Set(targets.map((target) => target.frame)).size;
+        },
+        get targetCount() {
+            return targets.length;
+        },
+        recordTargets(frameTargets) {
+            const normalized = normalizeLagCompensatedTargets3D(frameTargets);
+            const duplicateKeys = new Set(targets.map((target) => lagCompensatedTargetKey(target)));
+            for (const target of normalized) {
+                const key = lagCompensatedTargetKey(target);
+                if (duplicateKeys.has(key)) {
+                    throw new Error(`Duplicate deterministic lag compensation target ${key}`);
+                }
+                duplicateKeys.add(key);
+            }
+            targets = [...targets, ...normalized].sort(compareLagCompensatedTarget3DByFrame);
+            prune();
+        },
+        rewind(frame, shooterSlot) {
+            assertLagCompensationFrame(frame);
+            const rewoundTargets = rewindDeterministicLagCompensatedTargets3D(targets, frame);
+            const proxies = buildDeterministicLagCompensatedHitboxProxies3D(targets, frame, shooterSlot);
+            const withoutChecksum = {
+                frame,
+                targets: rewoundTargets,
+                proxies,
+                interpolatedTargets: rewoundTargets.filter(isInterpolatedLagCompensatedTarget3D).length,
+            };
+            return {
+                ...withoutChecksum,
+                checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+            };
+        },
+        validateShot(shot) {
+            return validateDeterministicLagCompensatedShot3D(targets, occluders, shot);
+        },
+        snapshot() {
+            const withoutChecksum = {
+                maxStoredFrames,
+                targets: normalizeLagCompensatedTargets3D(targets),
+                occluders,
+            };
+            return {
+                ...withoutChecksum,
+                checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+            };
+        },
+        restore(snapshot) {
+            const expected = (0, canonical_js_1.defaultChecksum)({
+                maxStoredFrames: snapshot.maxStoredFrames,
+                targets: normalizeLagCompensatedTargets3D(snapshot.targets),
+                occluders: normalizePhysicsBodies(snapshot.occluders),
+            });
+            if (snapshot.maxStoredFrames !== maxStoredFrames || snapshot.checksum !== expected) {
+                throw new Error('Deterministic lag compensation history snapshot checksum mismatch');
+            }
+            targets = [...normalizeLagCompensatedTargets3D(snapshot.targets)];
+            occluders = normalizePhysicsBodies(snapshot.occluders);
+        },
+        checksum() {
+            return (0, canonical_js_1.defaultChecksum)({ maxStoredFrames, targets: normalizeLagCompensatedTargets3D(targets), occluders });
+        },
+    };
+}
+function rewindDeterministicLagCompensatedTargets3D(history, rewindFrame) {
+    assertLagCompensationFrame(rewindFrame);
+    return interpolateLagCompensatedTargets3D(normalizeLagCompensatedTargets3D(history), rewindFrame);
+}
+function buildDeterministicLagCompensatedHitboxProxies3D(history, rewindFrame, shooterSlot) {
+    assertLagCompensationFrame(rewindFrame);
+    return buildHitboxProxies(normalizeLagCompensatedTargets3D(history), rewindFrame, shooterSlot);
+}
+function validateDeterministicLagCompensatedShot3D(history, occluders, shot) {
+    return validateLagCompensatedShot3D(normalizeLagCompensatedTargets3D(history), normalizePhysicsBodies(occluders), shot);
+}
+function validateDeterministicAuthoritativeLagCompensatedShot3D(history, occluders, shot, context) {
+    if (!Number.isInteger(context.acceptedShotFrame)
+        || !Number.isInteger(context.serverReceiveFrame)
+        || !Number.isInteger(context.maxHistoryFrames)
+        || !Number.isInteger(context.maxLatencyFrames)
+        || context.acceptedShotFrame < 0
+        || context.serverReceiveFrame < context.acceptedShotFrame
+        || context.maxHistoryFrames <= 0
+        || context.maxLatencyFrames < 0) {
+        return shotResult(shot, 'invalid-shot', shot.shotFrame - shot.latencyFrames, '', '', 0, 0, 0);
+    }
+    const derivedLatencyFrames = context.serverReceiveFrame - context.acceptedShotFrame;
+    if (derivedLatencyFrames > context.maxLatencyFrames
+        || shot.shotFrame !== context.serverReceiveFrame
+        || shot.latencyFrames !== derivedLatencyFrames
+        || shot.maxHistoryFrames !== context.maxHistoryFrames) {
+        return shotResult(shot, 'invalid-shot', context.acceptedShotFrame, '', '', 0, 0, 0);
+    }
+    return validateDeterministicLagCompensatedShot3D(history, occluders, {
+        ...shot,
+        shotFrame: context.serverReceiveFrame,
+        latencyFrames: derivedLatencyFrames,
+        maxHistoryFrames: context.maxHistoryFrames,
+    });
+}
+function runDeterministicLagCompensation3DApiFixture() {
+    const history = createDeterministicLagCompensation3DHistory({ maxStoredFrames: 4 });
+    const frameTargets = [
+        [
+            targetSnapshot(0, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(0, 'slot-1', 10, 1, 0, 'standing'),
+        ],
+        [
+            targetSnapshot(1, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(1, 'slot-1', 12, 1, 0, 'standing'),
+        ],
+        [
+            targetSnapshot(2, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(2, 'slot-1', 14, 1, 0, 'crouching'),
+        ],
+        [
+            targetSnapshot(3, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(3, 'slot-1', 16, 1, 0, 'crouching'),
+        ],
+    ];
+    for (const targetsAtFrame of frameTargets) {
+        history.recordTargets(targetsAtFrame);
+    }
+    const exactRewind = history.rewind(2, 0);
+    const sparseHistory = createDeterministicLagCompensation3DHistory({ maxStoredFrames: 8 });
+    sparseHistory.recordTargets(frameTargets[0]);
+    sparseHistory.recordTargets(frameTargets[2]);
+    const interpolatedRewind = sparseHistory.rewind(1, 0);
+    const hitShot = shotAtTarget('api-hit', 0, 3, 1, 10, 1.45, 0);
+    const hit = history.validateShot(hitShot);
+    const generatedZeroDirectionRejectionReason = captureGeneratedZeroDirectionRejectionReason();
+    const occluded = validateDeterministicLagCompensatedShot3D(history.snapshot().targets, [{
+            id: 'occluder.api-wall',
+            kind: 'static',
+            x: 8,
+            y: 1.4,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.25, halfY: 2, halfZ: 2 },
+            layer: 2,
+            mask: 3,
+        }], hitShot);
+    const stale = history.validateShot({ ...hitShot, id: 'api-stale', latencyFrames: 8, maxHistoryFrames: 2 });
+    const future = history.validateShot({ ...hitShot, id: 'api-future', latencyFrames: -1 });
+    const snapshot = history.snapshot();
+    const restored = createDeterministicLagCompensation3DHistory({ maxStoredFrames: 4 });
+    restored.restore(snapshot);
+    history.recordTargets([
+        targetSnapshot(4, 'slot-0', 0, 1, 0, 'standing'),
+        targetSnapshot(4, 'slot-1', 18, 1, 0, 'standing'),
+    ]);
+    const withoutChecksum = {
+        exactRewindTargets: exactRewind.targets.length,
+        interpolatedRewindTargets: interpolatedRewind.interpolatedTargets,
+        hit,
+        occluded,
+        stale,
+        future,
+        generatedZeroDirectionRejectionReason,
+        restoredChecksum: restored.checksum(),
+        snapshotChecksum: snapshot.checksum,
+        prunedFrameCount: history.frameCount,
+    };
+    return {
+        checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+        restoredChecksum: restored.checksum(),
+        rollbackEquivalent: restored.checksum() === snapshot.checksum,
+        generatedZeroDirectionRejectionReason,
+        exactRewindTargets: exactRewind.targets.length,
+        interpolatedRewindTargets: interpolatedRewind.interpolatedTargets,
+        hitReason: hit.reason,
+        occludedReason: occluded.reason,
+        staleReason: stale.reason,
+        futureReason: future.reason,
+        proxiesCreated: hit.proxiesCreated,
+        proxiesDestroyed: hit.proxiesDestroyed,
+        historyFrameCount: history.frameCount,
+        prunedOldFrames: history.frameCount === 4 && history.snapshot().targets.every((target) => target.frame >= 1),
+    };
+}
+function runDeterministicAuthoritativeLagCompensation3DFixture() {
+    const history = createDeterministicLagCompensation3DHistory({ maxStoredFrames: 8 });
+    for (const targetsAtFrame of [
+        [
+            targetSnapshot(0, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(0, 'slot-1', 6, 1, 0, 'standing'),
+        ],
+        [
+            targetSnapshot(1, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(1, 'slot-1', 8, 1, 0, 'standing'),
+        ],
+        [
+            targetSnapshot(2, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(2, 'slot-1', 12, 1, 0, 'standing'),
+        ],
+        [
+            targetSnapshot(3, 'slot-0', 0, 1, 0, 'standing'),
+            targetSnapshot(3, 'slot-1', 16, 1, 0, 'standing'),
+        ],
+    ]) {
+        history.recordTargets(targetsAtFrame);
+    }
+    const context = {
+        acceptedShotFrame: 1,
+        serverReceiveFrame: 3,
+        maxHistoryFrames: 4,
+        maxLatencyFrames: 4,
+    };
+    const shot = { ...shotAtTarget('authority-hit', 0, 3, 2, 8, 1.45, 0), maxHistoryFrames: 4 };
+    const authorityHit = validateDeterministicAuthoritativeLagCompensatedShot3D(history.snapshot().targets, [], shot, context);
+    const forgedLatency = validateDeterministicAuthoritativeLagCompensatedShot3D(history.snapshot().targets, [], {
+        ...shot,
+        id: 'forged-latency',
+        latencyFrames: 1,
+    }, context);
+    const forgedShotFrame = validateDeterministicAuthoritativeLagCompensatedShot3D(history.snapshot().targets, [], {
+        ...shot,
+        id: 'forged-shot-frame',
+        shotFrame: 2,
+    }, context);
+    const forgedHistory = validateDeterministicAuthoritativeLagCompensatedShot3D(history.snapshot().targets, [], {
+        ...shot,
+        id: 'forged-history',
+        maxHistoryFrames: 99,
+    }, context);
+    const rawForged = validateDeterministicLagCompensatedShot3D(history.snapshot().targets, [], {
+        ...shot,
+        id: 'raw-forged-latency',
+        latencyFrames: 1,
+    });
+    const snapshot = history.snapshot();
+    const restored = createDeterministicLagCompensation3DHistory({ maxStoredFrames: 8 });
+    restored.restore(snapshot);
+    const metrics = {
+        authorityHitReason: authorityHit.reason,
+        forgedLatencyReason: forgedLatency.reason,
+        forgedShotFrameReason: forgedShotFrame.reason,
+        forgedHistoryReason: forgedHistory.reason,
+        derivedRewindFrame: authorityHit.rewindFrame,
+        rawForgedRewindFrame: rawForged.rewindFrame,
+        authorityTimingRejected: [forgedLatency, forgedShotFrame, forgedHistory].filter((result) => result.reason === 'invalid-shot').length,
+        replayChecksum: history.checksum(),
+        restoredChecksum: restored.checksum(),
+        rollbackEquivalent: history.checksum() === restored.checksum(),
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function simulateLagCompensation3D(players, frames, seed) {
+    const occlusionShotFrame = Math.max(1, Math.min(Math.max(1, frames - 1), 9));
+    const occlusionRewindFrame = Math.max(0, occlusionShotFrame - 1);
+    const history = [
+        ...buildTargetHistory(players, frames, seed),
+        targetSnapshot(occlusionRewindFrame, 'occlusion-target', 4, 1, 0, 'standing'),
+    ];
+    const occluders = buildStaticOccluders();
+    const shots = [
+        ...buildShotCorpus(players, frames, seed),
+        {
+            id: 'shot-occluded-fixed-wall',
+            shooterSlot: 0,
+            shotFrame: occlusionShotFrame,
+            latencyFrames: occlusionShotFrame - occlusionRewindFrame,
+            x: -4,
+            y: 1.45,
+            z: 0,
+            dx: 1,
+            dy: 0,
+            dz: 0,
+            maxDistance: 16,
+            weapon: 'rifle',
+            pellets: [{ dx: 1, dy: 0, dz: 0 }],
+            maxHistoryFrames: 12,
+        },
+    ];
+    const sparseHistory = history.filter((snapshot) => snapshot.frame % 2 === 0);
+    const interpolationShots = buildInterpolationShotCorpus(seed);
+    const results = [
+        ...shots.map((shot) => validateLagCompensatedShot3D(history, occluders, shot)),
+        ...interpolationShots.map((shot) => validateLagCompensatedShot3D(sparseHistory, occluders, shot)),
+    ];
+    const metrics = {
+        players,
+        frames,
+        shots: shots.length + interpolationShots.length,
+        rifleShots: [...shots, ...interpolationShots].filter((shot) => shot.weapon === 'rifle').length,
+        shotgunShots: [...shots, ...interpolationShots].filter((shot) => shot.weapon === 'shotgun').length,
+        burstShots: [...shots, ...interpolationShots].filter((shot) => shot.weapon === 'burst').length,
+        hits: results.filter((result) => result.reason === 'hit').length,
+        misses: results.filter((result) => result.reason === 'miss').length,
+        occluded: results.filter((result) => result.reason === 'occluded').length,
+        staleRejected: results.filter((result) => result.reason === 'stale-frame').length,
+        futureRejected: results.filter((result) => result.reason === 'future-frame').length,
+        multiHitboxQueries: results.filter((result) => result.proxiesCreated >= 2).length,
+        animatedHitboxSamples: results.filter((result) => result.hitboxId.includes('.head') || result.hitboxId.includes('.chest')).length,
+        interpolatedHitboxSamples: results.filter((result) => result.interpolatedProxies > 0).length,
+        staticOcclusionQueries: results.filter((result) => result.reason === 'occluded' || result.reason === 'hit').length,
+        proxyBodiesCreated: results.reduce((sum, result) => sum + result.proxiesCreated, 0),
+        proxyBodiesDestroyed: results.reduce((sum, result) => sum + result.proxiesDestroyed, 0),
+        proxyLifecycleBalanced: results.every((result) => result.proxiesCreated === result.proxiesDestroyed),
+        perClientShotTimesCovered: new Set([...shots, ...interpolationShots].map((shot) => shot.latencyFrames)).size >= 4,
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)({ metrics, results }),
+    };
+}
+function validateLagCompensatedShot3D(history, occluders, shot) {
+    if (!Number.isInteger(shot.shotFrame)
+        || !Number.isInteger(shot.latencyFrames)
+        || !Number.isFinite(shot.x)
+        || !Number.isFinite(shot.y)
+        || !Number.isFinite(shot.z)
+        || !Number.isFinite(shot.dx)
+        || !Number.isFinite(shot.dy)
+        || !Number.isFinite(shot.dz)
+        || !Number.isFinite(shot.maxDistance)
+        || shot.maxDistance <= 0
+        || shot.pellets.length === 0
+        || shot.pellets.some((pellet) => !Number.isFinite(pellet.dx) || !Number.isFinite(pellet.dy) || !Number.isFinite(pellet.dz))) {
+        return shotResult(shot, 'invalid-shot', shot.shotFrame - shot.latencyFrames, '', '', 0, 0, 0);
+    }
+    const rewindFrame = shot.shotFrame - shot.latencyFrames;
+    if (rewindFrame > shot.shotFrame) {
+        return shotResult(shot, 'future-frame', rewindFrame, '', '', 0, 0, 0);
+    }
+    if (rewindFrame < 0 || shot.shotFrame - rewindFrame > shot.maxHistoryFrames) {
+        return shotResult(shot, 'stale-frame', rewindFrame, '', '', 0, 0, 0);
+    }
+    const shotDirection = normalizeDirection(shot.dx, shot.dy, shot.dz);
+    if (shotDirection === undefined) {
+        return shotResult(shot, 'invalid-shot', rewindFrame, '', '', 0, 0, 0);
+    }
+    const pelletDirections = [];
+    for (const pellet of shot.pellets) {
+        const pelletDirection = normalizeDirection(pellet.dx, pellet.dy, pellet.dz);
+        if (pelletDirection === undefined || !pelletDirectionMatchesShot(shotDirection, pelletDirection)) {
+            return shotResult(shot, 'invalid-shot', rewindFrame, '', '', 0, 0, 0);
+        }
+        pelletDirections.push(pelletDirection);
+    }
+    const proxies = buildHitboxProxies(history, rewindFrame, shot.shooterSlot);
+    const pelletHits = pelletDirections.map((pelletDirection) => validatePellet([...occluders, ...proxies], shot, pelletDirection));
+    const hitPellets = pelletHits.filter(isHitPellet);
+    const occludedPellets = pelletHits.filter(isOccludedPellet);
+    const firstHit = hitPellets[0];
+    const reason = firstHit !== undefined ? 'hit' : occludedPellets.length > 0 ? 'occluded' : 'miss';
+    const firstOcclusion = occludedPellets[0];
+    return shotResult(shot, reason, rewindFrame, firstHit?.targetId ?? '', firstHit?.hitboxId ?? '', firstHit?.distance ?? firstOcclusion?.distance ?? 0, hitPellets.length, proxies.length, proxies.filter((proxy) => proxy.id.includes('.interpolated.')).length);
+}
+function pelletDirectionMatchesShot(shotDirection, pelletDirection) {
+    const dot = shotDirection.x * pelletDirection.x + shotDirection.y * pelletDirection.y + shotDirection.z * pelletDirection.z;
+    return dot >= 0.95;
+}
+function validatePellet(bodies, shot, pelletDirection) {
+    const world = (0, physics3d_js_1.createDeterministicPhysicsWorld3D)(bodies);
+    const hit = (0, physics3d_js_1.raycastDeterministicPhysics3D)(world, {
+        x: shot.x,
+        y: shot.y,
+        z: shot.z,
+        dx: pelletDirection.x,
+        dy: pelletDirection.y,
+        dz: pelletDirection.z,
+        maxDistance: shot.maxDistance,
+        layerMask: 3,
+    })[0];
+    if (hit === undefined) {
+        return { kind: 'miss' };
+    }
+    if (hit.bodyId.startsWith('occluder.')) {
+        return { kind: 'occluded', targetId: '', hitboxId: hit.bodyId, distance: hit.distance };
+    }
+    const separator = hit.bodyId.indexOf('.');
+    return {
+        kind: 'hit',
+        targetId: separator === -1 ? hit.bodyId : hit.bodyId.slice(0, separator),
+        hitboxId: hit.bodyId,
+        distance: hit.distance,
+    };
+}
+function isHitPellet(result) {
+    return result.kind === 'hit';
+}
+function isOccludedPellet(result) {
+    return result.kind === 'occluded';
+}
+function buildTargetHistory(players, frames, seed) {
+    const snapshots = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        for (let slot = 0; slot < players; slot += 1) {
+            snapshots.push({
+                frame,
+                targetId: `slot-${slot}`,
+                x: targetX(slot, frame, seed),
+                y: 1,
+                z: targetZ(slot, frame, seed),
+                radius: 0.45,
+                pose: (frame + slot + seed) % 5 === 0 ? 'crouching' : 'standing',
+            });
+        }
+    }
+    return snapshots;
+}
+function buildHitboxProxies(history, rewindFrame, shooterSlot) {
+    return interpolateLagCompensatedTargets3D(history, rewindFrame)
+        .filter((snapshot) => shooterSlot === undefined || snapshot.targetId !== `slot-${shooterSlot}`)
+        .flatMap((snapshot) => {
+        const headOffset = snapshot.pose === 'crouching' ? 0.85 : 1.35;
+        const interpolationMarker = isInterpolatedLagCompensatedTarget3D(snapshot) ? '.interpolated' : '';
+        return [
+            hitboxProxy(`${snapshot.targetId}${interpolationMarker}.chest`, snapshot.x, snapshot.y + 0.45, snapshot.z, { type: 'capsule', radius: snapshot.radius, halfHeight: 0.55 }),
+            hitboxProxy(`${snapshot.targetId}${interpolationMarker}.head`, snapshot.x, snapshot.y + headOffset, snapshot.z, { type: 'sphere', radius: 0.28 }),
+        ];
+    });
+}
+function interpolateLagCompensatedTargets3D(history, rewindFrame) {
+    const exact = history.filter((snapshot) => snapshot.frame === rewindFrame);
+    if (exact.length > 0) {
+        return [...exact].sort(compareLagCompensatedTarget3D);
+    }
+    const byTarget = new Map();
+    for (const snapshot of history) {
+        const entry = byTarget.get(snapshot.targetId) ?? {};
+        if (snapshot.frame < rewindFrame && (entry.before === undefined || snapshot.frame > entry.before.frame)) {
+            byTarget.set(snapshot.targetId, { ...entry, before: snapshot });
+            continue;
+        }
+        if (snapshot.frame > rewindFrame && (entry.after === undefined || snapshot.frame < entry.after.frame)) {
+            byTarget.set(snapshot.targetId, { ...entry, after: snapshot });
+        }
+    }
+    const interpolated = [];
+    for (const [targetId, entry] of [...byTarget.entries()].sort(([left], [right]) => compareStrings(left, right))) {
+        if (entry.before === undefined || entry.after === undefined || entry.before.frame === entry.after.frame) {
+            continue;
+        }
+        const alpha = (rewindFrame - entry.before.frame) / (entry.after.frame - entry.before.frame);
+        interpolated.push({
+            frame: rewindFrame,
+            targetId,
+            x: interpolateNumber(entry.before.x, entry.after.x, alpha),
+            y: interpolateNumber(entry.before.y, entry.after.y, alpha),
+            z: interpolateNumber(entry.before.z, entry.after.z, alpha),
+            radius: interpolateNumber(entry.before.radius, entry.after.radius, alpha),
+            pose: alpha < 0.5 ? entry.before.pose : entry.after.pose,
+            interpolated: true,
+        });
+    }
+    return interpolated;
+}
+function compareLagCompensatedTarget3D(left, right) {
+    return compareStrings(left.targetId, right.targetId);
+}
+function compareLagCompensatedTarget3DByFrame(left, right) {
+    return left.frame - right.frame || compareLagCompensatedTarget3D(left, right);
+}
+function normalizeLagCompensatedTargets3D(targets) {
+    const normalized = targets.map((target) => {
+        assertLagCompensationFrame(target.frame);
+        if (typeof target.targetId !== 'string' || target.targetId.length === 0) {
+            throw new Error('Deterministic lag compensation target requires a non-empty target id');
+        }
+        if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || !Number.isFinite(target.z) || !Number.isFinite(target.radius) || target.radius <= 0) {
+            throw new Error(`Deterministic lag compensation target ${target.targetId} has invalid position or radius`);
+        }
+        if (target.pose !== 'standing' && target.pose !== 'crouching') {
+            throw new Error(`Deterministic lag compensation target ${target.targetId} has invalid pose`);
+        }
+        return {
+            frame: target.frame,
+            targetId: target.targetId,
+            x: target.x,
+            y: target.y,
+            z: target.z,
+            radius: target.radius,
+            pose: target.pose,
+        };
+    }).sort(compareLagCompensatedTarget3DByFrame);
+    const duplicate = normalized.find((target, index) => index > 0 && lagCompensatedTargetKey(target) === lagCompensatedTargetKey(normalized[index - 1]));
+    if (duplicate !== undefined) {
+        throw new Error(`Duplicate deterministic lag compensation target ${lagCompensatedTargetKey(duplicate)}`);
+    }
+    return normalized;
+}
+function normalizePhysicsBodies(bodies) {
+    return [...bodies].sort((left, right) => compareStrings(left.id, right.id)).map((body) => ({ ...body }));
+}
+function lagCompensatedTargetKey(target) {
+    return `${target.frame}:${target.targetId}`;
+}
+function assertLagCompensationFrame(frame) {
+    if (!Number.isInteger(frame) || frame < 0) {
+        throw new Error('Deterministic lag compensation frame must be a non-negative integer');
+    }
+}
+function targetSnapshot(frame, targetId, x, y, z, pose) {
+    return {
+        frame,
+        targetId,
+        x,
+        y,
+        z,
+        radius: 0.45,
+        pose,
+    };
+}
+function shotAtTarget(id, shooterSlot, shotFrame, latencyFrames, targetX, targetY, targetZ) {
+    const direction = requireGeneratedShotDirection(targetX, targetY - 1.45, targetZ);
+    return {
+        id,
+        shooterSlot,
+        shotFrame,
+        latencyFrames,
+        x: 0,
+        y: 1.45,
+        z: 0,
+        dx: direction.x,
+        dy: direction.y,
+        dz: direction.z,
+        maxDistance: 40,
+        weapon: 'rifle',
+        pellets: [{ dx: direction.x, dy: direction.y, dz: direction.z }],
+        maxHistoryFrames: 8,
+    };
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function captureGeneratedZeroDirectionRejectionReason() {
+    let reason = 'missing rejection';
+    try {
+        shotAtTarget('api-zero-direction', 0, 0, 0, 0, 1.45, 0);
+    }
+    catch (error) {
+        reason = error.message;
+    }
+    return reason;
+}
+function isInterpolatedLagCompensatedTarget3D(snapshot) {
+    return snapshot.interpolated === true;
+}
+function buildStaticOccluders() {
+    return [
+        {
+            id: 'occluder.center-wall',
+            kind: 'static',
+            x: 0,
+            y: 1.2,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.2, halfY: 2, halfZ: 18 },
+            layer: 2,
+            mask: 3,
+        },
+        {
+            id: 'occluder.side-pillar',
+            kind: 'static',
+            x: -7,
+            y: 1.2,
+            z: 4,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.8, halfY: 2, halfZ: 0.8 },
+            layer: 2,
+            mask: 3,
+        },
+    ];
+}
+function buildShotCorpus(players, frames, seed) {
+    const shots = [];
+    const start = 8;
+    const end = Math.max(start, frames - 3);
+    for (let frame = start; frame < end; frame += 3) {
+        const shooterSlot = (frame + seed) % players;
+        const targetSlot = (shooterSlot + 7 + (frame % 11)) % players;
+        const rewindFrame = Math.max(0, frame - latencyForShot(shooterSlot, frame, seed));
+        const shooter = shooterPose(shooterSlot, frame, seed);
+        const target = {
+            x: targetX(targetSlot, rewindFrame, seed),
+            y: 1.6,
+            z: targetZ(targetSlot, rewindFrame, seed),
+        };
+        const direction = requireGeneratedShotDirection(target.x - shooter.x, target.y - shooter.y, target.z - shooter.z);
+        const weapon = frame % 5 === 0 ? 'shotgun' : frame % 7 === 0 ? 'burst' : 'rifle';
+        shots.push({
+            id: `shot-${frame}-${shooterSlot}`,
+            shooterSlot,
+            shotFrame: frame,
+            latencyFrames: latencyForShot(shooterSlot, frame, seed),
+            x: shooter.x,
+            y: shooter.y,
+            z: shooter.z,
+            dx: direction.x,
+            dy: direction.y,
+            dz: direction.z,
+            maxDistance: 40,
+            weapon,
+            pellets: pelletsForWeapon(weapon, direction),
+            maxHistoryFrames: 12,
+        });
+    }
+    shots.push({
+        id: 'shot-miss',
+        shooterSlot: 2,
+        shotFrame: Math.min(Math.max(start + 2, 12), Math.max(12, frames - 4)),
+        latencyFrames: 2,
+        x: 32,
+        y: 1.6,
+        z: 32,
+        dx: 1,
+        dy: 0,
+        dz: 0,
+        maxDistance: 12,
+        weapon: 'rifle',
+        pellets: [{ dx: 1, dy: 0, dz: 0 }],
+        maxHistoryFrames: 12,
+    });
+    shots.push({
+        id: 'shot-stale',
+        shooterSlot: 0,
+        shotFrame: 3,
+        latencyFrames: 6,
+        x: -18,
+        y: 1.6,
+        z: -18,
+        dx: 1,
+        dy: 0,
+        dz: 1,
+        maxDistance: 40,
+        weapon: 'rifle',
+        pellets: [{ dx: 1, dy: 0, dz: 1 }],
+        maxHistoryFrames: 4,
+    });
+    shots.push({
+        id: 'shot-future',
+        shooterSlot: 1,
+        shotFrame: frames - 2,
+        latencyFrames: -1,
+        x: 18,
+        y: 1.6,
+        z: 18,
+        dx: -1,
+        dy: 0,
+        dz: -1,
+        maxDistance: 40,
+        weapon: 'rifle',
+        pellets: [{ dx: -1, dy: 0, dz: -1 }],
+        maxHistoryFrames: 4,
+    });
+    return shots;
+}
+function buildInterpolationShotCorpus(seed) {
+    const shotFrame = 5;
+    const rewindFrame = 3;
+    const shooterSlot = 0;
+    const targetSlot = 1;
+    const shooter = shooterPose(shooterSlot, shotFrame, seed);
+    const target = {
+        x: targetX(targetSlot, rewindFrame, seed),
+        y: 1.6,
+        z: targetZ(targetSlot, rewindFrame, seed),
+    };
+    const direction = requireGeneratedShotDirection(target.x - shooter.x, target.y - shooter.y, target.z - shooter.z);
+    return [{
+            id: 'shot-interpolated-3d',
+            shooterSlot,
+            shotFrame,
+            latencyFrames: shotFrame - rewindFrame,
+            x: shooter.x,
+            y: shooter.y,
+            z: shooter.z,
+            dx: direction.x,
+            dy: direction.y,
+            dz: direction.z,
+            maxDistance: 40,
+            weapon: 'rifle',
+            pellets: [{ dx: direction.x, dy: direction.y, dz: direction.z }],
+            maxHistoryFrames: 12,
+        }];
+}
+function pelletsForWeapon(weapon, direction) {
+    if (weapon === 'shotgun') {
+        return [-2, -1, 0, 1, 2].map((offset) => ({ dx: direction.x, dy: direction.y + offset * 0.015, dz: direction.z + offset * 0.03 }));
+    }
+    if (weapon === 'burst') {
+        return [0, 1, 2].map((offset) => ({ dx: direction.x, dy: direction.y, dz: direction.z + offset * 0.01 }));
+    }
+    return [{ dx: direction.x, dy: direction.y, dz: direction.z }];
+}
+function hitboxProxy(id, x, y, z, shape) {
+    return {
+        id,
+        kind: 'static',
+        x,
+        y,
+        z,
+        vx: 0,
+        vy: 0,
+        vz: 0,
+        shape,
+        layer: 1,
+        mask: 3,
+    };
+}
+function shotResult(shot, reason, rewindFrame, hitTargetId, hitboxId, distance, pelletHits, proxiesCreated, interpolatedProxies = 0) {
+    const withoutChecksum = {
+        id: shot.id,
+        reason,
+        rewindFrame,
+        hitTargetId,
+        hitboxId,
+        distance,
+        pelletHits,
+        proxiesCreated,
+        proxiesDestroyed: proxiesCreated,
+        interpolatedProxies,
+    };
+    return {
+        ...withoutChecksum,
+        checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+    };
+}
+function shooterPose(slot, frame, seed) {
+    return {
+        x: targetX(slot, frame, seed) - 0.4,
+        y: 1.6,
+        z: targetZ(slot, frame, seed) - 0.4,
+    };
+}
+function targetX(slot, frame, seed) {
+    return ((slot % 16) - 8) * 2 + (((frame + seed + slot) % 5) - 2) * 0.1;
+}
+function targetZ(slot, frame, seed) {
+    return (Math.floor(slot / 16) - 4) * 2 + (((frame * 2 + seed + slot) % 7) - 3) * 0.1;
+}
+function interpolateNumber(before, after, alpha) {
+    return before + (after - before) * alpha;
+}
+function latencyForShot(slot, frame, seed) {
+    return 1 + ((slot + frame + seed) % 6);
+}
+function normalizeDirection(x, y, z) {
+    const scale = 10_000;
+    const ix = Math.round(x * scale);
+    const iy = Math.round(y * scale);
+    const iz = Math.round(z * scale);
+    const lengthSquared = (ix * ix) + (iy * iy) + (iz * iz);
+    if (!Number.isSafeInteger(lengthSquared) || lengthSquared < 0) {
+        return undefined;
+    }
+    const length = integerSqrt(lengthSquared);
+    if (length === 0) {
+        return undefined;
+    }
+    return {
+        x: Math.trunc((ix * scale) / length) / scale,
+        y: Math.trunc((iy * scale) / length) / scale,
+        z: Math.trunc((iz * scale) / length) / scale,
+    };
+}
+function requireGeneratedShotDirection(x, y, z) {
+    const direction = normalizeDirection(x, y, z);
+    if (direction === undefined) {
+        throw new Error('Deterministic lag compensation fixture generated a zero-length shot direction');
+    }
+    return direction;
+}
+function integerSqrt(value) {
+    /* istanbul ignore next -- normalizeDirection validates integerSqrt inputs before calling this private guard. */
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error('integerSqrt requires a non-negative integer');
+    }
+    if (value < 2) {
+        return value;
+    }
+    let low = 1;
+    let high = Math.min(value, 1_000_000_000);
+    let result = 1;
+    while (low <= high) {
+        const mid = Math.trunc((low + high) / 2);
+        const square = mid * mid;
+        if (square === value) {
+            return mid;
+        }
+        if (square < value) {
+            result = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return result;
+}