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

package/dist/local-authority.js

@@ -0,0 +1,810 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+import { createOfflineSession } from './offline-session.js';
+import { DeterministicRandom } from './random.js';
+import { createDeterministicReplayBundle, minimizeDeterministicReplayDesyncBundle, verifyDeterministicReplayBundle, } from './replay-bundle.js';
+export function createDeterministicLocalAuthorityRuntime(players, options = {}) {
+    const maxFrameLead = options.maxFrameLead ?? 12;
+    const rollbackWindowFrames = options.rollbackWindowFrames ?? 0;
+    const stateReducer = options.stateReducer ?? defaultLocalAuthorityStateReducer;
+    const retainAcceptedMessages = rollbackWindowFrames > 0 || options.stateReducer !== undefined;
+    const authorityQueue = new Map();
+    const deliveryQueue = new Map();
+    const acceptedMessages = [];
+    const clientStateBySlot = Array.from({ length: players }, () => 0);
+    const lateJoinSlots = new Set();
+    const spectatorSlots = new Set();
+    const acceptedInputIds = new Set();
+    let commandChecksum = defaultChecksum({ kind: 'local-authority-runtime', players });
+    let state = {
+        frame: 0,
+        players,
+        clients: Array.from({ length: players }, (_, slot) => ({
+            slot,
+            connected: true,
+            spectator: false,
+            inputDelayFrames: 0,
+            lastAckFrame: 0,
+        })),
+        stateBySlot: Array.from({ length: players }, () => 0),
+        rejectedMessages: 0,
+        rollbackDepths: [],
+        clockDriftFrames: [],
+    };
+    function updateClient(slot, updater) {
+        assertSlot(state, slot);
+        state = {
+            ...state,
+            clients: state.clients.map((client) => client.slot === slot ? updater(client) : client),
+        };
+    }
+    const runtime = {
+        get state() {
+            return cloneCanonical(state);
+        },
+        submitInput(message) {
+            if (message.inputId !== undefined && !isValidInputId(message.inputId)) {
+                state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                return false;
+            }
+            if (!Number.isInteger(message.slot) ||
+                message.slot < 0 ||
+                message.slot >= players ||
+                (message.senderSlot !== undefined && (!Number.isInteger(message.senderSlot) || message.senderSlot !== message.slot)) ||
+                !Number.isInteger(message.frame) ||
+                !Number.isFinite(message.value) ||
+                !Number.isInteger(message.value) ||
+                (message.delay !== undefined && (!Number.isInteger(message.delay) || message.delay < 0))) {
+                state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                return false;
+            }
+            const frameInputId = defaultAuthorityInputId(message);
+            const inputId = message.inputId ?? frameInputId;
+            if (acceptedInputIds.has(inputId) || acceptedInputIds.has(frameInputId)) {
+                state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                return false;
+            }
+            let inputData;
+            if (message.data !== undefined) {
+                try {
+                    inputData = cloneCanonical(message.data);
+                }
+                catch {
+                    state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                    return false;
+                }
+            }
+            if (message.frame < state.frame - rollbackWindowFrames ||
+                message.frame > state.frame + maxFrameLead) {
+                state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                return false;
+            }
+            const client = state.clients[message.slot];
+            if (client.connected !== true || client.spectator === true) {
+                state = { ...state, rejectedMessages: state.rejectedMessages + 1 };
+                return false;
+            }
+            const delay = message.delay ?? client.inputDelayFrames;
+            const deliveryFrame = message.frame + Math.max(0, delay);
+            acceptedInputIds.add(inputId);
+            acceptedInputIds.add(frameInputId);
+            commandChecksum = defaultChecksum({ commandChecksum, inputId, frameInputId, slot: message.slot, frame: message.frame, value: message.value, data: inputData });
+            const acceptedMessage = {
+                slot: message.slot,
+                frame: message.frame,
+                delay,
+                deliveryFrame,
+                value: message.value,
+                ...(inputData === undefined ? {} : { data: inputData }),
+            };
+            enqueueAuthorityFrameMessage(authorityQueue, acceptedMessage);
+            enqueueAuthorityDeliveryMessage(deliveryQueue, acceptedMessage);
+            if (retainAcceptedMessages) {
+                acceptedMessages.push(acceptedMessage);
+            }
+            return true;
+        },
+        disconnect(slot) {
+            updateClient(slot, (client) => ({ ...client, connected: false }));
+        },
+        reconnect(slot) {
+            updateClient(slot, (client) => ({ ...client, connected: true, lastAckFrame: state.frame }));
+        },
+        lateJoin(slot) {
+            assertSlot(state, slot);
+            lateJoinSlots.add(slot);
+            clientStateBySlot[slot] = state.stateBySlot[slot];
+            updateClient(slot, (client) => ({ ...client, connected: true, lastAckFrame: state.frame }));
+        },
+        addSpectator(slot) {
+            assertSlot(state, slot);
+            spectatorSlots.add(slot);
+            removeQueuedMessagesForSlot(authorityQueue, slot);
+            removeQueuedMessagesForSlot(deliveryQueue, slot);
+            removeAcceptedMessagesForSlotFromFrame(acceptedMessages, slot, state.frame);
+            clientStateBySlot[slot] = state.stateBySlot[slot];
+            updateClient(slot, (client) => ({ ...client, spectator: true }));
+        },
+        step() {
+            state = retainAcceptedMessages
+                ? applyAuthorityMessages(state, authorityQueue, acceptedMessages, state.frame, stateReducer)
+                : applyQueuedAuthorityMessages(state, authorityQueue, state.frame, stateReducer);
+            deliverClientMessages(deliveryQueue, clientStateBySlot, state.frame, stateReducer);
+            state = { ...state, frame: state.frame + 1 };
+        },
+        snapshot() {
+            return cloneCanonical({
+                state,
+                authorityQueue: serializeAuthorityQueue(authorityQueue),
+                deliveryQueue: serializeDeliveryQueue(deliveryQueue),
+                acceptedMessages: [...acceptedMessages].sort(compareAuthorityFrameMessages),
+                clientStateBySlot,
+                commandChecksum,
+                lateJoinSlots: [...lateJoinSlots].sort(compareNumbers),
+                spectatorSlots: [...spectatorSlots].sort(compareNumbers),
+                acceptedInputIds: [...acceptedInputIds].sort(compareStrings),
+            });
+        },
+        restore(snapshot) {
+            const restoredState = cloneCanonical(snapshot.state);
+            state = {
+                ...restoredState,
+                stateBySlot: Array.from({ length: restoredState.players }, (_, slot) => restoredState.stateBySlot[slot] ?? 0),
+            };
+            restoreAuthorityQueue(authorityQueue, snapshot.authorityQueue ?? []);
+            restoreDeliveryQueue(deliveryQueue, snapshot.deliveryQueue);
+            acceptedMessages.length = 0;
+            acceptedMessages.push(...(snapshot.acceptedMessages ?? []).map((message) => cloneCanonical(message)));
+            for (let slot = 0; slot < clientStateBySlot.length; slot += 1) {
+                clientStateBySlot[slot] = snapshot.clientStateBySlot[slot] ?? 0;
+            }
+            commandChecksum = snapshot.commandChecksum;
+            lateJoinSlots.clear();
+            snapshot.lateJoinSlots.forEach((slot) => lateJoinSlots.add(slot));
+            spectatorSlots.clear();
+            snapshot.spectatorSlots.forEach((slot) => spectatorSlots.add(slot));
+            acceptedInputIds.clear();
+            (snapshot.acceptedInputIds ?? []).forEach((inputId) => acceptedInputIds.add(inputId));
+        },
+        checksums() {
+            const projectedClientStateBySlot = retainAcceptedMessages
+                ? projectClientMessages(players, acceptedMessages, stateReducer)
+                : projectDeliveryMessages(deliveryQueue, clientStateBySlot, stateReducer);
+            const authorityProjectionChecksum = defaultChecksum(state.stateBySlot);
+            const clientProjectionChecksum = defaultChecksum(projectedClientStateBySlot);
+            return {
+                authorityChecksum: defaultChecksum(state),
+                clientChecksum: defaultChecksum(clientStateBySlot),
+                authorityProjectionChecksum,
+                clientProjectionChecksum,
+                convergence: authorityProjectionChecksum === clientProjectionChecksum,
+                commandChecksum,
+            };
+        },
+    };
+    return runtime;
+}
+function defaultAuthorityInputId(message) {
+    return `slot:${message.slot}:frame:${message.frame}`;
+}
+function isValidInputId(inputId) {
+    return /^[A-Za-z0-9:._-]{1,128}$/.test(inputId);
+}
+export function runDeterministicLocalAuthorityFixture(players, frames, seed) {
+    const random = new DeterministicRandom(seed);
+    const lateJoinSlots = new Set(Array.from({ length: players }, (_, slot) => slot).filter((slot) => slot > 0 && slot % 47 === 0));
+    const spectatorSlots = new Set(Array.from({ length: players }, (_, slot) => slot).filter((slot) => slot > 0 && slot % 53 === 0 && !lateJoinSlots.has(slot)));
+    let state = {
+        frame: 0,
+        players,
+        clients: Array.from({ length: players }, (_, slot) => ({
+            slot,
+            connected: !lateJoinSlots.has(slot),
+            spectator: false,
+            inputDelayFrames: 2 + (slot % 4),
+            lastAckFrame: 0,
+        })),
+        stateBySlot: Array.from({ length: players }, () => 0),
+        rejectedMessages: 0,
+        rollbackDepths: [],
+        clockDriftFrames: [],
+    };
+    let reconnects = 0;
+    let lateJoins = 0;
+    let spectators = 0;
+    let absentBeforeJoinInputs = 0;
+    let lateJoinReconstructions = 0;
+    let spectatorReconstructions = 0;
+    let acceptedMessages = 0;
+    let commandChecksum = defaultChecksum({ kind: 'local-authority-command-stream', seed, players });
+    const migrationFrame = Math.floor(frames / 2);
+    let persisted;
+    let migrationQueueRestored = false;
+    let migrationCommandTimelineRestored = false;
+    let slotReservationsRestored = false;
+    const deliveryQueue = new Map();
+    const rollbackDepthHistogram = new Map();
+    const clockDriftHistogram = new Map();
+    const clientStateBySlot = Array.from({ length: players }, () => 0);
+    const costs = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === migrationFrame) {
+            persisted = persistAuthorityRuntime(state, deliveryQueue, clientStateBySlot, commandChecksum, lateJoinSlots, spectatorSlots);
+            state = cloneCanonical(persisted.state);
+            restoreDeliveryQueue(deliveryQueue, persisted.deliveryQueue);
+            for (let slot = 0; slot < clientStateBySlot.length; slot += 1) {
+                clientStateBySlot[slot] = persisted.clientStateBySlot[slot];
+            }
+            migrationQueueRestored = defaultChecksum(serializeDeliveryQueue(deliveryQueue)) === defaultChecksum(persisted.deliveryQueue);
+            migrationCommandTimelineRestored = commandChecksum === persisted.commandChecksum;
+            slotReservationsRestored = defaultChecksum([...lateJoinSlots].sort(compareNumbers)) === defaultChecksum(persisted.lateJoinSlots)
+                && defaultChecksum([...spectatorSlots].sort(compareNumbers)) === defaultChecksum(persisted.spectatorSlots);
+        }
+        const clients = state.clients.map((client) => {
+            if (frame === 7 && client.slot % 31 === 0) {
+                reconnects += 1;
+                return { ...client, connected: false };
+            }
+            if (frame === 11 && client.slot % 31 === 0) {
+                return { ...client, connected: true, lastAckFrame: frame };
+            }
+            if (frame === 13 && lateJoinSlots.has(client.slot) && !client.connected) {
+                lateJoins += 1;
+                lateJoinReconstructions += 1;
+                return { ...client, connected: true, lastAckFrame: frame };
+            }
+            if (frame === 17 && spectatorSlots.has(client.slot) && !client.spectator) {
+                spectators += 1;
+                removeQueuedMessagesForSlot(deliveryQueue, client.slot);
+                clientStateBySlot[client.slot] = state.stateBySlot[client.slot];
+                spectatorReconstructions += 1;
+                return { ...client, spectator: true };
+            }
+            return client;
+        });
+        let rejectedMessages = state.rejectedMessages;
+        const nextStateBySlot = [...state.stateBySlot];
+        for (const client of clients) {
+            const drift = random.nextInt(0, 3) - 1;
+            incrementHistogram(clockDriftHistogram, Math.abs(drift));
+            if (!client.connected || client.spectator) {
+                absentBeforeJoinInputs += !client.connected && lateJoinSlots.has(client.slot) ? 1 : 0;
+                continue;
+            }
+            if (client.slot === players - 1 && frame % 29 === 0) {
+                rejectedMessages += 1;
+            }
+            else {
+                acceptedMessages += 1;
+                const delay = client.inputDelayFrames + drift;
+                const value = frame + client.slot + delay;
+                commandChecksum = defaultChecksum({ commandChecksum, slot: client.slot, frame, value });
+                enqueueAuthorityDeliveryMessage(deliveryQueue, {
+                    slot: client.slot,
+                    frame,
+                    delay,
+                    deliveryFrame: frame + Math.max(0, delay),
+                    value,
+                });
+                nextStateBySlot[client.slot] += value;
+            }
+            const delay = client.inputDelayFrames + drift;
+            incrementHistogram(rollbackDepthHistogram, Math.max(0, delay));
+        }
+        deliverClientMessages(deliveryQueue, clientStateBySlot, frame, defaultLocalAuthorityStateReducer);
+        state = {
+            frame: frame + 1,
+            players,
+            clients,
+            stateBySlot: nextStateBySlot,
+            rejectedMessages,
+            rollbackDepths: [],
+            clockDriftFrames: [],
+        };
+        costs.push(players / 10_000 + acceptedMessages / 1_000_000);
+    }
+    deliverAllClientMessages(deliveryQueue, clientStateBySlot);
+    const authorityProjectionChecksum = defaultChecksum(state.stateBySlot);
+    const clientProjectionChecksum = defaultChecksum(clientStateBySlot);
+    return {
+        authorityChecksum: defaultChecksum(state),
+        clientChecksum: defaultChecksum(clientStateBySlot),
+        authorityProjectionChecksum,
+        clientProjectionChecksum,
+        convergence: authorityProjectionChecksum === clientProjectionChecksum,
+        players,
+        frames,
+        reconnects,
+        lateJoins,
+        spectators,
+        absentBeforeJoinInputs,
+        lateJoinReconstructions,
+        spectatorReconstructions,
+        rejectedMessages: state.rejectedMessages,
+        migrationFrame,
+        migrationPersistedSections: persisted === undefined ? 0 : 5,
+        migrationQueueRestored,
+        migrationCommandTimelineRestored,
+        slotReservationsRestored,
+        inputDelayP95: percentile(state.clients.map((client) => client.inputDelayFrames), 95),
+        rollbackDepthP95: percentileFromHistogram(rollbackDepthHistogram, 95),
+        clockDriftP95: percentileFromHistogram(clockDriftHistogram, 95),
+        p95FrameCost: percentile(costs, 95),
+        p99FrameCost: percentile(costs, 99),
+    };
+}
+export function runDeterministicLocalAuthorityRuntimePolicyFixture() {
+    const runtime = createDeterministicLocalAuthorityRuntime(2, { maxFrameLead: 4, rollbackWindowFrames: 2 });
+    runtime.step();
+    runtime.step();
+    const inputData = {
+        axisX: 2,
+        fire: true,
+        buttons: ['jump', 'dash'],
+        aim: { x: 7, y: -3 },
+    };
+    const lateWithinRollbackWindowAccepted = runtime.submitInput({
+        slot: 0,
+        frame: 1,
+        value: 5,
+        data: inputData,
+        delay: 0,
+        inputId: 'late-structured-input',
+    });
+    const queuedSnapshot = runtime.snapshot();
+    const queuedData = queuedSnapshot.authorityQueue
+        .flatMap((entry) => entry.messages)
+        .find((message) => message.slot === 0 && message.frame === 1)?.data;
+    runtime.step();
+    const afterLateStep = runtime.checksums();
+    const expiredLateInputRejected = runtime.submitInput({
+        slot: 1,
+        frame: 0,
+        value: 7,
+        inputId: 'expired-late-input',
+    }) === false;
+    const strictRuntime = createDeterministicLocalAuthorityRuntime(1, { maxFrameLead: 4 });
+    strictRuntime.step();
+    const strictStaleInputRejected = strictRuntime.submitInput({
+        slot: 0,
+        frame: 0,
+        value: 3,
+        inputId: 'strict-stale-input',
+    }) === false;
+    const malformedRuntime = createDeterministicLocalAuthorityRuntime(1, { maxFrameLead: 4, rollbackWindowFrames: 1 });
+    const malformedStructuredInputRejected = malformedRuntime.submitInput({
+        slot: 0,
+        frame: 0,
+        value: 1,
+        data: Symbol('malformed-structured-input'),
+        inputId: 'malformed-structured-input',
+    }) === false;
+    const restored = createDeterministicLocalAuthorityRuntime(2, { maxFrameLead: 4, rollbackWindowFrames: 2 });
+    restored.restore(queuedSnapshot);
+    restored.step();
+    const restoredAfterLateStep = restored.checksums();
+    let clientProjectionValueAfterLateInput = -1;
+    /* istanbul ignore else -- this fixture's rollbackEquivalent assertion requires convergence; the else value is diagnostic only. */
+    if (afterLateStep.convergence) {
+        clientProjectionValueAfterLateInput = runtime.state.stateBySlot[0];
+    }
+    const nonCommutative = runNonCommutativeLateInputResimulationFixture();
+    return {
+        checksum: afterLateStep.authorityProjectionChecksum,
+        restoredChecksum: restoredAfterLateStep.authorityProjectionChecksum,
+        rollbackEquivalent: afterLateStep.authorityProjectionChecksum === restoredAfterLateStep.authorityProjectionChecksum
+            && afterLateStep.clientProjectionChecksum === restoredAfterLateStep.clientProjectionChecksum,
+        nonCommutativeRuntimeChecksum: nonCommutative.runtimeChecksum,
+        nonCommutativeFullReplayChecksum: nonCommutative.fullReplayChecksum,
+        nonCommutativeAppendOnlyChecksum: nonCommutative.appendOnlyChecksum,
+        nonCommutativeLateInputResimulated: nonCommutative.runtimeChecksum === nonCommutative.fullReplayChecksum,
+        nonCommutativeAppendOnlyDiverged: nonCommutative.appendOnlyChecksum !== nonCommutative.fullReplayChecksum,
+        nonCommutativeResimulatedFrames: nonCommutative.resimulatedFrames,
+        lateWithinRollbackWindowAccepted,
+        expiredLateInputRejected,
+        strictStaleInputRejected,
+        structuredInputDataPreserved: defaultChecksum(queuedData) === defaultChecksum(inputData),
+        malformedStructuredInputRejected,
+        structuredInputChecksum: defaultChecksum(inputData),
+        authorityValueAfterLateInput: runtime.state.stateBySlot[0],
+        clientProjectionValueAfterLateInput,
+        rollbackWindowFrames: 2,
+    };
+}
+export function runDeterministicOfflineToAuthorityUpgradeFixture(players, frames, seed) {
+    const random = new DeterministicRandom(seed);
+    const inputsByFrame = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        const frameInputs = [];
+        for (let slot = 0; slot < players; slot += 1) {
+            frameInputs.push((random.nextInt(0, 7) + frame + slot) % 11);
+        }
+        inputsByFrame.push(frameInputs);
+    }
+    const offline = createOfflineSession({
+        tickRate: 60,
+        playerCount: players,
+        initialState: { stateBySlot: Array.from({ length: players }, () => 0), frame: 0 },
+        defaultInput: { value: 0 },
+        inputSchemaId: 'offline-authority-input/v1',
+        stateSchemaId: 'offline-authority-state/v1',
+        deterministicVersion: 'offline-authority-upgrade@1',
+        snapshotBufferSize: Math.max(8, Math.min(frames + 1, 512)),
+        step: (state, inputs, frame) => ({
+            stateBySlot: state.stateBySlot.map((value, slot) => value + inputs[slot].value),
+            frame: frame + 1,
+        }),
+    });
+    const authority = createDeterministicLocalAuthorityRuntime(players, { maxFrameLead: frames + 4 });
+    let snapshotFrame = Math.floor(frames / 2);
+    let authoritySnapshot;
+    for (let frame = 0; frame < frames; frame += 1) {
+        const frameInputs = inputsByFrame[frame];
+        for (let slot = 0; slot < players; slot += 1) {
+            const value = frameInputs[slot];
+            offline.setInput(slot, { value });
+            authority.submitInput({
+                slot,
+                frame,
+                value,
+                delay: 0,
+                inputId: `offline-authority:${frame}:${slot}`,
+            });
+        }
+        offline.stepFrames(1);
+        authority.step();
+        if (frame + 1 === snapshotFrame) {
+            authoritySnapshot = authority.snapshot();
+        }
+    }
+    if (authoritySnapshot === undefined) {
+        snapshotFrame = frames;
+        authoritySnapshot = authority.snapshot();
+    }
+    const restored = createDeterministicLocalAuthorityRuntime(players, { maxFrameLead: frames + 4 });
+    restored.restore(authoritySnapshot);
+    for (let frame = snapshotFrame; frame < frames; frame += 1) {
+        const frameInputs = inputsByFrame[frame];
+        for (let slot = 0; slot < players; slot += 1) {
+            restored.submitInput({
+                slot,
+                frame,
+                value: frameInputs[slot],
+                delay: 0,
+                inputId: `offline-authority-restored:${frame}:${slot}`,
+            });
+        }
+        restored.step();
+    }
+    const offlineState = offline.getState();
+    const replay = offline.exportReplay();
+    const authorityChecksums = authority.checksums();
+    const restoredChecksums = restored.checksums();
+    const offlineChecksum = defaultChecksum(offlineState.stateBySlot);
+    const replayFinalChecksum = replay.checksums.at(-1)?.checksum ?? '';
+    const offlineStateChecksum = defaultChecksum(offlineState);
+    const authorityChecksum = authorityChecksums.authorityProjectionChecksum;
+    const authorityRestoredChecksum = restoredChecksums.authorityProjectionChecksum;
+    return {
+        checksum: defaultChecksum({
+            offlineChecksum,
+            authorityChecksum,
+            authorityRestoredChecksum,
+            replayChecksum: defaultChecksum(replay),
+        }),
+        players,
+        frames,
+        offlineFrame: offline.currentFrame,
+        authorityFrame: authority.state.frame,
+        offlineChecksum,
+        authorityChecksum,
+        authorityRestoredChecksum,
+        replayChecksum: defaultChecksum(replay),
+        stateMatch: offlineChecksum === authorityChecksum,
+        replayVerified: replayFinalChecksum === offlineStateChecksum,
+        restoreVerified: authorityRestoredChecksum === authorityChecksum,
+        authorityConvergence: authorityChecksums.convergence,
+        inputRows: replay.inputFrames.reduce((sum, inputFrame) => sum + inputFrame.inputs.length, 0),
+        snapshotFrame,
+    };
+}
+export function runDeterministicLocalAuthorityReplayMinimizerFixture(players, frames, seed) {
+    const random = new DeterministicRandom(seed);
+    const runtime = createDeterministicLocalAuthorityRuntime(players);
+    const inputHistory = [];
+    const checksums = [];
+    const snapshots = [];
+    const debugEvents = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        const inputs = [];
+        for (let slot = 0; slot < players; slot += 1) {
+            const value = (random.nextInt(0, 9) + frame + slot) % 13;
+            runtime.submitInput({
+                slot,
+                frame,
+                value,
+                delay: 0,
+                inputId: `authority-replay:${frame}:${slot}`,
+            });
+            inputs.push({ slot, dx: value, dy: 0 });
+        }
+        runtime.step();
+        inputHistory.push({ frame, inputs });
+        const snapshotPayload = {
+            frame,
+            positions: runtime.state.stateBySlot,
+            commandScore: 0,
+        };
+        const bytes = canonicalStringify(snapshotPayload);
+        const checksum = defaultChecksum(bytes);
+        snapshots.push({ frame, bytes, checksum });
+        checksums.push({ frame, checksum });
+        debugEvents.push({
+            frame,
+            type: 'local-authority.snapshot',
+            payload: { frame, checksum },
+        });
+    }
+    const validBundle = createDeterministicReplayBundle({
+        runtimeVersion: 'local-authority-replay@1',
+        engineHash: 'local-authority-engine',
+        schemaHash: 'local-authority-schema',
+        assetDbHash: 'local-authority-assets',
+        configHash: 'local-authority-config',
+        sampleId: 'local-authority-replay-minimizer',
+        inputHistory,
+        commandHistory: [],
+        checksums,
+        debugEvents,
+        snapshots,
+        metadata: { players, frames, seed },
+    });
+    const mismatchFrame = Math.max(1, Math.floor(frames / 2));
+    const corruptedBundle = createDeterministicReplayBundle({
+        ...validBundle,
+        checksums: validBundle.checksums.map((checksum) => checksum.frame === mismatchFrame
+            ? { ...checksum, checksum: `corrupt:${checksum.frame}` }
+            : checksum),
+    });
+    const validVerification = verifyDeterministicReplayBundle(validBundle);
+    const corruptedVerification = verifyDeterministicReplayBundle(corruptedBundle);
+    const minimization = minimizeDeterministicReplayDesyncBundle(validBundle, corruptedBundle);
+    return {
+        checksum: defaultChecksum({
+            valid: validVerification.bundleHash,
+            corrupted: corruptedVerification.bundleHash,
+            minimized: minimization?.verifier.bundleHash ?? '',
+        }),
+        players,
+        frames,
+        validReplayVerified: validVerification.result === 'pass',
+        corruptedReplayFailed: corruptedVerification.result === 'fail',
+        minimizedReplayFailed: minimization?.verifier.result === 'fail',
+        mismatchFrame: corruptedVerification.firstMismatch.frame,
+        minimizedMismatchFrame: minimization?.verifier.firstMismatch?.frame ?? -1,
+        originalReplayBytes: minimization?.originalReplayBytes ?? 0,
+        minimizedReplayBytes: minimization?.minimizedReplayBytes ?? 0,
+        removedInputFrames: minimization?.removedInputFrames ?? 0,
+        removedSnapshots: minimization?.removedSnapshots ?? 0,
+        removedChecksumFrames: minimization?.removedChecksumFrames ?? 0,
+        debugEvents: validBundle.debugEvents.length,
+    };
+}
+function runNonCommutativeLateInputResimulationFixture() {
+    const stateReducer = (currentValue, message) => (currentValue * 31 + message.value) % 2_147_483_647;
+    const runtime = createDeterministicLocalAuthorityRuntime(1, { maxFrameLead: 4, rollbackWindowFrames: 4, stateReducer });
+    runtime.submitInput({ slot: 0, frame: 0, value: 2, inputId: 'noncommutative:f0' });
+    runtime.step();
+    runtime.submitInput({ slot: 0, frame: 2, value: 5, inputId: 'noncommutative:f2' });
+    runtime.step();
+    runtime.step();
+    const lateInputFrame = 1;
+    const verifiedFrame = runtime.state.frame;
+    runtime.submitInput({ slot: 0, frame: lateInputFrame, value: 3, inputId: 'noncommutative:f1-late' });
+    runtime.step();
+    const runtimeChecksum = runtime.checksums().authorityProjectionChecksum;
+    const fullReplay = createDeterministicLocalAuthorityRuntime(1, { maxFrameLead: 4, rollbackWindowFrames: 4, stateReducer });
+    fullReplay.submitInput({ slot: 0, frame: 0, value: 2, inputId: 'noncommutative-full:f0' });
+    fullReplay.step();
+    fullReplay.submitInput({ slot: 0, frame: 1, value: 3, inputId: 'noncommutative-full:f1' });
+    fullReplay.step();
+    fullReplay.submitInput({ slot: 0, frame: 2, value: 5, inputId: 'noncommutative-full:f2' });
+    fullReplay.step();
+    fullReplay.step();
+    const fullReplayChecksum = fullReplay.checksums().authorityProjectionChecksum;
+    const appendOnlyValue = stateReducer(stateReducer(stateReducer(0, { slot: 0, frame: 0, delay: 0, deliveryFrame: 0, value: 2 }), {
+        slot: 0,
+        frame: 2,
+        delay: 0,
+        deliveryFrame: 2,
+        value: 5,
+    }), {
+        slot: 0,
+        frame: lateInputFrame,
+        delay: 0,
+        deliveryFrame: lateInputFrame,
+        value: 3,
+    });
+    return {
+        runtimeChecksum,
+        fullReplayChecksum,
+        appendOnlyChecksum: defaultChecksum([appendOnlyValue]),
+        resimulatedFrames: Math.max(0, verifiedFrame - lateInputFrame),
+    };
+}
+function persistAuthorityRuntime(state, deliveryQueue, clientStateBySlot, commandChecksum, lateJoinSlots, spectatorSlots) {
+    return cloneCanonical({
+        state,
+        deliveryQueue: serializeDeliveryQueue(deliveryQueue),
+        clientStateBySlot,
+        commandChecksum,
+        lateJoinSlots: [...lateJoinSlots].sort(compareNumbers),
+        spectatorSlots: [...spectatorSlots].sort(compareNumbers),
+    });
+}
+function assertSlot(state, slot) {
+    if (!Number.isInteger(slot) || slot < 0 || slot >= state.players) {
+        throw new Error(`Invalid local authority slot ${slot}`);
+    }
+}
+function serializeDeliveryQueue(queue) {
+    return [...queue.entries()]
+        .map(([frame, messages]) => ({ frame, messages: [...messages].sort(compareAuthorityMessages) }))
+        .sort((left, right) => left.frame - right.frame);
+}
+function restoreDeliveryQueue(queue, entries) {
+    queue.clear();
+    for (const entry of entries) {
+        queue.set(entry.frame, entry.messages.map((message) => cloneCanonical(message)));
+    }
+}
+function serializeAuthorityQueue(queue) {
+    return [...queue.entries()]
+        .map(([frame, messages]) => ({ frame, messages: [...messages].sort(compareAuthorityMessages) }))
+        .sort((left, right) => left.frame - right.frame);
+}
+function restoreAuthorityQueue(queue, entries) {
+    queue.clear();
+    for (const entry of entries) {
+        queue.set(entry.frame, entry.messages.map((message) => cloneCanonical(message)));
+    }
+}
+function enqueueAuthorityFrameMessage(queue, message) {
+    const messages = queue.get(message.frame) ?? [];
+    messages.push(message);
+    queue.set(message.frame, messages);
+}
+function enqueueAuthorityDeliveryMessage(queue, message) {
+    const messages = queue.get(message.deliveryFrame) ?? [];
+    messages.push(message);
+    queue.set(message.deliveryFrame, messages);
+}
+function applyAuthorityMessages(state, queue, acceptedMessages, frame, stateReducer) {
+    const dueFrames = [...queue.keys()].filter((targetFrame) => targetFrame <= frame).sort((left, right) => left - right);
+    for (const targetFrame of dueFrames) {
+        queue.delete(targetFrame);
+    }
+    const nextStateBySlot = replayAuthorityMessages(state.players, acceptedMessages, frame, stateReducer);
+    return { ...state, stateBySlot: nextStateBySlot };
+}
+function applyQueuedAuthorityMessages(state, queue, frame, stateReducer) {
+    const dueFrames = [...queue.keys()].filter((targetFrame) => targetFrame <= frame).sort((left, right) => left - right);
+    if (dueFrames.length === 0) {
+        return state;
+    }
+    const nextStateBySlot = [...state.stateBySlot];
+    for (const targetFrame of dueFrames) {
+        const messages = queue.get(targetFrame);
+        for (const message of [...messages].sort(compareAuthorityMessages)) {
+            nextStateBySlot[message.slot] = stateReducer(nextStateBySlot[message.slot], message);
+        }
+        queue.delete(targetFrame);
+    }
+    return { ...state, stateBySlot: nextStateBySlot };
+}
+function deliverClientMessages(queue, clientStateBySlot, frame, stateReducer) {
+    const dueFrames = [...queue.keys()].filter((deliveryFrame) => deliveryFrame <= frame).sort((left, right) => left - right);
+    for (const deliveryFrame of dueFrames) {
+        const messages = queue.get(deliveryFrame);
+        for (const message of [...messages].sort(compareAuthorityMessages)) {
+            clientStateBySlot[message.slot] = stateReducer(clientStateBySlot[message.slot], message);
+        }
+        queue.delete(deliveryFrame);
+    }
+}
+function deliverAllClientMessages(queue, clientStateBySlot) {
+    for (const deliveryFrame of [...queue.keys()].sort((left, right) => left - right)) {
+        const messages = queue.get(deliveryFrame);
+        for (const message of [...messages].sort(compareAuthorityMessages)) {
+            clientStateBySlot[message.slot] += message.value;
+        }
+        queue.delete(deliveryFrame);
+    }
+}
+function projectClientMessages(players, acceptedMessages, stateReducer) {
+    return replayAuthorityMessages(players, acceptedMessages, Number.MAX_SAFE_INTEGER, stateReducer);
+}
+function projectDeliveryMessages(queue, clientStateBySlot, stateReducer) {
+    const projected = [...clientStateBySlot];
+    for (const deliveryFrame of [...queue.keys()].sort((left, right) => left - right)) {
+        const messages = queue.get(deliveryFrame);
+        for (const message of [...messages].sort(compareAuthorityMessages)) {
+            projected[message.slot] = stateReducer(projected[message.slot], message);
+        }
+    }
+    return projected;
+}
+function replayAuthorityMessages(players, acceptedMessages, frame, stateReducer) {
+    const stateBySlot = Array.from({ length: players }, () => 0);
+    for (const message of [...acceptedMessages]
+        .filter((candidate) => candidate.frame <= frame)
+        .sort(compareAuthorityFrameMessages)) {
+        stateBySlot[message.slot] = stateReducer(stateBySlot[message.slot], message);
+    }
+    return stateBySlot;
+}
+function defaultLocalAuthorityStateReducer(currentValue, message) {
+    return currentValue + message.value;
+}
+function removeQueuedMessagesForSlot(queue, slot) {
+    for (const deliveryFrame of [...queue.keys()].sort((left, right) => left - right)) {
+        const remaining = queue.get(deliveryFrame).filter((message) => message.slot !== slot);
+        if (remaining.length === 0) {
+            queue.delete(deliveryFrame);
+        }
+        else {
+            queue.set(deliveryFrame, remaining);
+        }
+    }
+}
+function removeAcceptedMessagesForSlotFromFrame(messages, slot, frame) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.slot === slot && message.frame >= frame) {
+            messages.splice(index, 1);
+        }
+    }
+}
+function incrementHistogram(histogram, value) {
+    histogram.set(value, (histogram.get(value) ?? 0) + 1);
+}
+function percentileFromHistogram(histogram, percentileRank) {
+    const total = [...histogram.values()].reduce((sum, count) => sum + count, 0);
+    if (total === 0) {
+        return 0;
+    }
+    const target = Math.floor((percentileRank / 100) * total);
+    let seen = 0;
+    for (const [value, count] of [...histogram.entries()].sort((left, right) => left[0] - right[0])) {
+        seen += count;
+        if (seen > target) {
+            return value;
+        }
+    }
+    /* istanbul ignore next -- non-empty histogram entries exhaust the counted total above. */
+    throw new Error('Percentile histogram traversal ended before reaching its target');
+}
+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 compareAuthorityMessages(left, right) {
+    return left.deliveryFrame - right.deliveryFrame
+        || left.frame - right.frame
+        || left.slot - right.slot;
+}
+function compareAuthorityFrameMessages(left, right) {
+    return left.frame - right.frame
+        || left.deliveryFrame - right.deliveryFrame
+        || left.slot - right.slot;
+}
+function compareNumbers(left, right) {
+    return left - right;
+}
+function compareStrings(left, right) {
+    /* istanbul ignore next -- accepted input ids are unique Set keys before sorting. */
+    return left < right ? -1 : left > right ? 1 : 0;
+}