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

package/dist/local-ws-adapter.d.ts

@@ -0,0 +1,14 @@
+import { type DeterministicMockNetworkReplay } from './mock-network-adapter.js';
+import type { ProtocolRollbackLabOptions } from './protocol-lab.js';
+export interface LocalWebSocketServer {
+    readonly port: number;
+    readonly healthUrl: string;
+    readonly url: string;
+    close(): Promise<void>;
+}
+export interface LocalWebSocketAdapterTestOptions {
+    readonly url: string;
+    readonly protocolOptions: ProtocolRollbackLabOptions;
+}
+export declare function startLocalWebSocketProtocolServer(port: number): Promise<LocalWebSocketServer>;
+export declare function runLocalWebSocketAdapterTest(options: LocalWebSocketAdapterTestOptions): Promise<DeterministicMockNetworkReplay>;

package/dist/local-ws-adapter.js

@@ -0,0 +1,146 @@
+import { createServer } from 'node:http';
+import { createDeterministicMockNetworkAdapter } from './mock-network-adapter.js';
+import { encodeWebSocketCloseFrame, encodeWebSocketTextFrame, readWebSocketFrame, webSocketAcceptKey } from './ws-frame.js';
+export async function startLocalWebSocketProtocolServer(port) {
+    const server = createServer((request, response) => {
+        if (request.url === '/health') {
+            response.statusCode = 200;
+            response.setHeader('content-type', 'text/plain');
+            response.end('ok');
+            return;
+        }
+        response.statusCode = 404;
+        response.end('not found');
+    });
+    server.on('upgrade', (request, socket, head) => {
+        if (new URL(request.url ?? '/', 'http://127.0.0.1').pathname !== '/protocol') {
+            socket.end('HTTP/1.1 404 Not Found\r\n\r\n');
+            return;
+        }
+        acceptWebSocket(request, socket);
+        const connection = createLocalProtocolConnection(socket);
+        if (head.byteLength > 0) {
+            connection.receive(head);
+        }
+    });
+    await new Promise((resolveListen) => {
+        server.listen(port, '127.0.0.1', resolveListen);
+    });
+    const actualPort = serverPort(server);
+    return {
+        port: actualPort,
+        healthUrl: `http://127.0.0.1:${actualPort}/health`,
+        url: `ws://127.0.0.1:${actualPort}/protocol`,
+        close() {
+            return new Promise((resolveClose, rejectClose) => {
+                server.close((error) => {
+                    if (error !== undefined) {
+                        rejectClose(error);
+                        return;
+                    }
+                    resolveClose();
+                });
+            });
+        },
+    };
+}
+export async function runLocalWebSocketAdapterTest(options) {
+    const socket = new WebSocket(options.url);
+    const request = {
+        kind: 'run-protocol',
+        options: options.protocolOptions,
+    };
+    await new Promise((resolveOpen, rejectOpen) => {
+        socket.addEventListener('open', () => resolveOpen(), { once: true });
+        socket.addEventListener('error', () => rejectOpen(new Error(`Could not connect to ${options.url}`)), { once: true });
+    });
+    const response = new Promise((resolveMessage, rejectMessage) => {
+        socket.addEventListener('message', (event) => {
+            try {
+                resolveMessage(JSON.parse(String(event.data)));
+            }
+            catch (error) {
+                rejectMessage(error);
+            }
+            finally {
+                socket.close();
+            }
+        }, { once: true });
+        socket.addEventListener('error', () => rejectMessage(new Error(`WebSocket error from ${options.url}`)), { once: true });
+    });
+    socket.send(JSON.stringify(request));
+    return response;
+}
+function acceptWebSocket(request, socket) {
+    const key = request.headers['sec-websocket-key'];
+    if (typeof key !== 'string') {
+        socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+        return;
+    }
+    socket.write([
+        'HTTP/1.1 101 Switching Protocols',
+        'Upgrade: websocket',
+        'Connection: Upgrade',
+        `Sec-WebSocket-Accept: ${webSocketAcceptKey(key)}`,
+        '\r\n',
+    ].join('\r\n'));
+}
+function createLocalProtocolConnection(socket) {
+    let pending = new Uint8Array();
+    socket.on('data', (chunk) => {
+        receive(chunk);
+    });
+    socket.on('error', () => {
+        socket.destroy();
+    });
+    function receive(chunk) {
+        pending = concatBytes(pending, chunk);
+        let result = readWebSocketFrame(pending);
+        while (result.kind === 'frame') {
+            const frame = result.frame;
+            pending = pending.slice(frame.bytesRead);
+            if (frame.opcode === 8) {
+                socket.end(encodeWebSocketCloseFrame());
+                return;
+            }
+            if (frame.opcode === 1) {
+                handleProtocolText(socket, frame.text);
+            }
+            result = readWebSocketFrame(pending);
+        }
+        if (result.kind === 'invalid') {
+            // Malformed frame: close the connection instead of crashing the process.
+            socket.end(encodeWebSocketCloseFrame());
+        }
+    }
+    return { receive };
+}
+function handleProtocolText(socket, text) {
+    try {
+        const request = JSON.parse(text);
+        if (request.kind !== 'run-protocol') {
+            throw new Error('Unsupported local WebSocket request');
+        }
+        const replay = createDeterministicMockNetworkAdapter(request.options).exportReplay();
+        socket.write(encodeWebSocketTextFrame(JSON.stringify(replay)));
+    }
+    catch (error) {
+        socket.write(encodeWebSocketTextFrame(JSON.stringify({
+            kind: 'error',
+            message: error instanceof Error ? error.message : String(error),
+        })));
+    }
+}
+function concatBytes(left, right) {
+    const output = new Uint8Array(left.byteLength + right.byteLength);
+    output.set(left, 0);
+    output.set(right, left.byteLength);
+    return output;
+}
+function serverPort(server) {
+    const address = server.address();
+    if (address === null || typeof address === 'string') {
+        throw new Error('Could not determine local WebSocket server port');
+    }
+    return address.port;
+}

package/dist/match-log.d.ts

@@ -0,0 +1,74 @@
+import type { ConfirmedInputFrame, EncodedInput } from './input-authority.js';
+import type { DeterministicSessionConfig, OfflineSession } from './types.js';
+/**
+ * Server-ordered match logs + offline re-simulation verification (G3).
+ *
+ * The authority sees and orders every input; with `preserveFullHistory` it can
+ * export the COMPLETE confirmed-input log from tick 0 ({@link SyncplayMatchLog}
+ * via `DeterministicAuthorityRoom.matchLog()`). Re-simulating that log through
+ * the game's deterministic session is THE anti-cheat for deterministic systems
+ * (Quantum doctrine; Rune's server re-execution): a client cannot forge a
+ * score without forging inputs the server itself ordered. This is strictly
+ * stronger than `verifyScoredReplay`, which trusts a CLIENT-exported
+ * ReplayFile — a fully self-consistent fabricated replay passes that; a match
+ * log cannot be fabricated by a client at all.
+ *
+ * The verifier is transport/storage-agnostic: the submission pipeline persists
+ * logs (mp-room-server persists them in the restorable room record) and runs
+ * this wherever the game bundle can execute (worker, verification service).
+ */
+export interface SyncplayMatchLog {
+    readonly v: 1;
+    readonly seed: number;
+    readonly tickRateHz: number;
+    readonly playerCount: number;
+    readonly hardToleranceTicks: number;
+    readonly confirmedThrough: number;
+    /** Every playerId ever seated, by slot — score attribution. */
+    readonly everSlots: Readonly<Record<string, number>>;
+    /** The complete server-ordered confirmed frames, tick 0 .. confirmedThrough. */
+    readonly frames: readonly ConfirmedInputFrame[];
+}
+export interface ScoredMatchLogVerificationConfig<State, Input> {
+    readonly log: SyncplayMatchLog;
+    /**
+     * The game's session factory — the same shape `createNetworkedSyncplayClient`
+     * takes, minus seed/playerCount (supplied from the log so the verifier can
+     * never be pointed at the wrong descriptor).
+     */
+    readonly createSession: (params: {
+        seed: number;
+        playerCount: number;
+    }) => OfflineSession<State, Input>;
+    /** Decode a wire input; MUST map the neutral substitute (canonical null) to the default. */
+    readonly decodeInput: (encoded: EncodedInput) => Input;
+    readonly submittedScore: number;
+    /** Game-supplied: read the canonical score out of the final state. */
+    readonly extractScore: (finalState: State) => number;
+    /**
+     * Optional cross-check against the quorum: the state checksum clients
+     * reported at `confirmedThrough` (from checksum-reports / the validated
+     * snapshot). A mismatch means the server log and the clients' sim disagree —
+     * either a desynced match or a non-deterministic game build.
+     */
+    readonly expectedFinalChecksum?: string;
+}
+export type ScoredMatchLogRejection = 'log-not-contiguous' | 'checksum-mismatch' | 'score-mismatch';
+export interface ScoredMatchLogVerdict {
+    readonly ok: boolean;
+    readonly reason?: ScoredMatchLogRejection;
+    readonly replayScore?: number;
+    readonly submittedScore: number;
+    readonly framesReplayed: number;
+    readonly finalChecksum?: string;
+}
+export declare function verifyScoredMatchLog<State, Input>(config: ScoredMatchLogVerificationConfig<State, Input>): ScoredMatchLogVerdict;
+/**
+ * Convenience: build the verifier's session factory from a full
+ * DeterministicSessionConfig (creators usually have one of these), overriding
+ * seed/playerCount from the log.
+ */
+export declare function matchLogSessionFactory<State, Input>(base: Omit<DeterministicSessionConfig<State, Input>, 'randomSeed' | 'playerCount'>): (params: {
+    seed: number;
+    playerCount: number;
+}) => OfflineSession<State, Input>;

package/dist/match-log.js

@@ -0,0 +1,57 @@
+import { createOfflineSession } from './offline-session.js';
+import { defaultChecksum } from './canonical.js';
+export function verifyScoredMatchLog(config) {
+    const { log } = config;
+    // The log must be the complete, gap-free tick 0..confirmedThrough sequence —
+    // a truncated or reordered log must never verify a score.
+    if (log.frames.length !== log.confirmedThrough + 1 || log.frames.some((frame, index) => frame.tick !== index)) {
+        return { ok: false, reason: 'log-not-contiguous', submittedScore: config.submittedScore, framesReplayed: 0 };
+    }
+    const session = config.createSession({ seed: log.seed, playerCount: log.playerCount });
+    for (const frame of log.frames) {
+        for (let slot = 0; slot < log.playerCount; slot += 1) {
+            session.setInput(slot, config.decodeInput(frame.inputs[slot]));
+        }
+        session.stepFrames(1);
+    }
+    const finalChecksum = String(defaultChecksum(session.getState()));
+    if (config.expectedFinalChecksum !== undefined && finalChecksum !== config.expectedFinalChecksum) {
+        return {
+            ok: false,
+            reason: 'checksum-mismatch',
+            submittedScore: config.submittedScore,
+            framesReplayed: log.frames.length,
+            finalChecksum,
+        };
+    }
+    const replayScore = config.extractScore(session.getState());
+    if (replayScore !== config.submittedScore) {
+        return {
+            ok: false,
+            reason: 'score-mismatch',
+            replayScore,
+            submittedScore: config.submittedScore,
+            framesReplayed: log.frames.length,
+            finalChecksum,
+        };
+    }
+    return {
+        ok: true,
+        replayScore,
+        submittedScore: config.submittedScore,
+        framesReplayed: log.frames.length,
+        finalChecksum,
+    };
+}
+/**
+ * Convenience: build the verifier's session factory from a full
+ * DeterministicSessionConfig (creators usually have one of these), overriding
+ * seed/playerCount from the log.
+ */
+export function matchLogSessionFactory(base) {
+    return ({ seed, playerCount }) => createOfflineSession({
+        ...base,
+        randomSeed: seed,
+        playerCount,
+    });
+}

package/dist/math.d.ts

@@ -0,0 +1,41 @@
+export interface DeterministicMath {
+    readonly fixedScale: number;
+    readonly minFixed: number;
+    readonly maxFixed: number;
+    toFixed(value: number): number;
+    fromFixed(value: number): number;
+    add(a: number, b: number): number;
+    sub(a: number, b: number): number;
+    mul(a: number, b: number): number;
+    div(a: number, b: number): number;
+    saturatingAdd(a: number, b: number): number;
+    saturatingSub(a: number, b: number): number;
+    quantize(value: number, engine: number): number;
+    /**
+     * CHEAP DETERMINISTIC APPROXIMATION, not true sine: piecewise-LINEAR ramp
+     * per quadrant (a triangle wave) — ~29% below true sine at 1/8 turn. Right
+     * for gameplay oscillation/steering where cross-peer identity matters more
+     * than curve shape; wrong for trajectories that must LOOK sinusoidal. A
+     * true polynomial approximation is a candidate for the API freeze pass.
+     */
+    sinTurns(turns: number): number;
+    /** See sinTurns — same triangle-wave approximation, quarter-turn shifted. */
+    cosTurns(turns: number): number;
+    vec2(x: number, y: number): DeterministicFixedVec2;
+    vec2Add(a: DeterministicFixedVec2, b: DeterministicFixedVec2): DeterministicFixedVec2;
+    vec2Lerp(a: DeterministicFixedVec2, b: DeterministicFixedVec2, t: number): DeterministicFixedVec2;
+    quatFromYawTurns(turns: number): DeterministicFixedQuaternion;
+    quatLerp(a: DeterministicFixedQuaternion, b: DeterministicFixedQuaternion, t: number): DeterministicFixedQuaternion;
+    clamp(value: number, min: number, max: number): number;
+}
+export interface DeterministicFixedVec2 {
+    readonly x: number;
+    readonly y: number;
+}
+export interface DeterministicFixedQuaternion {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+export declare function createDeterministicMath(fixedScale?: number, minFixed?: number, maxFixed?: number): DeterministicMath;

package/dist/math.js

@@ -0,0 +1,154 @@
+const DEFAULT_MIN_FIXED = -2_147_483_648;
+const DEFAULT_MAX_FIXED = 2_147_483_647;
+export function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXED, maxFixed = DEFAULT_MAX_FIXED) {
+    if (!Number.isInteger(fixedScale) || fixedScale <= 0) {
+        throw new Error('fixedScale must be a positive integer');
+    }
+    if (!Number.isInteger(minFixed) || !Number.isInteger(maxFixed) || minFixed >= maxFixed) {
+        throw new Error('fixed range must be integer min < max');
+    }
+    return {
+        fixedScale,
+        minFixed,
+        maxFixed,
+        toFixed(value) {
+            if (!Number.isFinite(value)) {
+                throw new Error('Cannot convert a non-finite number to fixed point');
+            }
+            // normalizeZero: Math.round of a tiny negative yields -0, which the
+            // canonical layer tags as {$rdm:'negative-zero'} — keep -0 out of state.
+            return normalizeZero(saturate(Math.round(value * fixedScale), minFixed, maxFixed));
+        },
+        fromFixed(value) {
+            if (!Number.isInteger(value)) {
+                throw new Error('Fixed point values must be integers');
+            }
+            return value / fixedScale;
+        },
+        add(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            const result = a + b;
+            if (result < minFixed || result > maxFixed) {
+                throw new Error('Fixed point addition overflow');
+            }
+            return result;
+        },
+        sub(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            const result = a - b;
+            if (result < minFixed || result > maxFixed) {
+                throw new Error('Fixed point subtraction overflow');
+            }
+            return result;
+        },
+        // Exactness bound: the a*b intermediate is an IEEE double, so results are
+        // deterministic everywhere (correctly-rounded *), but INTEGER-EXACT only
+        // while |a*b| <= 2^53 — at the default fixedScale 1000 that is operands up
+        // to ~95k real units each. Beyond that the product quietly loses low bits
+        // (identically on every peer). Keep gameplay magnitudes inside the bound
+        // or use a larger fixedScale with smaller ranges. div has the same bound
+        // via a*fixedScale.
+        mul(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return normalizeZero(saturate(Math.trunc((a * b) / fixedScale), minFixed, maxFixed));
+        },
+        div(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            if (b === 0) {
+                throw new Error('Fixed point division by zero');
+            }
+            return normalizeZero(saturate(Math.trunc((a * fixedScale) / b), minFixed, maxFixed));
+        },
+        saturatingAdd(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return saturate(a + b, minFixed, maxFixed);
+        },
+        saturatingSub(a, b) {
+            assertFixed(a);
+            assertFixed(b);
+            return saturate(a - b, minFixed, maxFixed);
+        },
+        quantize(value, engine) {
+            assertFixed(value);
+            if (!Number.isInteger(engine) || engine <= 0) {
+                throw new Error('engine must be a positive integer');
+            }
+            return Math.trunc(value / engine) * engine;
+        },
+        sinTurns(turns) {
+            assertFixed(turns);
+            return trigLookup(turns, fixedScale, 'sin');
+        },
+        cosTurns(turns) {
+            assertFixed(turns);
+            return trigLookup(turns, fixedScale, 'cos');
+        },
+        vec2(x, y) {
+            assertFixed(x);
+            assertFixed(y);
+            return { x, y };
+        },
+        vec2Add(a, b) {
+            return {
+                x: saturate(a.x + b.x, minFixed, maxFixed),
+                y: saturate(a.y + b.y, minFixed, maxFixed),
+            };
+        },
+        vec2Lerp(a, b, t) {
+            assertFixed(t);
+            return {
+                x: normalizeZero(a.x + Math.trunc(((b.x - a.x) * t) / fixedScale)),
+                y: normalizeZero(a.y + Math.trunc(((b.y - a.y) * t) / fixedScale)),
+            };
+        },
+        quatFromYawTurns(turns) {
+            assertFixed(turns);
+            const halfTurns = Math.trunc(turns / 2);
+            return {
+                x: 0,
+                y: 0,
+                z: normalizeZero(trigLookup(halfTurns, fixedScale, 'sin')),
+                w: normalizeZero(trigLookup(halfTurns, fixedScale, 'cos')),
+            };
+        },
+        quatLerp(a, b, t) {
+            assertFixed(t);
+            return {
+                x: a.x + Math.trunc(((b.x - a.x) * t) / fixedScale),
+                y: a.y + Math.trunc(((b.y - a.y) * t) / fixedScale),
+                z: a.z + Math.trunc(((b.z - a.z) * t) / fixedScale),
+                w: a.w + Math.trunc(((b.w - a.w) * t) / fixedScale),
+            };
+        },
+        clamp(value, min, max) {
+            return Math.min(max, Math.max(min, value));
+        },
+    };
+}
+function assertFixed(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error('Fixed point values must be integers');
+    }
+}
+function saturate(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function trigLookup(turns, fixedScale, op) {
+    const normalized = ((turns % fixedScale) + fixedScale) % fixedScale;
+    const quadrant = Math.trunc((normalized * 4) / fixedScale) % 4;
+    const offset = normalized - Math.trunc((quadrant * fixedScale) / 4);
+    const ramp = Math.trunc((offset * fixedScale * 4) / fixedScale);
+    const sin = quadrant === 0 ? ramp : quadrant === 1 ? fixedScale - ramp : quadrant === 2 ? -ramp : -fixedScale + ramp;
+    if (op === 'sin') {
+        return normalizeZero(sin);
+    }
+    return trigLookup(normalized + Math.trunc(fixedScale / 4), fixedScale, 'sin');
+}
+function normalizeZero(value) {
+    return Object.is(value, -0) ? 0 : value;
+}

package/dist/mock-network-adapter.d.ts

@@ -0,0 +1,13 @@
+import { type ProtocolRollbackLabOptions, type ProtocolRollbackLabResult } from './protocol-lab.js';
+export interface DeterministicMockNetworkAdapter {
+    readonly options: ProtocolRollbackLabOptions;
+    run(): ProtocolRollbackLabResult;
+    exportReplay(): DeterministicMockNetworkReplay;
+}
+export interface DeterministicMockNetworkReplay {
+    readonly formatVersion: 1;
+    readonly kind: 'deterministic-mock-network';
+    readonly options: ProtocolRollbackLabOptions;
+    readonly result: ProtocolRollbackLabResult;
+}
+export declare function createDeterministicMockNetworkAdapter(options: ProtocolRollbackLabOptions): DeterministicMockNetworkAdapter;

package/dist/mock-network-adapter.js

@@ -0,0 +1,23 @@
+import { cloneCanonical } from './canonical.js';
+import { runProtocolRollbackLab } from './protocol-lab.js';
+export function createDeterministicMockNetworkAdapter(options) {
+    const stableOptions = cloneCanonical(options);
+    let result;
+    return {
+        options: stableOptions,
+        run() {
+            result = runProtocolRollbackLab(stableOptions);
+            return cloneCanonical(result);
+        },
+        exportReplay() {
+            const replayResult = result ?? runProtocolRollbackLab(stableOptions);
+            result = replayResult;
+            return {
+                formatVersion: 1,
+                kind: 'deterministic-mock-network',
+                options: cloneCanonical(stableOptions),
+                result: cloneCanonical(replayResult),
+            };
+        },
+    };
+}

package/dist/movement.d.ts

@@ -0,0 +1,155 @@
+import { type QuantizedFpsAim } from './deterministic-primitives.js';
+export interface DeterministicKccBody {
+    readonly x: number;
+    readonly y: number;
+    readonly vx: number;
+    readonly vy: number;
+    readonly grounded: boolean;
+    readonly coyoteFrames: number;
+    readonly jumpBufferFrames: number;
+    readonly wallSlideSide: -1 | 0 | 1;
+    readonly platformId?: string;
+}
+export interface DeterministicKccInput {
+    readonly moveX: number;
+    readonly jumpPressed?: boolean;
+    readonly dropPressed?: boolean;
+}
+export interface DeterministicSlope {
+    readonly id: string;
+    readonly minX: number;
+    readonly maxX: number;
+    readonly baseY: number;
+    readonly risePerUnit: number;
+}
+export interface DeterministicMovementStep {
+    readonly id: string;
+    readonly x: number;
+    readonly height: number;
+}
+export interface DeterministicMovingPlatform {
+    readonly id: string;
+    readonly minX: number;
+    readonly maxX: number;
+    readonly y: number;
+    readonly dxPerFrame: number;
+    readonly dyPerFrame?: number;
+}
+export interface DeterministicOneWayPlatform {
+    readonly id: string;
+    readonly minX: number;
+    readonly maxX: number;
+    readonly y: number;
+}
+export interface DeterministicMovementWorld {
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minY: number;
+    readonly maxY: number;
+    readonly walls: readonly number[];
+    readonly slopes: readonly DeterministicSlope[];
+    readonly steps: readonly DeterministicMovementStep[];
+    readonly movingPlatforms: readonly DeterministicMovingPlatform[];
+    readonly oneWayPlatforms: readonly DeterministicOneWayPlatform[];
+}
+export interface DeterministicKccStepResult {
+    readonly body: DeterministicKccBody;
+    readonly events: readonly string[];
+}
+export interface DeterministicTopDownBody {
+    readonly x: number;
+    readonly y: number;
+    readonly vx: number;
+    readonly vy: number;
+}
+export interface DeterministicTopDownInput {
+    readonly dx: number;
+    readonly dy: number;
+    readonly navDx?: number;
+    readonly navDy?: number;
+}
+export interface DeterministicTopDownBounds {
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minY: number;
+    readonly maxY: number;
+}
+export interface DeterministicFpsAimState extends QuantizedFpsAim {
+    readonly recoil: number;
+}
+export interface DeterministicFpsInput {
+    readonly yawDelta: number;
+    readonly pitchDelta: number;
+    readonly fire?: boolean;
+}
+export interface DeterministicTargetSnapshot {
+    readonly frame: number;
+    readonly targetId: string;
+    readonly x: number;
+    readonly y: number;
+    readonly radius?: number;
+}
+export interface DeterministicLagCompensatedShot {
+    readonly shotFrame: number;
+    readonly latencyFrames: number;
+    readonly shooterX: number;
+    readonly shooterY: number;
+    readonly directionX: number;
+    readonly directionY: number;
+    readonly maxDistance: number;
+    readonly targetId?: string;
+    readonly maxHistoryFrames?: number;
+}
+export interface DeterministicLagCompensatedHitValidation {
+    readonly accepted: boolean;
+    readonly reason: 'hit' | 'miss' | 'stale-frame' | 'future-frame' | 'no-target' | 'invalid-shot';
+    readonly rewindFrame: number;
+    readonly targetId?: string;
+    readonly hitTargetId?: string;
+    readonly interpolated: boolean;
+    readonly distance: number;
+    readonly checksum: string;
+}
+export interface DeterministicMovementSimulationMetrics {
+    readonly checksum: string;
+    readonly slopes: number;
+    readonly steps: number;
+    readonly ledges: number;
+    readonly platformRides: number;
+    readonly elevatorRides: number;
+    readonly oneWayDrops: number;
+    readonly wallSlides: number;
+    readonly bufferedJumps: number;
+    readonly coyoteJumps: number;
+    readonly topDownSlides: number;
+    readonly navSteeringFrames: number;
+    readonly hitscanOriginsStable: boolean;
+    readonly recoilFrames: number;
+    readonly rewindHits: number;
+    readonly rewindValidatedHits: number;
+    readonly rewindMisses: number;
+    readonly rewindRejectedStale: number;
+    readonly rewindRejectedFuture: number;
+    readonly rewindInterpolated: number;
+    readonly rewindValidationChecksum: string;
+}
+export interface DeterministicMovementCrowdMetrics {
+    readonly checksum: string;
+    readonly players: number;
+    readonly frames: number;
+    readonly humanInputSlots: number;
+    readonly botInputSlots: number;
+    readonly predictionCorrections: number;
+    readonly rollbackEquivalent: boolean;
+}
+export declare function stepDeterministicKcc2D(body: DeterministicKccBody, input: DeterministicKccInput, world: DeterministicMovementWorld, frame: number): DeterministicKccStepResult;
+export declare function stepDeterministicTopDownMover(body: DeterministicTopDownBody, input: DeterministicTopDownInput, bounds: DeterministicTopDownBounds): {
+    readonly body: DeterministicTopDownBody;
+    readonly slid: boolean;
+    readonly navSteered: boolean;
+};
+export declare function stepDeterministicFpsAim(previous: DeterministicFpsAimState, input: DeterministicFpsInput, seed: number, frame: number): DeterministicFpsAimState;
+export declare function rewindDeterministicTargets(snapshots: readonly DeterministicTargetSnapshot[], targetFrame: number): readonly DeterministicTargetSnapshot[];
+export declare function validateDeterministicLagCompensatedHit(snapshots: readonly DeterministicTargetSnapshot[], shot: DeterministicLagCompensatedShot): DeterministicLagCompensatedHitValidation;
+export declare function runDeterministicMovementSimulation(frames: number, seed: number, restoreFrame?: number): DeterministicMovementSimulationMetrics;
+export declare function runDeterministicMovementCrowdSimulation(players: number, frames: number, seed: number, restoreFrame?: number): DeterministicMovementCrowdMetrics;