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

package/dist/cjs/protocol-lab.js

@@ -0,0 +1,1299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProtocolRollbackLab = runProtocolRollbackLab;
+exports.runProtocolLabInternalCoverageProbe = runProtocolLabInternalCoverageProbe;
+const canonical_js_1 = require("./canonical.js");
+const counter_duel_js_1 = require("./examples/counter-duel.js");
+const offline_session_js_1 = require("./offline-session.js");
+const random_js_1 = require("./random.js");
+const sample_lab_js_1 = require("./sample-lab.js");
+class MockNetwork {
+    minDelayFrames;
+    maxDelayFrames;
+    duplicatePermille;
+    lossPermille;
+    resendIntervalFrames;
+    maxResendAttempts;
+    disconnectStartFrame;
+    disconnectEndFrame;
+    latencySkewSlot;
+    latencySkewFrames;
+    random;
+    scheduled = [];
+    deliveries = 0;
+    duplicates = 0;
+    lost = 0;
+    disconnectDrops = 0;
+    canceledRetries = 0;
+    reorders = 0;
+    deliveryDelaySamples = [];
+    sequence = 0;
+    lastDeliveredSourceFrame = -1;
+    constructor(seed, minDelayFrames, maxDelayFrames, duplicatePermille, lossPermille, resendIntervalFrames, maxResendAttempts, disconnectStartFrame, disconnectEndFrame, latencySkewSlot, latencySkewFrames) {
+        this.minDelayFrames = minDelayFrames;
+        this.maxDelayFrames = maxDelayFrames;
+        this.duplicatePermille = duplicatePermille;
+        this.lossPermille = lossPermille;
+        this.resendIntervalFrames = resendIntervalFrames;
+        this.maxResendAttempts = maxResendAttempts;
+        this.disconnectStartFrame = disconnectStartFrame;
+        this.disconnectEndFrame = disconnectEndFrame;
+        this.latencySkewSlot = latencySkewSlot;
+        this.latencySkewFrames = latencySkewFrames;
+        this.random = new random_js_1.DeterministicRandom(seed);
+    }
+    send(currentFrame, message) {
+        for (let attempt = 0; attempt < this.maxResendAttempts; attempt += 1) {
+            this.schedule(currentFrame + attempt * this.resendIntervalFrames, message, false);
+        }
+    }
+    drain(deliveryFrame) {
+        const ready = this.scheduled
+            .filter((message) => message.deliveryFrame <= deliveryFrame)
+            .sort((a, b) => a.deliveryFrame - b.deliveryFrame || a.sequence - b.sequence);
+        const readySequences = new Set(ready.map((message) => message.sequence));
+        for (let index = this.scheduled.length - 1; index >= 0; index -= 1) {
+            if (readySequences.has(this.scheduled[index].sequence)) {
+                this.scheduled.splice(index, 1);
+            }
+        }
+        return ready.flatMap((scheduledMessage) => {
+            this.deliveries += 1;
+            this.deliveryDelaySamples.push(scheduledMessage.deliveryFrame - scheduledMessage.message.startFrame);
+            if (scheduledMessage.duplicate) {
+                this.duplicates += 1;
+            }
+            if (scheduledMessage.message.startFrame < this.lastDeliveredSourceFrame) {
+                this.reorders += 1;
+            }
+            this.lastDeliveredSourceFrame = Math.max(this.lastDeliveredSourceFrame, scheduledMessage.message.startFrame);
+            return scheduledMessage.message.inputs.map((input, index) => ({
+                frame: scheduledMessage.message.startFrame + index,
+                slot: scheduledMessage.message.slot,
+                input,
+            }));
+        });
+    }
+    hasPending() {
+        return this.scheduled.length > 0;
+    }
+    cancel(frame, slot) {
+        for (let index = this.scheduled.length - 1; index >= 0; index -= 1) {
+            const message = this.scheduled[index].message;
+            const frameInBundle = frame >= message.startFrame && frame < message.startFrame + message.inputs.length;
+            if (frameInBundle && message.slot === slot) {
+                this.scheduled.splice(index, 1);
+                this.canceledRetries += 1;
+            }
+        }
+    }
+    getStats() {
+        return {
+            deliveries: this.deliveries,
+            duplicates: this.duplicates,
+            lost: this.lost,
+            disconnectDrops: this.disconnectDrops,
+            canceledRetries: this.canceledRetries,
+            reorders: this.reorders,
+            deliveryDelaySamples: [...this.deliveryDelaySamples],
+        };
+    }
+    schedule(currentFrame, message, duplicate) {
+        if (this.isDisconnected(currentFrame)) {
+            this.disconnectDrops += 1;
+            return;
+        }
+        if (this.random.nextInt(0, 999) < this.lossPermille) {
+            this.lost += 1;
+            return;
+        }
+        const delay = this.random.nextInt(this.minDelayFrames, this.maxDelayFrames) + this.getLatencySkew(message.slot);
+        this.scheduled.push({
+            deliveryFrame: currentFrame + delay,
+            sequence: this.sequence,
+            message,
+            duplicate,
+        });
+        this.sequence += 1;
+        if (!duplicate && this.random.nextInt(0, 999) < this.duplicatePermille) {
+            this.schedule(currentFrame, message, true);
+        }
+    }
+    isDisconnected(frame) {
+        return (this.disconnectStartFrame !== undefined &&
+            this.disconnectEndFrame !== undefined &&
+            frame >= this.disconnectStartFrame &&
+            frame <= this.disconnectEndFrame);
+    }
+    getLatencySkew(slot) {
+        return this.latencySkewSlot === slot ? this.latencySkewFrames : 0;
+    }
+}
+function runProtocolRollbackLab(options) {
+    validateOptions(options);
+    const game = options.game ?? 'lab';
+    if (game === 'counter-duel') {
+        return runProtocolRollbackForGame(options, game, counterDuelAdapter);
+    }
+    if (game === 'moderate-state') {
+        return runProtocolRollbackForGame(options, game, moderateStateAdapter);
+    }
+    if (game === 'command-bursts') {
+        return runProtocolRollbackForGame(options, game, commandBurstsAdapter);
+    }
+    return runProtocolRollbackForGame(options, game, labAdapter);
+}
+function runProtocolRollbackForGame(options, game, adapter) {
+    validateOptions(options);
+    const authority = adapter.createSession(options.players, options.seed, options.frames + 1);
+    const client = adapter.createSession(options.players, options.seed, options.frames + 1);
+    const inputRandom = new random_js_1.DeterministicRandom(options.seed);
+    const network = new MockNetwork(options.seed ^ 0x9e3779b9, options.minDelayFrames, options.maxDelayFrames, options.duplicatePermille ?? 0, options.lossPermille ?? 0, options.resendIntervalFrames ?? Math.max(1, options.maxDelayFrames + 1), options.maxResendAttempts ?? 1, options.disconnectStartFrame, options.disconnectEndFrame, options.latencySkewSlot, options.latencySkewFrames ?? 0);
+    const commandNetwork = new MockNetwork((options.seed ^ 0x85ebca6b) >>> 0, options.minDelayFrames, options.maxDelayFrames, options.duplicatePermille ?? 0, options.lossPermille ?? 0, options.resendIntervalFrames ?? Math.max(1, options.maxDelayFrames + 1), options.maxResendAttempts ?? 1, options.disconnectStartFrame, options.disconnectEndFrame, options.latencySkewSlot, options.latencySkewFrames ?? 0);
+    const truthInputs = [];
+    const confirmedInputs = new Map();
+    const inputHistory = [];
+    const authorityCommandsByFrame = new Map();
+    const clientCommandsByFrame = new Map();
+    const acceptedClientCommandIds = new Set();
+    const pendingBundles = new Map();
+    const bundleSizeFrames = options.bundleSizeFrames ?? 1;
+    let inputDelayFrames = options.inputDelayFrames ?? 0;
+    const adaptiveInputDelay = options.adaptiveInputDelay ?? false;
+    const maxAdaptiveInputDelayFrames = options.maxAdaptiveInputDelayFrames ?? Math.max(inputDelayFrames, options.maxDelayFrames + (options.latencySkewFrames ?? 0));
+    let maxObservedInputDelayFrames = inputDelayFrames;
+    let inputDelayAdjustments = 0;
+    let stableFramesSinceDelayAdjustment = 0;
+    const predictionPolicy = options.predictionPolicy ?? 'repeat-last';
+    const botSlots = new Set(options.botSlots ?? []);
+    const eventTracker = createProtocolEventTracker(options.eventTimelineLimit ?? 64);
+    let confirmations = 0;
+    let localInputConfirmations = 0;
+    let localInputRollbacks = 0;
+    let bundledInputMessages = 0;
+    let absentInputFrames = 0;
+    let botInputFrames = 0;
+    let rollbacks = 0;
+    let maxRollbackDepth = 0;
+    let commandDeliveries = 0;
+    let commandRejected = 0;
+    let commandDuplicateDrops = 0;
+    let predictedInputFrames = 0;
+    let neutralPredictions = 0;
+    let repeatLastPredictions = 0;
+    let repeatLastNonDefaultPredictions = 0;
+    let spectatorInputFrames = 0;
+    let spectatorCommandRejected = 0;
+    const predictionFallbackSamples = [];
+    const commandRejectionCounts = new Map();
+    let commandRollbackFrame;
+    const rollbackDepthSamples = [];
+    let nextClientFrameToStep = 0;
+    let lastCompletelyConfirmedFrame = -1;
+    for (let networkFrame = 0; networkFrame < options.frames; networkFrame += 1) {
+        generateAuthorityFrame(networkFrame);
+        processNetworkFrame(networkFrame);
+        stepReadyClientFrames(networkFrame);
+    }
+    let networkFrame = options.frames;
+    while (network.hasPending() || commandNetwork.hasPending() || nextClientFrameToStep < options.frames) {
+        processNetworkFrame(networkFrame);
+        stepReadyClientFrames(networkFrame);
+        networkFrame += 1;
+    }
+    const authorityChecksum = (0, canonical_js_1.defaultChecksum)(authority.getState());
+    const clientChecksum = (0, canonical_js_1.defaultChecksum)(client.getState());
+    const commandAuthorityChecksum = (0, canonical_js_1.defaultChecksum)(normalizeCommandFrames(authorityCommandsByFrame));
+    const commandClientChecksum = (0, canonical_js_1.defaultChecksum)(normalizeCommandFrames(clientCommandsByFrame));
+    const lateJoinReconstruction = reconstructLateJoin();
+    const spectatorReconstruction = reconstructSpectator();
+    const didDesync = authorityChecksum !== clientChecksum;
+    if (didDesync && options.expectDesync !== true) {
+        throw new Error(`Protocol lab checksum mismatch: authority=${authorityChecksum} client=${clientChecksum}`);
+    }
+    if (!didDesync && options.expectDesync === true) {
+        throw new Error('Protocol lab expected a desync but checksums matched');
+    }
+    const commandRollbackObserved = commandRollbackFrame !== undefined;
+    const commandTimelineConverged = commandAuthorityChecksum === commandClientChecksum;
+    const stats = network.getStats();
+    const commandStats = commandNetwork.getStats();
+    return {
+        game,
+        frames: options.frames,
+        players: options.players,
+        confirmations,
+        localInputConfirmations,
+        localInputRollbacks,
+        bundledInputMessages,
+        bundleSizeFrames,
+        inputDelayFrames: options.inputDelayFrames ?? 0,
+        adaptiveInputDelay,
+        finalInputDelayFrames: inputDelayFrames,
+        maxObservedInputDelayFrames,
+        inputDelayAdjustments,
+        deliveries: stats.deliveries,
+        duplicates: stats.duplicates,
+        lost: stats.lost,
+        disconnectDrops: stats.disconnectDrops,
+        canceledRetries: stats.canceledRetries,
+        absentInputFrames,
+        botInputFrames,
+        reorders: stats.reorders,
+        rollbacks,
+        maxRollbackDepth,
+        deliveryDelaySamples: stats.deliveryDelaySamples,
+        rollbackDepthSamples,
+        eventTimeline: eventTracker.summary(),
+        commandDeliveries,
+        commandDuplicates: commandStats.duplicates,
+        commandLost: commandStats.lost,
+        commandDisconnectDrops: commandStats.disconnectDrops,
+        commandReorders: commandStats.reorders,
+        commandDeliveryDelaySamples: commandStats.deliveryDelaySamples,
+        commandRejected,
+        commandRejectionCounts: Object.fromEntries([...commandRejectionCounts.entries()].sort((left, right) => compareStrings(left[0], right[0]))),
+        commandDuplicateDrops,
+        commandRollbackConverged: commandTimelineConverged && commandDeliveries > 0,
+        commandRollbackObserved,
+        commandReplayChecksum: (0, canonical_js_1.defaultChecksum)({
+            authority: commandAuthorityChecksum,
+            client: commandClientChecksum,
+            delivered: commandDeliveries,
+            rollbackObserved: commandRollbackObserved,
+            rejected: commandRejected,
+            rejectionCounts: Object.fromEntries([...commandRejectionCounts.entries()].sort((left, right) => compareStrings(left[0], right[0]))),
+        }),
+        commandAuthorityChecksum,
+        commandClientChecksum,
+        spectatorReconstructions: spectatorReconstruction.reconstructions,
+        spectatorReconstructionChecksum: spectatorReconstruction.checksum,
+        spectatorInputFrames,
+        spectatorCommandRejected,
+        lateJoinReconstructions: lateJoinReconstruction.reconstructions,
+        lateJoinReconstructionChecksum: lateJoinReconstruction.checksum,
+        staleJoinRejected: lateJoinReconstruction.staleJoinRejected,
+        predictionPolicy,
+        predictedInputFrames,
+        neutralPredictions,
+        repeatLastPredictions,
+        repeatLastNonDefaultPredictions,
+        predictionFallbackChecksum: (0, canonical_js_1.defaultChecksum)(predictionFallbackSamples),
+        authorityChecksum,
+        clientChecksum,
+        result: didDesync ? 'desync' : 'pass',
+    };
+    function generateAuthorityFrame(frame) {
+        const frameInputs = Array.from({ length: options.players }, (_, slot) => {
+            if (botSlots.has(slot)) {
+                botInputFrames += 1;
+                return adapter.makeBotInput(options.seed, options.players, frame, slot);
+            }
+            if (isSpectatorSlotActive(options, frame, slot)) {
+                return adapter.defaultInput;
+            }
+            if (!isSlotPresent(options, frame, slot)) {
+                absentInputFrames += 1;
+                return adapter.defaultInput;
+            }
+            return adapter.makeInput(inputRandom, options.players, frame, slot);
+        });
+        truthInputs.push(frameInputs);
+        generateAuthorityCommands(frame);
+        stepSession(authority, frameInputs, authorityCommandsByFrame.get(frame) ?? []);
+        for (let slot = 0; slot < options.players; slot += 1) {
+            if (botSlots.has(slot)) {
+                continue;
+            }
+            if (isSpectatorSlotActive(options, frame, slot)) {
+                spectatorInputFrames += 1;
+                continue;
+            }
+            if (!isSlotPresent(options, frame, slot)) {
+                continue;
+            }
+            confirmations += 1;
+            if (slot === 0) {
+                localInputConfirmations += 1;
+            }
+            const pending = pendingBundles.get(slot) ?? { startFrame: frame, inputs: [] };
+            pending.inputs.push(maybeCorruptInput(options, adapter, frame, slot, frameInputs[slot]));
+            pendingBundles.set(slot, pending);
+            if (shouldFlushBundle(options, frame, bundleSizeFrames, pending.inputs.length)) {
+                network.send(frame, {
+                    startFrame: pending.startFrame,
+                    slot,
+                    inputs: pending.inputs.slice(),
+                });
+                pendingBundles.delete(slot);
+                bundledInputMessages += 1;
+            }
+        }
+    }
+    function processNetworkFrame(frame) {
+        const inputRollbackFrame = applyDeliveries(network.drain(frame));
+        const commandRollbackFrame = applyCommandDeliveries(commandNetwork.drain(frame), frame);
+        const rollbackFrame = minDefined(inputRollbackFrame, commandRollbackFrame);
+        if (rollbackFrame !== undefined) {
+            rollbackAndReplay(rollbackFrame);
+            adaptInputDelayAfterRollback(frame, rollbackFrame);
+        }
+        else {
+            adaptInputDelayAfterStableFrame();
+        }
+        confirmCompleteFrames();
+    }
+    function stepReadyClientFrames(networkFrame) {
+        while (nextClientFrameToStep < options.frames && nextClientFrameToStep <= networkFrame - inputDelayFrames) {
+            const predictedInputs = buildFrameInputs(nextClientFrameToStep);
+            inputHistory[nextClientFrameToStep] = predictedInputs;
+            stepSession(client, predictedInputs, clientCommandsByFrame.get(nextClientFrameToStep) ?? []);
+            nextClientFrameToStep += 1;
+        }
+    }
+    function applyDeliveries(messages) {
+        let rollbackFrame;
+        for (const message of messages) {
+            const frameInputs = confirmedInputs.get(message.frame) ?? new Map();
+            confirmedInputs.set(message.frame, frameInputs);
+            const existing = frameInputs.get(message.slot);
+            if (existing !== undefined && adapter.inputsEqual(existing, message.input)) {
+                continue;
+            }
+            frameInputs.set(message.slot, message.input);
+            network.cancel(message.frame, message.slot);
+            const historicalInput = inputHistory[message.frame]?.[message.slot];
+            const previousInput = 
+            /* istanbul ignore next -- rollback deliveries only target frames the client has already stepped. */
+            historicalInput ?? adapter.defaultInput;
+            if (message.frame < client.currentFrame &&
+                !adapter.inputsEqual(previousInput, message.input)) {
+                rollbackFrame = Math.min(rollbackFrame ?? message.frame, message.frame);
+                if (message.slot === 0) {
+                    localInputRollbacks += 1;
+                }
+            }
+        }
+        return rollbackFrame;
+    }
+    function applyCommandDeliveries(messages, deliveryFrame) {
+        let rollbackFrame;
+        for (const message of messages) {
+            const rejection = validateProtocolCommandEnvelope(message.input, deliveryFrame, options.players, acceptedClientCommandIds);
+            const effectiveRejection = isSpectatorSlotActive(options, deliveryFrame, message.input.senderSlot) ? 'spectator-command' : rejection;
+            if (effectiveRejection !== undefined) {
+                commandRejected += 1;
+                commandRejectionCounts.set(effectiveRejection, (commandRejectionCounts.get(effectiveRejection) ?? 0) + 1);
+                spectatorCommandRejected += effectiveRejection === 'spectator-command' ? 1 : 0;
+                commandDuplicateDrops += effectiveRejection === 'duplicate-command-id' ? 1 : 0;
+                continue;
+            }
+            const command = message.input.command;
+            commandDeliveries += 1;
+            acceptedClientCommandIds.add(command.id);
+            insertCommand(clientCommandsByFrame, command);
+            if (command.frame < client.currentFrame) {
+                rollbackFrame = Math.min(rollbackFrame ?? command.frame, command.frame);
+                commandRollbackFrame = Math.min(commandRollbackFrame ?? command.frame, command.frame);
+            }
+        }
+        return rollbackFrame;
+    }
+    function rollbackAndReplay(frame) {
+        const targetFrame = client.currentFrame;
+        const rollbackDepth = targetFrame - frame;
+        /* istanbul ignore next -- private callers only pass rollback frames strictly before client.currentFrame. */
+        if (rollbackDepth <= 0) {
+            return;
+        }
+        rollbacks += 1;
+        maxRollbackDepth = Math.max(maxRollbackDepth, rollbackDepth);
+        rollbackDepthSamples.push(rollbackDepth);
+        eventTracker.cancelFromFrame(frame);
+        client.restoreToFrame(frame);
+        for (let replayFrame = frame; replayFrame < targetFrame; replayFrame += 1) {
+            const replayInputs = buildFrameInputs(replayFrame);
+            inputHistory[replayFrame] = replayInputs;
+            stepSession(client, replayInputs, clientCommandsByFrame.get(replayFrame) ?? []);
+        }
+    }
+    function adaptInputDelayAfterRollback(networkFrame, rollbackFrame) {
+        if (!adaptiveInputDelay) {
+            return;
+        }
+        stableFramesSinceDelayAdjustment = 0;
+        const observedDepth = Math.max(0, networkFrame - rollbackFrame);
+        const targetDelay = Math.min(maxAdaptiveInputDelayFrames, Math.max(inputDelayFrames + 1, observedDepth));
+        if (targetDelay > inputDelayFrames) {
+            inputDelayFrames = targetDelay;
+            maxObservedInputDelayFrames = Math.max(maxObservedInputDelayFrames, inputDelayFrames);
+            inputDelayAdjustments += 1;
+        }
+    }
+    function adaptInputDelayAfterStableFrame() {
+        if (!adaptiveInputDelay || inputDelayFrames === 0) {
+            return;
+        }
+        stableFramesSinceDelayAdjustment += 1;
+        const stableWindow = Math.max(8, maxAdaptiveInputDelayFrames * 2);
+        if (stableFramesSinceDelayAdjustment >= stableWindow) {
+            inputDelayFrames -= 1;
+            inputDelayAdjustments += 1;
+            stableFramesSinceDelayAdjustment = 0;
+        }
+    }
+    function buildFrameInputs(frame) {
+        return Array.from({ length: options.players }, (_, slot) => {
+            if (botSlots.has(slot)) {
+                return truthInputs[frame][slot];
+            }
+            const confirmedInput = confirmedInputs.get(frame)?.get(slot);
+            if (confirmedInput !== undefined) {
+                return confirmedInput;
+            }
+            if (isSpectatorSlotActive(options, frame, slot)) {
+                return adapter.defaultInput;
+            }
+            if (isSlotPresent(options, frame, slot)) {
+                eventTracker.emitPredictedInput(frame, slot);
+            }
+            return predictedFallbackInput(frame, slot);
+        });
+    }
+    function predictedFallbackInput(frame, slot) {
+        predictedInputFrames += 1;
+        if (predictionPolicy === 'neutral') {
+            neutralPredictions += 1;
+            recordPredictionFallback(frame, slot, adapter.defaultInput);
+            return adapter.defaultInput;
+        }
+        const previous = previousKnownInput(frame, slot);
+        const input = previous ?? adapter.defaultInput;
+        repeatLastPredictions += previous === undefined ? 0 : 1;
+        repeatLastNonDefaultPredictions += previous !== undefined && !adapter.inputsEqual(previous, adapter.defaultInput) ? 1 : 0;
+        neutralPredictions += previous === undefined ? 1 : 0;
+        recordPredictionFallback(frame, slot, input);
+        return input;
+    }
+    function previousKnownInput(frame, slot) {
+        for (let previousFrame = frame - 1; previousFrame >= 0; previousFrame -= 1) {
+            const confirmed = confirmedInputs.get(previousFrame)?.get(slot);
+            if (confirmed !== undefined) {
+                return confirmed;
+            }
+            const predicted = inputHistory[previousFrame]?.[slot];
+            /* istanbul ignore next -- every prior stepped protocol frame stores a full per-slot input history row. */
+            if (predicted !== undefined) {
+                return predicted;
+            }
+        }
+        return undefined;
+    }
+    function recordPredictionFallback(frame, slot, input) {
+        if (predictionFallbackSamples.length < 256) {
+            predictionFallbackSamples.push({ frame, slot, policy: predictionPolicy, input });
+        }
+    }
+    function generateAuthorityCommands(frame) {
+        if (game !== 'command-bursts') {
+            return;
+        }
+        for (let slot = 1; slot < options.players; slot += 1) {
+            if (botSlots.has(slot) || isSpectatorSlotActive(options, frame, slot) || !isSlotPresent(options, frame, slot)) {
+                continue;
+            }
+            const command = makeProtocolCommand(options.seed, options.players, frame, slot);
+            if (command === undefined || command.frame >= options.frames) {
+                continue;
+            }
+            insertCommand(authorityCommandsByFrame, command);
+            commandNetwork.send(frame, {
+                startFrame: frame,
+                slot,
+                inputs: [{ senderSlot: slot, command }],
+            });
+            if ((frame + slot + options.seed) % 113 === 0) {
+                commandNetwork.send(frame, {
+                    startFrame: frame,
+                    slot,
+                    inputs: [{ senderSlot: slot, command }],
+                });
+            }
+        }
+        if (frame === Math.max(1, Math.floor(options.frames / 3))) {
+            for (const envelope of makeHostileProtocolCommandEnvelopes(options.players, frame)) {
+                commandNetwork.send(frame, {
+                    startFrame: frame,
+                    slot: Math.max(1, Math.min(options.players - 1, envelope.senderSlot)),
+                    inputs: [envelope],
+                });
+            }
+        }
+        if (options.spectatorSlot !== undefined &&
+            options.spectatorJoinFrame !== undefined &&
+            frame === Math.min(options.frames - 1, options.spectatorJoinFrame + 1)) {
+            commandNetwork.send(frame, {
+                startFrame: frame,
+                slot: options.spectatorSlot,
+                inputs: [makeSpectatorProtocolCommandEnvelope(options.spectatorSlot, frame)],
+            });
+        }
+    }
+    function confirmCompleteFrames() {
+        while (lastCompletelyConfirmedFrame + 1 < options.frames && isFrameComplete(lastCompletelyConfirmedFrame + 1)) {
+            lastCompletelyConfirmedFrame += 1;
+            eventTracker.confirmThroughFrame(lastCompletelyConfirmedFrame);
+        }
+    }
+    function isFrameComplete(frame) {
+        for (let slot = 0; slot < options.players; slot += 1) {
+            if (botSlots.has(slot) || !isSlotPresent(options, frame, slot)) {
+                continue;
+            }
+            if (!confirmedInputs.get(frame)?.has(slot)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function reconstructLateJoin() {
+        if (options.lateJoinFrame === undefined || options.lateJoinSlot === undefined || adapter.stepState === undefined) {
+            return { reconstructions: 0, checksum: (0, canonical_js_1.defaultChecksum)('late-join:not-run'), staleJoinRejected: false };
+        }
+        const snapshot = authority.getSnapshot(options.lateJoinFrame);
+        /* istanbul ignore next -- the fixture snapshot buffer retains every validated late-join frame. */
+        if (snapshot === undefined) {
+            return { reconstructions: 0, checksum: (0, canonical_js_1.defaultChecksum)('late-join:missing-snapshot'), staleJoinRejected: false };
+        }
+        let state = snapshot.state;
+        for (let frame = options.lateJoinFrame; frame < options.frames; frame += 1) {
+            state = adapter.stepState(state, truthInputs[frame], frame, authorityCommandsByFrame.get(frame) ?? []);
+        }
+        const checksum = (0, canonical_js_1.defaultChecksum)(state);
+        const staleSnapshot = options.lateJoinFrame > 0 ? authority.getSnapshot(options.lateJoinFrame - 1) : undefined;
+        const staleJoinRejected = staleSnapshot !== undefined && staleSnapshot.frame !== options.lateJoinFrame;
+        return {
+            reconstructions: Number(checksum === authorityChecksum),
+            checksum,
+            staleJoinRejected,
+        };
+    }
+    function reconstructSpectator() {
+        if (options.spectatorJoinFrame === undefined || options.spectatorSlot === undefined || adapter.stepState === undefined) {
+            return { reconstructions: 0, checksum: (0, canonical_js_1.defaultChecksum)('spectator:not-run') };
+        }
+        const snapshot = authority.getSnapshot(options.spectatorJoinFrame);
+        /* istanbul ignore next -- the fixture snapshot buffer retains every validated spectator join frame. */
+        if (snapshot === undefined) {
+            return { reconstructions: 0, checksum: (0, canonical_js_1.defaultChecksum)('spectator:missing-snapshot') };
+        }
+        let state = snapshot.state;
+        for (let frame = options.spectatorJoinFrame; frame < options.frames; frame += 1) {
+            state = adapter.stepState(state, truthInputs[frame], frame, authorityCommandsByFrame.get(frame) ?? []);
+        }
+        const checksum = (0, canonical_js_1.defaultChecksum)(state);
+        return {
+            reconstructions: Number(checksum === authorityChecksum),
+            checksum,
+        };
+    }
+}
+function createProtocolEventTracker(sampleLimit) {
+    if (!Number.isInteger(sampleLimit) || sampleLimit < 0) {
+        throw new Error('eventTimelineLimit must be a non-negative integer');
+    }
+    const activePredictions = new Map();
+    const sampledRecords = [];
+    let sequence = 0;
+    let totalRecords = 0;
+    let predicted = 0;
+    let confirmed = 0;
+    let canceled = 0;
+    return {
+        emitPredictedInput(frame, slot) {
+            const dedupeKey = `protocol.input.predicted:${frame}:${slot}`;
+            if (activePredictions.has(dedupeKey)) {
+                return;
+            }
+            const record = {
+                eventId: 'protocol.input.predicted',
+                frame,
+                sequence,
+                payload: {
+                    kind: 'input-prediction',
+                    frame,
+                    slot,
+                },
+                predictionState: 'predicted',
+                dedupeKey,
+            };
+            sequence += 1;
+            totalRecords += 1;
+            predicted += 1;
+            activePredictions.set(dedupeKey, record);
+            if (sampledRecords.length < sampleLimit) {
+                sampledRecords.push(record);
+            }
+        },
+        confirmThroughFrame(frame) {
+            for (const [dedupeKey, record] of activePredictions) {
+                if (record.frame > frame) {
+                    continue;
+                }
+                record.predictionState = 'confirmed';
+                activePredictions.delete(dedupeKey);
+                predicted -= 1;
+                confirmed += 1;
+            }
+        },
+        cancelFromFrame(frame) {
+            for (const [dedupeKey, record] of activePredictions) {
+                if (record.frame < frame) {
+                    continue;
+                }
+                record.predictionState = 'canceled';
+                activePredictions.delete(dedupeKey);
+                predicted -= 1;
+                canceled += 1;
+            }
+        },
+        summary() {
+            return {
+                totalRecords,
+                sampledRecords: sampledRecords.map(cloneProtocolEventRecord),
+                truncatedRecords: Math.max(0, totalRecords - sampledRecords.length),
+                predicted,
+                confirmed,
+                canceled,
+                verifiedOnly: 0,
+            };
+        },
+    };
+}
+function cloneProtocolEventRecord(record) {
+    return {
+        eventId: record.eventId,
+        frame: record.frame,
+        sequence: record.sequence,
+        payload: { ...record.payload },
+        predictionState: record.predictionState,
+        dedupeKey: record.dedupeKey,
+        notHashedKeys: [],
+    };
+}
+function isSlotPresent(options, frame, slot) {
+    if (isSpectatorSlot(options, slot)) {
+        return false;
+    }
+    return !(options.lateJoinSlot === slot && options.lateJoinFrame !== undefined && frame < options.lateJoinFrame);
+}
+function isSpectatorSlot(options, slot) {
+    return options.spectatorSlot === slot && options.spectatorJoinFrame !== undefined;
+}
+function isSpectatorSlotActive(options, frame, slot) {
+    return isSpectatorSlot(options, slot) && options.spectatorJoinFrame !== undefined && frame >= options.spectatorJoinFrame;
+}
+function shouldFlushBundle(options, frame, bundleSizeFrames, pendingInputs) {
+    if (pendingInputs >= bundleSizeFrames) {
+        return true;
+    }
+    return frame === options.frames - 1;
+}
+function maybeCorruptInput(options, adapter, frame, slot, input) {
+    if (options.desyncFrame === frame && options.desyncSlot === slot) {
+        return adapter.corruptInput(input);
+    }
+    return input;
+}
+function stepSession(session, inputs, commands) {
+    inputs.forEach((input, slot) => {
+        session.setInput(slot, input);
+    });
+    session.recordCommands(commands);
+    session.stepFrames(1);
+}
+const labAdapter = {
+    defaultInput: sample_lab_js_1.labDefaultInput,
+    createSession(players, seed, snapshotBufferSize) {
+        return (0, sample_lab_js_1.createLabSession)({
+            players,
+            seed,
+            replayRecordingMode: 'none',
+            snapshotBufferSize,
+        });
+    },
+    makeInput(random) {
+        return (0, sample_lab_js_1.makeLabInput)(random);
+    },
+    makeBotInput(seed, _players, frame, slot) {
+        const random = new random_js_1.DeterministicRandom(seed).fork(`bot:${slot}:${frame}`);
+        return (0, sample_lab_js_1.makeLabInput)(random);
+    },
+    corruptInput(input) {
+        return {
+            ...input,
+            dx: input.dx + 1,
+        };
+    },
+    inputsEqual(left, right) {
+        return left.dx === right.dx && left.dy === right.dy && left.action === right.action;
+    },
+    stepState(state, inputs, frame, commands) {
+        return (0, sample_lab_js_1.labStep)(state, inputs, frame, { frame, dtTicks: 1, commands: commands });
+    },
+};
+const counterDuelAdapter = {
+    defaultInput: counter_duel_js_1.counterDuelDefaultInput,
+    createSession(players, seed, snapshotBufferSize) {
+        return (0, counter_duel_js_1.createCounterDuelSession)(players, seed, {
+            replayRecordingMode: 'none',
+            snapshotBufferSize,
+        });
+    },
+    makeInput(random, players, _frame, slot) {
+        return (0, counter_duel_js_1.makeCounterDuelInput)(random, players, slot);
+    },
+    makeBotInput(seed, players, frame, slot) {
+        const random = new random_js_1.DeterministicRandom(seed).fork(`bot:${slot}:${frame}`);
+        return (0, counter_duel_js_1.makeCounterDuelInput)(random, players, slot);
+    },
+    corruptInput(input) {
+        return {
+            ...input,
+            attack: !input.attack,
+        };
+    },
+    inputsEqual(left, right) {
+        return left.attack === right.attack && left.targetSlot === right.targetSlot;
+    },
+};
+const moderateStateAdapter = {
+    defaultInput: sample_lab_js_1.labDefaultInput,
+    createSession(players, seed, snapshotBufferSize) {
+        return createModerateStateSession(players, seed, snapshotBufferSize, 'moderate-state@1');
+    },
+    makeInput(random) {
+        return (0, sample_lab_js_1.makeLabInput)(random);
+    },
+    makeBotInput(seed, _players, frame, slot) {
+        const random = new random_js_1.DeterministicRandom(seed).fork(`moderate-bot:${slot}:${frame}`);
+        return (0, sample_lab_js_1.makeLabInput)(random);
+    },
+    corruptInput(input) {
+        return {
+            ...input,
+            dx: input.dx + 1,
+        };
+    },
+    inputsEqual(left, right) {
+        return labInputsEqual(left, right);
+    },
+    stepState(state, inputs, frame, commands) {
+        return moderateStateStep(state, inputs, frame, { commands: commands });
+    },
+};
+const commandBurstsAdapter = {
+    ...moderateStateAdapter,
+    createSession(players, seed, snapshotBufferSize) {
+        return createModerateStateSession(players, seed, snapshotBufferSize, 'command-bursts@1');
+    },
+    makeInput(random, _players, frame) {
+        const input = (0, sample_lab_js_1.makeLabInput)(random);
+        return {
+            ...input,
+            action: frame % 45 < 5 ? 1 : input.action,
+        };
+    },
+    makeBotInput(seed, _players, frame, slot) {
+        const random = new random_js_1.DeterministicRandom(seed).fork(`command-burst-bot:${slot}:${frame}`);
+        const input = (0, sample_lab_js_1.makeLabInput)(random);
+        return {
+            ...input,
+            action: frame % 45 < 5 ? 1 : input.action,
+        };
+    },
+};
+function createModerateStateSession(players, seed, snapshotBufferSize, deterministicVersion) {
+    return (0, offline_session_js_1.createOfflineSession)({
+        tickRate: 30,
+        playerCount: players,
+        initialState: {
+            frame: 0,
+            positionX: Array.from({ length: players }, () => 0),
+            positionY: Array.from({ length: players }, () => 0),
+            velocityX: Array.from({ length: players }, () => 0),
+            velocityY: Array.from({ length: players }, () => 0),
+            health: Array.from({ length: players }, () => 10),
+            cooldown: Array.from({ length: players }, () => 0),
+            flags: Array.from({ length: players }, () => 0),
+        },
+        step: moderateStateStep,
+        defaultInput: sample_lab_js_1.labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'moderate-state/v1',
+        deterministicVersion,
+        randomSeed: seed,
+        snapshotBufferSize,
+        replayRecordingMode: 'none',
+        canonicalizeInput: (input) => [input.dx, input.dy, input.action],
+    });
+}
+function moderateStateStep(state, inputs, _frame, ctx) {
+    const positionX = state.positionX.slice();
+    const positionY = state.positionY.slice();
+    const velocityX = state.velocityX.slice();
+    const velocityY = state.velocityY.slice();
+    const health = state.health.slice();
+    const cooldown = state.cooldown.map((value) => Math.max(0, value - 1));
+    const flags = state.flags.slice();
+    for (let slot = 0; slot < inputs.length; slot += 1) {
+        const input = inputs[slot];
+        velocityX[slot] = clampInt(velocityX[slot] + input.dx, -4, 4);
+        velocityY[slot] = clampInt(velocityY[slot] + input.dy, -4, 4);
+        positionX[slot] += velocityX[slot];
+        positionY[slot] += velocityY[slot];
+        if (input.action === 1 && cooldown[slot] === 0) {
+            const target = (slot + 1) % inputs.length;
+            health[target] -= 1;
+            cooldown[slot] = 15;
+            flags[slot] = (flags[slot] ^ 1) & 3;
+            if (health[target] <= 0) {
+                health[target] = 10;
+                flags[target] = (flags[target] + 1) & 3;
+            }
+        }
+    }
+    for (const command of ctx.commands) {
+        if (!isProtocolCommand(command)) {
+            continue;
+        }
+        const protocolCommand = command;
+        if (protocolCommand.channelId !== 'ability') {
+            continue;
+        }
+        const slot = protocolCommand.slot;
+        if (slot < 0 || slot >= inputs.length) {
+            continue;
+        }
+        const payload = protocolCommand.payload;
+        const power = typeof payload.power === 'number' ? payload.power : 1;
+        const target = (slot + 1 + (power % Math.max(1, inputs.length - 1))) % inputs.length;
+        health[target] -= 1 + (power % 3);
+        flags[slot] = (flags[slot] + power + 1) & 7;
+        cooldown[slot] = Math.max(cooldown[slot], 4 + (power % 5));
+        if (health[target] <= 0) {
+            health[target] = 10;
+            flags[target] = (flags[target] + 2) & 7;
+        }
+    }
+    return {
+        frame: state.frame + 1,
+        positionX,
+        positionY,
+        velocityX,
+        velocityY,
+        health,
+        cooldown,
+        flags,
+    };
+}
+function clampInt(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function labInputsEqual(left, right) {
+    return left.dx === right.dx && left.dy === right.dy && left.action === right.action;
+}
+const protocolCommandChannels = [
+    { id: 'ability', reliable: true, allowPrediction: true, maxPayloadBytes: 128, maxFrameLead: 8 },
+];
+const protocolCommandChannelIds = new Set(protocolCommandChannels.map((channel) => channel.id));
+const protocolCommandAssetRefs = new Set(['ability.dash', 'ability.shield']);
+function makeProtocolCommand(seed, players, frame, slot) {
+    if ((seed + frame * 7 + slot * 13) % 19 !== 0) {
+        return undefined;
+    }
+    return {
+        id: `protocol:${slot}:${frame}:ability`,
+        slot,
+        frame: frame + 2 + ((slot + seed) % 3),
+        channelId: 'ability',
+        payload: {
+            assetRef: slot % 2 === 0 ? 'ability.dash' : 'ability.shield',
+            power: (slot + frame + players + seed) % 10,
+        },
+        predicted: true,
+        submittedFrame: frame,
+    };
+}
+function makeHostileProtocolCommandEnvelopes(players, frame) {
+    return [
+        {
+            senderSlot: 0,
+            command: {
+                id: 'hostile:bad-sender',
+                slot: Math.max(1, players - 1),
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: { assetRef: 'ability.dash' },
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: 1,
+            command: {
+                id: 'hostile:bad-asset',
+                slot: 1,
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: { assetRef: 'missing.asset' },
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: 1,
+            command: {
+                id: 'hostile:oversized',
+                slot: 1,
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: { assetRef: 'ability.dash', text: 'x'.repeat(180) },
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: 1,
+            command: {
+                id: 'hostile:bad-channel',
+                slot: 1,
+                frame: frame + 2,
+                channelId: 'missing',
+                payload: { assetRef: 'ability.dash' },
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: 0,
+            command: {
+                id: 'hostile:invalid-slot',
+                slot: 0,
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: { assetRef: 'ability.dash' },
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: 1,
+            command: {
+                id: 'hostile:stale',
+                slot: 1,
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: { assetRef: 'ability.dash' },
+                submittedFrame: frame + 3,
+            },
+        },
+        {
+            senderSlot: 1,
+            command: {
+                id: 'hostile:bad-schema',
+                slot: 1,
+                frame: frame + 2,
+                channelId: 'ability',
+                payload: null,
+                submittedFrame: frame,
+            },
+        },
+        {
+            senderSlot: Math.max(1, players - 1),
+            command: {
+                id: 'hostile:future',
+                slot: Math.max(1, players - 1),
+                frame: frame + 99,
+                channelId: 'ability',
+                payload: { assetRef: 'ability.shield' },
+                submittedFrame: frame,
+            },
+        },
+    ];
+}
+function makeSpectatorProtocolCommandEnvelope(slot, frame) {
+    return {
+        senderSlot: slot,
+        command: {
+            id: `spectator:${slot}:${frame}:ability`,
+            slot,
+            frame: frame + 1,
+            channelId: 'ability',
+            payload: { assetRef: 'ability.dash', power: 1 },
+            submittedFrame: frame,
+        },
+    };
+}
+function validateProtocolCommandEnvelope(envelope, deliveryFrame, players, acceptedIds) {
+    const command = envelope.command;
+    if (acceptedIds.has(command.id)) {
+        return 'duplicate-command-id';
+    }
+    if (!Number.isInteger(envelope.senderSlot) || envelope.senderSlot !== command.slot) {
+        return 'unauthorized-slot';
+    }
+    if (!Number.isInteger(command.slot) || command.slot < 1 || command.slot >= players) {
+        return 'unauthorized-slot';
+    }
+    if (!protocolCommandChannelIds.has(command.channelId)) {
+        return 'unknown-channel';
+    }
+    const submittedFrame = command.submittedFrame ?? command.frame;
+    if (command.frame < submittedFrame) {
+        return 'stale-frame';
+    }
+    if (command.frame > submittedFrame + 8 || command.frame > deliveryFrame + 128) {
+        return 'future-frame';
+    }
+    if (typeof command.payload !== 'object' || command.payload === null || Array.isArray(command.payload)) {
+        return 'bad-schema';
+    }
+    if ((0, canonical_js_1.canonicalStringify)(command.payload).length > 128) {
+        return 'oversized-payload';
+    }
+    const payload = command.payload;
+    const assetRef = payload.assetRef;
+    if (typeof assetRef !== 'string' || !protocolCommandAssetRefs.has(assetRef)) {
+        return 'bad-asset-ref';
+    }
+    return undefined;
+}
+function insertCommand(commandsByFrame, command) {
+    const frameCommands = commandsByFrame.get(command.frame) ?? [];
+    if (!frameCommands.some((existing) => existing.id === command.id)) {
+        frameCommands.push(command);
+        frameCommands.sort(compareProtocolCommands);
+        commandsByFrame.set(command.frame, frameCommands);
+    }
+}
+function normalizeCommandFrames(commandsByFrame) {
+    return [...commandsByFrame.entries()]
+        .sort((left, right) => left[0] - right[0])
+        .map(([frame, commands]) => ({ frame, commands: [...commands].sort(compareProtocolCommands) }));
+}
+function compareProtocolCommands(left, right) {
+    return left.frame - right.frame
+        || left.slot - right.slot
+        || left.channelId.localeCompare(right.channelId)
+        || left.id.localeCompare(right.id);
+}
+function minDefined(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    if (right === undefined) {
+        return left;
+    }
+    return Math.min(left, right);
+}
+function isProtocolCommand(command) {
+    if (typeof command !== 'object' || command === null || Array.isArray(command)) {
+        return false;
+    }
+    const record = command;
+    return typeof record.id === 'string'
+        && typeof record.slot === 'number'
+        && typeof record.frame === 'number'
+        && typeof record.channelId === 'string'
+        && typeof record.payload === 'object'
+        && record.payload !== null
+        && !Array.isArray(record.payload);
+}
+function validateOptions(options) {
+    if (options.game !== undefined &&
+        options.game !== 'lab' &&
+        options.game !== 'counter-duel' &&
+        options.game !== 'moderate-state' &&
+        options.game !== 'command-bursts') {
+        throw new Error('protocol rollback lab game must be lab, counter-duel, moderate-state, or command-bursts');
+    }
+    if (!Number.isInteger(options.players) || options.players < 2 || options.players > 128) {
+        throw new Error('protocol rollback lab requires players between 2 and 128');
+    }
+    if (!Number.isInteger(options.frames) || options.frames < 1) {
+        throw new Error('protocol rollback lab requires at least one frame');
+    }
+    if (!Number.isInteger(options.minDelayFrames) ||
+        !Number.isInteger(options.maxDelayFrames) ||
+        options.minDelayFrames < 0 ||
+        options.maxDelayFrames < options.minDelayFrames) {
+        throw new Error('protocol rollback lab delay bounds are invalid');
+    }
+    if (options.bundleSizeFrames !== undefined && (!Number.isInteger(options.bundleSizeFrames) || options.bundleSizeFrames < 1)) {
+        throw new Error('bundleSizeFrames must be a positive integer');
+    }
+    if (options.inputDelayFrames !== undefined && (!Number.isInteger(options.inputDelayFrames) || options.inputDelayFrames < 0)) {
+        throw new Error('inputDelayFrames must be a non-negative integer');
+    }
+    if (options.adaptiveInputDelay !== undefined && typeof options.adaptiveInputDelay !== 'boolean') {
+        throw new Error('adaptiveInputDelay must be boolean');
+    }
+    if (options.maxAdaptiveInputDelayFrames !== undefined &&
+        (!Number.isInteger(options.maxAdaptiveInputDelayFrames) || options.maxAdaptiveInputDelayFrames < 0)) {
+        throw new Error('maxAdaptiveInputDelayFrames must be a non-negative integer');
+    }
+    if (options.predictionPolicy !== undefined &&
+        options.predictionPolicy !== 'repeat-last' &&
+        options.predictionPolicy !== 'neutral') {
+        throw new Error('predictionPolicy must be repeat-last or neutral');
+    }
+    if (options.duplicatePermille !== undefined &&
+        (!Number.isInteger(options.duplicatePermille) || options.duplicatePermille < 0 || options.duplicatePermille > 1000)) {
+        throw new Error('duplicatePermille must be an integer between 0 and 1000');
+    }
+    if (options.lossPermille !== undefined && (!Number.isInteger(options.lossPermille) || options.lossPermille < 0 || options.lossPermille > 1000)) {
+        throw new Error('lossPermille must be an integer between 0 and 1000');
+    }
+    if (options.resendIntervalFrames !== undefined &&
+        (!Number.isInteger(options.resendIntervalFrames) || options.resendIntervalFrames < 1)) {
+        throw new Error('resendIntervalFrames must be a positive integer');
+    }
+    if (options.maxResendAttempts !== undefined && (!Number.isInteger(options.maxResendAttempts) || options.maxResendAttempts < 1)) {
+        throw new Error('maxResendAttempts must be a positive integer');
+    }
+    const hasDisconnectStart = options.disconnectStartFrame !== undefined;
+    const hasDisconnectEnd = options.disconnectEndFrame !== undefined;
+    if (hasDisconnectStart !== hasDisconnectEnd) {
+        throw new Error('disconnect frame range is invalid');
+    }
+    if (hasDisconnectStart &&
+        hasDisconnectEnd &&
+        (!Number.isInteger(options.disconnectStartFrame) ||
+            !Number.isInteger(options.disconnectEndFrame) ||
+            options.disconnectStartFrame < 0 ||
+            options.disconnectEndFrame < options.disconnectStartFrame)) {
+        throw new Error('disconnect frame range is invalid');
+    }
+    if (options.desyncFrame !== undefined && (!Number.isInteger(options.desyncFrame) || options.desyncFrame < 0 || options.desyncFrame >= options.frames)) {
+        throw new Error('desyncFrame must be within the simulated frame range');
+    }
+    if (options.desyncSlot !== undefined && (!Number.isInteger(options.desyncSlot) || options.desyncSlot < 1 || options.desyncSlot >= options.players)) {
+        throw new Error('desyncSlot must be a remote player slot within range');
+    }
+    if ((options.desyncFrame === undefined) !== (options.desyncSlot === undefined)) {
+        throw new Error('desyncFrame and desyncSlot must be provided together');
+    }
+    if ((options.lateJoinSlot === undefined) !== (options.lateJoinFrame === undefined)) {
+        throw new Error('lateJoinSlot and lateJoinFrame must be provided together');
+    }
+    if (options.lateJoinSlot !== undefined &&
+        (!Number.isInteger(options.lateJoinSlot) || options.lateJoinSlot < 1 || options.lateJoinSlot >= options.players)) {
+        throw new Error('lateJoinSlot must be a remote player slot within range');
+    }
+    if (options.lateJoinFrame !== undefined &&
+        (!Number.isInteger(options.lateJoinFrame) || options.lateJoinFrame < 0 || options.lateJoinFrame >= options.frames)) {
+        throw new Error('lateJoinFrame must be within the simulated frame range');
+    }
+    if ((options.spectatorSlot === undefined) !== (options.spectatorJoinFrame === undefined)) {
+        throw new Error('spectatorSlot and spectatorJoinFrame must be provided together');
+    }
+    if (options.spectatorSlot !== undefined &&
+        (!Number.isInteger(options.spectatorSlot) || options.spectatorSlot < 1 || options.spectatorSlot >= options.players)) {
+        throw new Error('spectatorSlot must be a remote player slot within range');
+    }
+    if (options.spectatorJoinFrame !== undefined &&
+        (!Number.isInteger(options.spectatorJoinFrame) || options.spectatorJoinFrame < 0 || options.spectatorJoinFrame >= options.frames)) {
+        throw new Error('spectatorJoinFrame must be within the simulated frame range');
+    }
+    if ((options.latencySkewSlot === undefined) !== (options.latencySkewFrames === undefined)) {
+        throw new Error('latencySkewSlot and latencySkewFrames must be provided together');
+    }
+    if (options.latencySkewSlot !== undefined &&
+        (!Number.isInteger(options.latencySkewSlot) || options.latencySkewSlot < 1 || options.latencySkewSlot >= options.players)) {
+        throw new Error('latencySkewSlot must be a remote player slot within range');
+    }
+    if (options.latencySkewFrames !== undefined &&
+        (!Number.isInteger(options.latencySkewFrames) || options.latencySkewFrames < 0)) {
+        throw new Error('latencySkewFrames must be a non-negative integer');
+    }
+    if (options.botSlots !== undefined) {
+        const seen = new Set();
+        for (const slot of options.botSlots) {
+            if (!Number.isInteger(slot) || slot < 1 || slot >= options.players) {
+                throw new Error('botSlots must contain remote player slots within range');
+            }
+            if (seen.has(slot)) {
+                throw new Error('botSlots cannot contain duplicates');
+            }
+            seen.add(slot);
+        }
+    }
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function runProtocolLabInternalCoverageProbe() {
+    const tracker = createProtocolEventTracker(4);
+    tracker.emitPredictedInput(2, 1);
+    tracker.emitPredictedInput(2, 1);
+    const eventSummary = tracker.summary();
+    const state = {
+        frame: 0,
+        positionX: [0, 0],
+        positionY: [0, 0],
+        velocityX: [0, 0],
+        velocityY: [0, 0],
+        health: [10, 2],
+        cooldown: [0, 0],
+        flags: [0, 0],
+    };
+    const next = moderateStateStep(state, [sample_lab_js_1.labDefaultInput, sample_lab_js_1.labDefaultInput], 0, {
+        commands: [
+            null,
+            { id: 'wrong-channel', slot: 0, frame: 0, channelId: 'other', payload: {} },
+            { id: 'bad-slot', slot: 3, frame: 0, channelId: 'ability', payload: {} },
+            { id: 'default-power', slot: 0, frame: 0, channelId: 'ability', payload: {} },
+        ],
+    });
+    const commands = [
+        { id: 'b', slot: 1, frame: 2, channelId: 'ability', payload: {}, submittedFrame: 0 },
+        { id: 'a', slot: 1, frame: 2, channelId: 'ability', payload: {}, submittedFrame: 0 },
+        { id: 'c', slot: 0, frame: 2, channelId: 'ability', payload: {}, submittedFrame: 0 },
+        { id: 'd', slot: 0, frame: 1, channelId: 'ability', payload: {}, submittedFrame: 0 },
+    ];
+    const commandsByFrame = new Map();
+    insertCommand(commandsByFrame, commands[0]);
+    insertCommand(commandsByFrame, commands[1]);
+    insertCommand(commandsByFrame, commands[2]);
+    insertCommand(commandsByFrame, commands[3]);
+    insertCommand(commandsByFrame, commands[1]);
+    const validationReasons = [
+        validateProtocolCommandEnvelope({
+            senderSlot: 0,
+            command: { id: 'invalid-slot', slot: 0, frame: 2, channelId: 'ability', payload: { assetRef: 'ability.dash' }, submittedFrame: 0 },
+        }, 2, 2, new Set()),
+        validateProtocolCommandEnvelope({
+            senderSlot: 1,
+            command: { id: 'stale', slot: 1, frame: 2, channelId: 'ability', payload: { assetRef: 'ability.dash' }, submittedFrame: 3 },
+        }, 2, 2, new Set()),
+        validateProtocolCommandEnvelope({
+            senderSlot: 1,
+            command: { id: 'bad-schema', slot: 1, frame: 2, channelId: 'ability', payload: null, submittedFrame: 0 },
+        }, 2, 2, new Set()),
+        validateProtocolCommandEnvelope({
+            senderSlot: 1,
+            command: { id: 'valid-with-default-submitted', slot: 1, frame: 2, channelId: 'ability', payload: { assetRef: 'ability.dash' } },
+        }, 2, 2, new Set()),
+    ];
+    return {
+        eventPredicted: eventSummary.predicted,
+        eventSampled: eventSummary.sampledRecords.length,
+        invalidCommandFrame: next.frame,
+        defaultPowerHealth: next.health[1],
+        validationReasons,
+        normalizedCommandIds: normalizeCommandFrames(commandsByFrame).flatMap((entry) => entry.commands.map((command) => command.id)),
+        sortedComparison: [
+            compareProtocolCommands(commands[0], commands[1]),
+            compareProtocolCommands(commands[0], commands[2]),
+            compareProtocolCommands(commands[0], commands[3]),
+            compareStrings('z', 'a'),
+            compareStrings('a', 'a'),
+        ],
+    };
+}