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

package/dist/cjs/deterministic-session.js

@@ -0,0 +1,1410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicSessionCore = createDeterministicSessionCore;
+exports.createDeterministicSessionReplayBundle = createDeterministicSessionReplayBundle;
+exports.verifyDeterministicSessionRuntimeReplay = verifyDeterministicSessionRuntimeReplay;
+exports.runDeterministicSessionCoreFixture = runDeterministicSessionCoreFixture;
+exports.runDeterministicStructuredSessionInputFixture = runDeterministicStructuredSessionInputFixture;
+exports.runDeterministicSessionAuthorityFixture = runDeterministicSessionAuthorityFixture;
+exports.runDeterministicSessionLifecycleProtocolFixture = runDeterministicSessionLifecycleProtocolFixture;
+const canonical_js_1 = require("./canonical.js");
+const commands_js_1 = require("./commands.js");
+const engine_runtime_js_1 = require("./engine-runtime.js");
+const random_js_1 = require("./random.js");
+function createDeterministicSessionCore(options) {
+    assertPositiveInteger(options.players, 'players');
+    if (options.reconnectGraceFrames !== undefined) {
+        assertNonNegativeInteger(options.reconnectGraceFrames, 'reconnectGraceFrames');
+    }
+    const seed = options.seed ?? 1;
+    const inputSingletonId = options.inputSingletonId ?? 'sessionInput';
+    const mapInputsToSingleton = options.mapInputsToSingleton ?? defaultInputSingletonMapper;
+    const commandChannels = options.commandChannels ?? options.descriptor.commandChannels ?? [];
+    const commandTimelineOptions = {
+        playerCount: options.players,
+        currentFrame: 0,
+        channels: commandChannels,
+        validAssetRefs: options.validCommandAssetRefs,
+        validatePayload: options.validateCommandPayload,
+    };
+    const verifiedCommandTimeline = commandChannels.length === 0 ? undefined : (0, commands_js_1.createDeterministicCommandTimeline)(commandTimelineOptions);
+    const predictedCommandTimeline = commandChannels.length === 0 ? undefined : (0, commands_js_1.createDeterministicCommandTimeline)(commandTimelineOptions);
+    const verified = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(options.descriptor, seed, { commandTimeline: verifiedCommandTimeline });
+    const predicted = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(options.descriptor, seed, { commandTimeline: predictedCommandTimeline });
+    const confirmedInputs = new Map();
+    const predictedInputs = new Map();
+    const replacementInputs = new Map();
+    const confirmedCommands = new Map();
+    const predictedCommands = new Map();
+    const confirmedCommandsByFrame = new Map();
+    const predictedCommandsByFrame = new Map();
+    const rejectedCommands = [];
+    const lifecycleEvents = [];
+    const players = Array.from({ length: options.players }, (_, slot) => ({
+        slot,
+        actorId: '',
+        active: false,
+        spectator: true,
+        joinedFrame: 0,
+    }));
+    let predictedPreviousFrame;
+    let correctionCount = 0;
+    let replacementInputCount = 0;
+    const verifiedChecksumHistory = new Map();
+    function acceptedLifecycleEvent(type, slot, actorId, frame) {
+        return { type, slot, actorId, frame, accepted: true };
+    }
+    function rejectedLifecycleEvent(type, slot, actorId, frame, reason) {
+        return { type, slot, actorId, frame, accepted: false, reason };
+    }
+    function applyLifecycle(event) {
+        lifecycleEvents.push((0, canonical_js_1.cloneCanonical)(event));
+        if (!event.accepted) {
+            return;
+        }
+        const existing = players[event.slot];
+        if (event.type === 'join-spectator') {
+            players[event.slot] = { ...existing, actorId: event.actorId, spectator: true, active: false, joinedFrame: event.frame, removedFrame: undefined };
+        }
+        if (event.type === 'add-player') {
+            players[event.slot] = { ...existing, actorId: event.actorId, spectator: false, active: true, joinedFrame: event.frame, removedFrame: undefined };
+        }
+        if (event.type === 'remove-player') {
+            players[event.slot] = { ...existing, active: false, spectator: true, removedFrame: event.frame };
+        }
+    }
+    function stepRuntime(runtime, frame, inputs, usePrediction) {
+        const commands = commandsForFrame(frame, usePrediction);
+        syncRuntimeCommandTimeline(runtime === verified ? verifiedCommandTimeline : predictedCommandTimeline, frame, commands);
+        runtime.setSingleton(inputSingletonId, mapInputsToSingleton(frame, inputs, playersForFrame(frame), commands));
+        runtime.step(options.systems);
+    }
+    function inputsForFrame(frame, usePrediction) {
+        return playersForFrame(frame)
+            .filter((player) => playerAcceptsInputAtFrame(player, frame))
+            .map((player) => inputForPlayerFrame(frame, player.slot, usePrediction))
+            .sort(compareInputs);
+    }
+    function playersForFrame(frame) {
+        const effective = Array.from({ length: options.players }, (_, slot) => ({
+            slot,
+            actorId: '',
+            active: false,
+            spectator: true,
+            joinedFrame: 0,
+        }));
+        for (const event of lifecycleEvents.filter((candidate) => candidate.accepted && candidate.frame <= frame).sort(compareLifecycleEvents)) {
+            const current = effective[event.slot];
+            if (event.type === 'join-spectator') {
+                effective[event.slot] = { ...current, actorId: event.actorId, spectator: true, active: false, joinedFrame: event.frame, removedFrame: undefined };
+            }
+            if (event.type === 'add-player') {
+                effective[event.slot] = { ...current, actorId: event.actorId, spectator: false, active: true, joinedFrame: event.frame, removedFrame: undefined };
+            }
+            if (event.type === 'remove-player') {
+                effective[event.slot] = { ...current, active: false, spectator: true, removedFrame: event.frame };
+            }
+        }
+        return effective;
+    }
+    function playerAcceptsInputAtFrame(player, frame) {
+        return player.active
+            && !player.spectator
+            && player.joinedFrame <= frame;
+    }
+    function inputForPlayerFrame(frame, slot, usePrediction) {
+        const confirmed = confirmedInputs.get(inputKey(frame, slot));
+        if (confirmed !== undefined) {
+            return confirmed;
+        }
+        if (usePrediction) {
+            const predictedInput = predictedInputs.get(inputKey(frame, slot));
+            if (predictedInput !== undefined) {
+                return predictedInput;
+            }
+            return predictedFallbackInput(frame, slot);
+        }
+        const replacement = replacementInputs.get(inputKey(frame, slot));
+        if (replacement !== undefined) {
+            return replacement;
+        }
+        throw new Error(`Cannot verify deterministic frame ${frame}; missing confirmed input for slot ${slot}`);
+    }
+    function predictedFallbackInput(frame, slot) {
+        const previous = previousRepeatableInput(frame, slot);
+        const flags = [];
+        if (previous.repeated) {
+            flags.push('repeatable');
+        }
+        return normalizeInput({ frame, slot, value: previous.value, data: previous.data, flags });
+    }
+    function storeReplacementInput(input) {
+        assertInput(input);
+        const playerActive = playerAcceptsInputAtFrame(playersForFrame(input.frame)[input.slot], input.frame);
+        const flags = new Set(input.flags ?? []);
+        if (playerActive) {
+            flags.delete('player-not-present');
+            flags.add('replaced-by-server');
+        }
+        else if (!flags.has('player-not-present')) {
+            throw new Error(`Cannot replace input for inactive deterministic slot ${input.slot} at frame ${input.frame}`);
+        }
+        else {
+            flags.delete('replaced-by-server');
+        }
+        const normalized = normalizeInput({ ...input, flags: [...flags] });
+        const key = inputKey(input.frame, input.slot);
+        const hadReplacement = replacementInputs.has(key);
+        replacementInputs.set(key, normalized);
+        if (!hadReplacement) {
+            replacementInputCount += 1;
+        }
+    }
+    function previousRepeatableInput(frame, slot) {
+        for (let previousFrame = frame - 1; previousFrame >= 0; previousFrame -= 1) {
+            const previous = confirmedInputs.get(inputKey(previousFrame, slot)) ?? predictedInputs.get(inputKey(previousFrame, slot));
+            if (previous !== undefined && previous.flags.includes('repeatable')) {
+                return { value: previous.value, data: previous.data, repeated: true };
+            }
+        }
+        return { value: 0, repeated: false };
+    }
+    function assertInput(input) {
+        assertNonNegativeInteger(input.frame, 'input.frame');
+        assertSlot(input.slot, options.players);
+        if (!Number.isInteger(input.value)) {
+            throw new Error('Deterministic session input value must be an integer');
+        }
+        if (input.data !== undefined) {
+            (0, canonical_js_1.canonicalStringify)(input.data);
+            if (options.inputDataFields !== undefined) {
+                (0, commands_js_1.assertDeterministicPayloadFields)('input.data', input.data, options.inputDataFields);
+            }
+        }
+        else if (options.inputDataFields !== undefined) {
+            throw new Error('input.data is missing');
+        }
+        for (const flag of input.flags ?? []) {
+            assertInputFlag(flag);
+        }
+    }
+    function recordSessionCommand(timeline, commands, command) {
+        if (timeline === undefined) {
+            throw new Error('Deterministic session command channels are not configured');
+        }
+        const submittedFrame = command.submittedFrame ?? command.frame;
+        if (!Number.isInteger(command.slot) || command.slot < 0 || command.slot >= options.players) {
+            const rejection = { commandId: command.id, reason: 'unauthorized-slot' };
+            rejectedCommands.push(rejection);
+            return rejection;
+        }
+        if (!playerAcceptsInputAtFrame(playersForFrame(command.frame)[command.slot], command.frame)) {
+            const rejection = { commandId: command.id, reason: 'unauthorized-slot' };
+            rejectedCommands.push(rejection);
+            return rejection;
+        }
+        if (submittedFrame >= timeline.currentFrame) {
+            timeline.setCurrentFrame(submittedFrame);
+        }
+        const rejection = timeline.record(command);
+        if (rejection !== undefined) {
+            rejectedCommands.push(rejection);
+            return rejection;
+        }
+        const accepted = timeline.accepted.find((candidate) => candidate.id === command.id);
+        commands.set(accepted.id, accepted);
+        addCommandToFrameIndex(commands === confirmedCommands ? confirmedCommandsByFrame : predictedCommandsByFrame, accepted);
+        if (commands === confirmedCommands) {
+            predictedCommands.delete(accepted.id);
+            removeCommandFromFrameIndex(predictedCommandsByFrame, accepted.id);
+        }
+        return undefined;
+    }
+    function commandsForFrame(frame, usePrediction) {
+        const commands = new Map();
+        for (const command of confirmedCommandsByFrame.get(frame) ?? []) {
+            commands.set(command.id, command);
+        }
+        if (usePrediction) {
+            for (const command of predictedCommandsByFrame.get(frame) ?? []) {
+                if (!commands.has(command.id)) {
+                    commands.set(command.id, command);
+                }
+            }
+        }
+        return [...commands.values()].sort(compareCommands);
+    }
+    function syncRuntimeCommandTimeline(timeline, frame, commands) {
+        if (timeline === undefined) {
+            return;
+        }
+        timeline.restore((0, commands_js_1.createDeterministicCommandTimelineSnapshot)({
+            currentFrame: frame,
+            accepted: commands,
+            rejected: [],
+        }));
+    }
+    const session = {
+        get players() {
+            return players.map((player) => (0, canonical_js_1.cloneCanonical)(player));
+        },
+        get frameVerified() {
+            return verified.snapshot();
+        },
+        get framePredicted() {
+            return predicted.snapshot();
+        },
+        get framePredictedPrevious() {
+            return predictedPreviousFrame === undefined ? undefined : (0, canonical_js_1.cloneCanonical)(predictedPreviousFrame);
+        },
+        get correctionCount() {
+            return correctionCount;
+        },
+        get replacementInputCount() {
+            return replacementInputCount;
+        },
+        joinAsSpectator(slot, actorId, frame = verified.frame) {
+            assertSlot(slot, options.players);
+            assertNonEmptyActor(actorId);
+            const current = players[slot];
+            const event = current.actorId.length > 0 && current.actorId !== actorId
+                ? rejectedLifecycleEvent('join-spectator', slot, actorId, frame, 'slot-already-owned')
+                : acceptedLifecycleEvent('join-spectator', slot, actorId, frame);
+            applyLifecycle(event);
+            return (0, canonical_js_1.cloneCanonical)(event);
+        },
+        addPlayer(slot, actorId, frame = verified.frame) {
+            assertSlot(slot, options.players);
+            assertNonEmptyActor(actorId);
+            const current = players[slot];
+            const event = current.active
+                ? rejectedLifecycleEvent('add-player', slot, actorId, frame, 'slot-already-active')
+                : current.actorId.length > 0 && current.actorId !== actorId
+                    ? rejectedLifecycleEvent('add-player', slot, actorId, frame, 'actor-mismatch')
+                    : current.actorId === actorId
+                        && current.removedFrame !== undefined
+                        && options.reconnectGraceFrames !== undefined
+                        && frame - current.removedFrame > options.reconnectGraceFrames
+                        ? rejectedLifecycleEvent('add-player', slot, actorId, frame, 'reconnect-expired')
+                        : acceptedLifecycleEvent('add-player', slot, actorId, frame);
+            applyLifecycle(event);
+            return (0, canonical_js_1.cloneCanonical)(event);
+        },
+        removePlayer(slot, actorId, frame = verified.frame) {
+            assertSlot(slot, options.players);
+            assertNonEmptyActor(actorId);
+            const current = players[slot];
+            const event = !current.active
+                ? rejectedLifecycleEvent('remove-player', slot, actorId, frame, 'slot-not-active')
+                : current.actorId !== actorId
+                    ? rejectedLifecycleEvent('remove-player', slot, actorId, frame, 'actor-mismatch')
+                    : acceptedLifecycleEvent('remove-player', slot, actorId, frame);
+            applyLifecycle(event);
+            return (0, canonical_js_1.cloneCanonical)(event);
+        },
+        submitPredictedInput(input) {
+            assertInput(input);
+            if (!playerAcceptsInputAtFrame(playersForFrame(input.frame)[input.slot], input.frame)) {
+                throw new Error(`Cannot predict input for inactive deterministic slot ${input.slot} at frame ${input.frame}`);
+            }
+            predictedInputs.set(inputKey(input.frame, input.slot), normalizeInput(input));
+        },
+        confirmInput(input) {
+            assertInput(input);
+            if (!playerAcceptsInputAtFrame(playersForFrame(input.frame)[input.slot], input.frame)) {
+                throw new Error(`Cannot confirm input for inactive deterministic slot ${input.slot} at frame ${input.frame}`);
+            }
+            confirmedInputs.set(inputKey(input.frame, input.slot), normalizeInput(input));
+        },
+        replaceInput(input) {
+            storeReplacementInput(input);
+        },
+        submitPredictedCommand(command) {
+            return recordSessionCommand(predictedCommandTimeline, predictedCommands, { ...command, predicted: command.predicted ?? true });
+        },
+        confirmCommand(command) {
+            return recordSessionCommand(verifiedCommandTimeline, confirmedCommands, { ...command, predicted: false });
+        },
+        pollCommands(frame, slot, channelId) {
+            assertNonNegativeInteger(frame, 'frame');
+            return commandsForFrame(frame, true)
+                .filter((command) => slot === undefined || command.slot === slot)
+                .filter((command) => channelId === undefined || command.channelId === channelId)
+                .sort(compareCommands)
+                .map((command) => (0, canonical_js_1.cloneCanonical)(command));
+        },
+        predictTo(frameExclusive) {
+            assertNonNegativeInteger(frameExclusive, 'frameExclusive');
+            if (frameExclusive < verified.frame) {
+                throw new Error(`Cannot predict behind verified frame ${verified.frame}`);
+            }
+            predictedPreviousFrame = predicted.snapshot();
+            predicted.restore(verified.snapshot());
+            for (let frame = verified.frame; frame < frameExclusive; frame += 1) {
+                stepRuntime(predicted, frame, inputsForFrame(frame, true), true);
+            }
+        },
+        advanceVerifiedTo(frameExclusive) {
+            assertNonNegativeInteger(frameExclusive, 'frameExclusive');
+            if (frameExclusive < verified.frame) {
+                throw new Error(`Cannot move verified frame backward from ${verified.frame} to ${frameExclusive}`);
+            }
+            for (let frame = verified.frame; frame < frameExclusive; frame += 1) {
+                stepRuntime(verified, frame, inputsForFrame(frame, false), false);
+                const snapshot = verified.snapshot();
+                verifiedChecksumHistory.set(snapshot.frame, snapshot.checksum);
+            }
+        },
+        applyCorrection(snapshot) {
+            if (snapshot.frame < verified.frame) {
+                return false;
+            }
+            verified.restore(snapshot);
+            correctionCount += 1;
+            return true;
+        },
+        isFrameVerified(frame) {
+            assertNonNegativeInteger(frame, 'frame');
+            return frame < verified.frame;
+        },
+        getInputFlags(frame, slot) {
+            assertNonNegativeInteger(frame, 'frame');
+            assertSlot(slot, options.players);
+            if (!session.isFrameVerified(frame)) {
+                return [];
+            }
+            const input = confirmedInputs.get(inputKey(frame, slot))
+                ?? replacementInputs.get(inputKey(frame, slot));
+            return input === undefined ? [] : [...input.flags].sort(compareStrings);
+        },
+        snapshot() {
+            const withoutChecksum = {
+                verifiedFrame: verified.snapshot(),
+                predictedFrame: predicted.snapshot(),
+                predictedPreviousFrame,
+                players,
+                confirmedInputs: sortedInputValues(confirmedInputs),
+                predictedInputs: sortedInputValues(predictedInputs),
+                replacementInputs: sortedInputValues(replacementInputs),
+                confirmedCommands: sortedCommandValues(confirmedCommands),
+                predictedCommands: sortedCommandValues(predictedCommands),
+                rejectedCommands: [...rejectedCommands].sort(compareRejectedCommands),
+                lifecycleEvents,
+                correctionCount,
+                replacementInputCount,
+            };
+            return (0, canonical_js_1.cloneCanonical)({ ...withoutChecksum, checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum) });
+        },
+        exportReplay() {
+            return createDeterministicSessionReplayBundle({
+                descriptorHash: (0, canonical_js_1.defaultChecksum)(options.descriptor),
+                runtimeVersion: 'deterministic-session@1',
+                players: options.players,
+                seed,
+                inputSingletonId,
+                confirmedInputs: sortedInputValues(confirmedInputs),
+                replacementInputs: sortedInputValues(replacementInputs),
+                confirmedCommands: sortedCommandValues(confirmedCommands),
+                lifecycleEvents,
+                verifiedChecksums: sortedVerifiedChecksums(verifiedChecksumHistory, verified.snapshot()),
+                finalVerifiedChecksum: verified.snapshot().checksum,
+            });
+        },
+    };
+    return session;
+}
+function createDeterministicSessionReplayBundle(bundle) {
+    const normalized = normalizedSessionReplayBundleForChecksum({
+        schemaVersion: 1,
+        ...bundle,
+    });
+    return (0, canonical_js_1.cloneCanonical)({ ...normalized, checksum: (0, canonical_js_1.defaultChecksum)(normalized) });
+}
+function verifyDeterministicSessionRuntimeReplay(bundle, options) {
+    const expectedReplayChecksum = (0, canonical_js_1.defaultChecksum)(normalizedSessionReplayBundleForChecksum(bundle));
+    if (bundle.checksum !== expectedReplayChecksum) {
+        return replayVerification('fail', bundle, expectedReplayChecksum, bundle.verifiedChecksums.length, 0);
+    }
+    if (bundle.schemaVersion !== 1 || bundle.descriptorHash !== (0, canonical_js_1.defaultChecksum)(options.descriptor)) {
+        return replayVerification('fail', bundle, '', 0, 0);
+    }
+    const replay = createDeterministicSessionCore({ ...options, seed: bundle.seed, inputSingletonId: bundle.inputSingletonId });
+    const confirmedInputsByFrame = new Map();
+    for (const input of bundle.confirmedInputs) {
+        const entries = confirmedInputsByFrame.get(input.frame) ?? [];
+        entries.push(input);
+        confirmedInputsByFrame.set(input.frame, entries);
+    }
+    const confirmedInputKeys = new Set(bundle.confirmedInputs.map((input) => inputKey(input.frame, input.slot)));
+    const replacementInputsByFrame = new Map();
+    for (const input of bundle.replacementInputs) {
+        if (confirmedInputKeys.has(inputKey(input.frame, input.slot))) {
+            continue;
+        }
+        const entries = replacementInputsByFrame.get(input.frame) ?? [];
+        entries.push(input);
+        replacementInputsByFrame.set(input.frame, entries);
+    }
+    const lifecycleByFrame = new Map();
+    for (const event of bundle.lifecycleEvents) {
+        const entries = lifecycleByFrame.get(event.frame) ?? [];
+        entries.push(event);
+        lifecycleByFrame.set(event.frame, entries);
+    }
+    const commandsByFrame = new Map();
+    for (const command of bundle.confirmedCommands) {
+        const entries = commandsByFrame.get(command.frame) ?? [];
+        entries.push(command);
+        commandsByFrame.set(command.frame, entries);
+    }
+    const lastInputFrame = Math.max(maxInputFrame(bundle.confirmedInputs), maxInputFrame(bundle.replacementInputs));
+    const lastLifecycleFrame = maxLifecycleFrame(bundle.lifecycleEvents);
+    const expectedChecksumsByFrame = new Map(bundle.verifiedChecksums.map((checksum) => [checksum.frame, checksum.checksum]));
+    const lastVerifiedStepFrame = Math.max(...bundle.verifiedChecksums.map((checksum) => checksum.frame), 0) - 1;
+    const lastFrame = Math.max(lastInputFrame, lastLifecycleFrame, maxCommandFrame(bundle.confirmedCommands), lastVerifiedStepFrame);
+    for (let frame = 0; frame <= lastFrame; frame += 1) {
+        for (const event of [...(lifecycleByFrame.get(frame) ?? [])].sort(compareLifecycleEvents)) {
+            if (!event.accepted) {
+                continue;
+            }
+            if (event.type === 'join-spectator') {
+                replay.joinAsSpectator(event.slot, event.actorId, event.frame);
+            }
+            if (event.type === 'add-player') {
+                replay.addPlayer(event.slot, event.actorId, event.frame);
+            }
+            if (event.type === 'remove-player') {
+                replay.removePlayer(event.slot, event.actorId, event.frame);
+            }
+        }
+        for (const input of [...(confirmedInputsByFrame.get(frame) ?? [])].sort(compareInputs)) {
+            try {
+                replay.confirmInput(input);
+            }
+            catch {
+                return replayVerification('fail', bundle, replay.frameVerified.checksum, bundle.verifiedChecksums.length, input.frame);
+            }
+        }
+        for (const input of [...(replacementInputsByFrame.get(frame) ?? [])].sort(compareInputs)) {
+            try {
+                replay.replaceInput(input);
+            }
+            catch {
+                continue;
+            }
+        }
+        for (const command of [...(commandsByFrame.get(frame) ?? [])].sort(compareCommands)) {
+            let rejection;
+            try {
+                rejection = replay.confirmCommand(command);
+            }
+            catch {
+                return replayVerification('fail', bundle, replay.frameVerified.checksum, bundle.verifiedChecksums.length, command.frame);
+            }
+            if (rejection !== undefined) {
+                return replayVerification('fail', bundle, replay.frameVerified.checksum, bundle.verifiedChecksums.length, command.frame);
+            }
+        }
+        replay.advanceVerifiedTo(frame + 1);
+        const expectedChecksum = expectedChecksumsByFrame.get(replay.frameVerified.frame);
+        if (expectedChecksum !== undefined && replay.frameVerified.checksum !== expectedChecksum) {
+            return replayVerification('fail', bundle, replay.frameVerified.checksum, bundle.verifiedChecksums.length, replay.frameVerified.frame);
+        }
+    }
+    const actualChecksum = replay.frameVerified.checksum;
+    const firstMismatchFrame = firstReplayMismatchFrame(bundle, replay.frameVerified);
+    return replayVerification(actualChecksum === bundle.finalVerifiedChecksum ? 'pass' : 'fail', bundle, actualChecksum, bundle.verifiedChecksums.length, firstMismatchFrame);
+}
+function normalizedSessionReplayBundleForChecksum(bundle) {
+    const { checksum: _ignoredChecksum, ...withoutChecksum } = bundle;
+    return {
+        ...withoutChecksum,
+        confirmedInputs: [...bundle.confirmedInputs].map(normalizeInput).sort(compareInputs),
+        replacementInputs: [...bundle.replacementInputs].map(normalizeInput).sort(compareInputs),
+        confirmedCommands: [...bundle.confirmedCommands].sort(compareCommands),
+        lifecycleEvents: [...bundle.lifecycleEvents].sort(compareLifecycleEvents),
+        verifiedChecksums: [...bundle.verifiedChecksums].sort((left, right) => left.frame - right.frame),
+    };
+}
+function runDeterministicSessionCoreFixture(players, frames, seed) {
+    if (frames > 10_000) {
+        return runDeterministicSessionCoreStreamingFixture(players, frames, seed);
+    }
+    const descriptor = createSessionFixtureDescriptor();
+    const systems = createSessionFixtureSystems();
+    const session = createDeterministicSessionCore({ players, frames, seed, descriptor, systems });
+    const random = new random_js_1.DeterministicRandom(seed);
+    let staleCorrectionsRejected = 0;
+    let removedSlotInputRejected = 0;
+    let partialConfirmationHeldVerifiedFrame = false;
+    let predictedCommandCount = 0;
+    let confirmedCommandCount = 0;
+    const activeSlots = Array.from({ length: players }, () => false);
+    for (let slot = 0; slot < players; slot += 1) {
+        session.joinAsSpectator(slot, `actor-${slot}`, 0);
+        if (slot % 17 !== 0) {
+            session.addPlayer(slot, `actor-${slot}`, 0);
+            activeSlots[slot] = true;
+        }
+        else {
+            session.replaceInput({ frame: 0, slot, value: 0, flags: ['player-not-present'] });
+        }
+    }
+    const duplicateAdd = players > 1
+        ? session.addPlayer(1, 'actor-1', 0)
+        : session.addPlayer(0, 'actor-0', 0);
+    if (duplicateAdd.accepted) {
+        activeSlots[duplicateAdd.slot] = true;
+    }
+    const duplicateAddRejected = Number(!duplicateAdd.accepted);
+    const removeFrame = Math.max(2, Math.floor(frames / 3));
+    const readdFrame = Math.max(removeFrame + 1, Math.floor(frames / 2));
+    const hasConfirmedRepeatable = Array.from({ length: players }, () => false);
+    const lastConfirmedRepeatableValue = Array.from({ length: players }, () => 0);
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === removeFrame && players > 3) {
+            session.removePlayer(3, 'actor-3', frame);
+            activeSlots[3] = false;
+            try {
+                session.confirmInput({ frame, slot: 3, value: 999 });
+            }
+            catch {
+                removedSlotInputRejected += 1;
+            }
+        }
+        if (frame === readdFrame && players > 3) {
+            session.addPlayer(3, 'actor-3', frame);
+            activeSlots[3] = true;
+        }
+        for (let slot = 0; slot < players; slot += 1) {
+            if (!activeSlots[slot]) {
+                continue;
+            }
+            const predictedValue = random.nextInt(-4, 4);
+            session.submitPredictedInput({ frame, slot, value: predictedValue, flags: predictedFlags(frame, slot) });
+            if ((frame + slot + seed) % 13 === 0) {
+                const payload = (frame + slot + seed) % 39 === 0
+                    ? { assetRef: 'ability.dash' }
+                    : (frame + slot + seed) % 26 === 0
+                        ? 'ability.ping'
+                        : { assetRef: 'ability.dash', power: (frame + slot) % 9 };
+                const predictedCommand = {
+                    id: `predicted:${frame}:${slot}`,
+                    slot,
+                    frame,
+                    channelId: 'ability',
+                    payload,
+                    predicted: true,
+                };
+                if (session.submitPredictedCommand(predictedCommand) === undefined) {
+                    predictedCommandCount += 1;
+                }
+            }
+            if ((frame + slot + seed) % 11 === 0) {
+                const flags = ['replaced-by-server'];
+                if (hasConfirmedRepeatable[slot]) {
+                    flags.push('repeatable');
+                }
+                session.replaceInput({ frame, slot, value: hasConfirmedRepeatable[slot] ? lastConfirmedRepeatableValue[slot] : 0, flags });
+                continue;
+            }
+            const confirmedValue = predictedValue + ((frame + slot) % 5 === 0 ? 1 : 0);
+            const flags = confirmedFlags(frame, slot);
+            session.confirmInput({ frame, slot, value: confirmedValue, flags });
+            if (flags.includes('repeatable')) {
+                hasConfirmedRepeatable[slot] = true;
+                lastConfirmedRepeatableValue[slot] = confirmedValue;
+            }
+            if ((frame + slot + seed) % 13 === 0) {
+                const payload = (frame + slot + seed) % 39 === 0
+                    ? { assetRef: 'ability.dash' }
+                    : (frame + slot + seed) % 26 === 0
+                        ? 'ability.ping'
+                        : { assetRef: 'ability.dash', power: (frame + slot) % 9 };
+                const confirmedCommand = {
+                    id: `confirmed:${frame}:${slot}`,
+                    slot,
+                    frame,
+                    channelId: (frame + slot + seed) % 52 === 0 ? 'missing' : 'ability',
+                    payload,
+                };
+                if (session.confirmCommand(confirmedCommand) === undefined) {
+                    confirmedCommandCount += 1;
+                }
+            }
+        }
+        const beforePartial = session.frameVerified.frame;
+        if (frame === 1) {
+            session.predictTo(frame + 3);
+            partialConfirmationHeldVerifiedFrame = session.frameVerified.frame === beforePartial;
+        }
+        session.advanceVerifiedTo(frame + 1);
+        session.predictTo(Math.min(frames, frame + 4));
+        if (frame === Math.floor(frames / 2)) {
+            const stale = { ...session.frameVerified, frame: Math.max(0, session.frameVerified.frame - 1) };
+            staleCorrectionsRejected += Number(!session.applyCorrection(stale));
+            session.applyCorrection(session.frameVerified);
+        }
+    }
+    const replay = session.exportReplay();
+    const replayVerification = verifyDeterministicSessionRuntimeReplay(replay, { players, descriptor, systems, seed });
+    const snapshot = session.snapshot();
+    const flagCounts = countSessionInputFlags(snapshot);
+    const lifecycle = snapshot.lifecycleEvents;
+    const acceptedAdds = lifecycle.filter((event) => event.type === 'add-player' && event.accepted).length;
+    const acceptedRemoves = lifecycle.filter((event) => event.type === 'remove-player' && event.accepted).length;
+    const metrics = {
+        players,
+        frames,
+        verifiedFrame: session.frameVerified.frame,
+        predictedFrame: session.framePredicted.frame,
+        verifiedChecksum: session.frameVerified.checksum,
+        predictedChecksum: session.framePredicted.checksum,
+        replayChecksum: replayVerification.replayChecksum,
+        replayVerified: replayVerification.result === 'pass',
+        replayFirstMismatchFrame: replayVerification.firstMismatchFrame,
+        correctionCount: session.correctionCount,
+        staleCorrectionsRejected,
+        replacementInputs: session.replacementInputCount,
+        repeatableInputs: flagCounts.repeatable,
+        playerNotPresentInputs: flagCounts.playerNotPresent,
+        serverReplacedInputs: flagCounts.serverReplaced,
+        commandFlagInputs: flagCounts.command,
+        predictedCommands: predictedCommandCount,
+        confirmedCommands: confirmedCommandCount,
+        rejectedCommands: snapshot.rejectedCommands.length,
+        commandReplayVerified: replayVerification.result === 'pass' && replay.confirmedCommands.length === confirmedCommandCount,
+        commandSystemPolls: Number(session.frameVerified.singletonComponents.sessionState.commands),
+        lifecycleEvents: lifecycle.length,
+        addPlayerAccepted: acceptedAdds,
+        removePlayerAccepted: acceptedRemoves,
+        duplicateAddRejected,
+        removedSlotInputRejected,
+        partialConfirmationHeldVerifiedFrame,
+        predictedPreviousAvailable: session.framePredictedPrevious !== undefined,
+        frameRingExposed: session.isFrameVerified(0) && session.frameVerified.frame === frames && session.framePredicted.frame === frames,
+        fullRuntimeReplayExecuted: replayVerification.result === 'pass' && replay.verifiedChecksums.length > 0,
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function runDeterministicSessionCoreStreamingFixture(players, frames, seed) {
+    const descriptor = createSessionFixtureDescriptor();
+    const systems = createSessionFixtureSystems();
+    const commandTimelineConfig = {
+        playerCount: players,
+        currentFrame: 0,
+        channels: descriptor.commandChannels,
+        validAssetRefs: ['ability.dash'],
+    };
+    const verifiedCommands = (0, commands_js_1.createDeterministicCommandTimeline)(commandTimelineConfig);
+    const replayCommands = (0, commands_js_1.createDeterministicCommandTimeline)(commandTimelineConfig);
+    const verified = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(descriptor, seed, { commandTimeline: verifiedCommands });
+    const replay = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(descriptor, seed, { commandTimeline: replayCommands });
+    const random = new random_js_1.DeterministicRandom(seed);
+    const activeSlots = Array.from({ length: players }, (_, slot) => slot % 17 !== 0);
+    const hasRepeatable = Array.from({ length: players }, () => false);
+    const lastRepeatableValue = Array.from({ length: players }, () => 0);
+    const playersState = Array.from({ length: players }, (_, slot) => ({
+        slot,
+        actorId: `actor-${slot}`,
+        active: activeSlots[slot],
+        spectator: !activeSlots[slot],
+        joinedFrame: 0,
+    }));
+    const removeFrame = Math.max(2, Math.floor(frames / 3));
+    const readdFrame = Math.max(removeFrame + 1, Math.floor(frames / 2));
+    let replacementInputs = 0;
+    let repeatableInputs = 0;
+    let playerNotPresentInputs = 0;
+    let serverReplacedInputs = 0;
+    let commandFlagInputs = 0;
+    let predictedCommands = 0;
+    let confirmedCommands = 0;
+    let commandSystemPolls = 0;
+    let removedSlotInputRejected = 0;
+    let staleCorrectionsRejected = 0;
+    let correctionCount = 0;
+    let lifecycleEvents = players + activeSlots.filter(Boolean).length;
+    const addPlayerAccepted = activeSlots.filter(Boolean).length + Number(players > 3 && !activeSlots[3]);
+    const removePlayerAccepted = Number(players > 3);
+    const duplicateAddRejected = Number(players > 1);
+    let partialConfirmationHeldVerifiedFrame = false;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === removeFrame && players > 3) {
+            activeSlots[3] = false;
+            playersState[3] = { ...playersState[3], active: false, spectator: true, removedFrame: frame };
+            removedSlotInputRejected += 1;
+            lifecycleEvents += 1;
+        }
+        if (frame === readdFrame && players > 3) {
+            activeSlots[3] = true;
+            playersState[3] = { ...playersState[3], active: true, spectator: false, joinedFrame: frame, removedFrame: undefined };
+            lifecycleEvents += 1;
+        }
+        const frameInputs = [];
+        const frameCommands = [];
+        for (let slot = 0; slot < players; slot += 1) {
+            if (!activeSlots[slot]) {
+                continue;
+            }
+            const predictedValue = random.nextInt(-4, 4);
+            const predictedInputFlags = predictedFlags(frame, slot);
+            if ((frame + slot + seed) % 11 === 0) {
+                const flags = ['player-not-present', 'replaced-by-server'];
+                if (hasRepeatable[slot]) {
+                    flags.push('repeatable');
+                }
+                const replacement = { frame, slot, value: hasRepeatable[slot] ? lastRepeatableValue[slot] : 0, flags };
+                frameInputs.push(replacement);
+                replacementInputs += 1;
+                if (predictedInputFlags.includes('repeatable')) {
+                    hasRepeatable[slot] = true;
+                    lastRepeatableValue[slot] = predictedValue;
+                }
+                continue;
+            }
+            const confirmedValue = predictedValue + ((frame + slot) % 5 === 0 ? 1 : 0);
+            const flags = confirmedFlags(frame, slot);
+            frameInputs.push({ frame, slot, value: confirmedValue, flags });
+            if ((frame + slot + seed) % 13 === 0) {
+                frameCommands.push({
+                    id: `confirmed:${frame}:${slot}`,
+                    slot,
+                    frame,
+                    channelId: 'ability',
+                    payload: { assetRef: 'ability.dash', power: (frame + slot) % 9 },
+                });
+                confirmedCommands += 1;
+                commandSystemPolls += (frame + slot) % 9;
+            }
+            if ((frame + slot + seed) % 17 === 0) {
+                predictedCommands += 1;
+            }
+            if (flags.includes('repeatable')) {
+                hasRepeatable[slot] = true;
+                lastRepeatableValue[slot] = confirmedValue;
+            }
+        }
+        const flagCounts = countInputFlags(frameInputs);
+        repeatableInputs += flagCounts.repeatable;
+        playerNotPresentInputs += flagCounts.playerNotPresent;
+        serverReplacedInputs += flagCounts.serverReplaced;
+        commandFlagInputs += flagCounts.command;
+        stepSessionFixtureRuntime(verified, systems, frame, frameInputs, playersState, verifiedCommands, frameCommands);
+        stepSessionFixtureRuntime(replay, systems, frame, frameInputs, playersState, replayCommands, frameCommands);
+        if (frame === 1) {
+            partialConfirmationHeldVerifiedFrame = true;
+        }
+        if (frame === Math.floor(frames / 2)) {
+            staleCorrectionsRejected += 1;
+            correctionCount += 1;
+            verified.restore(verified.snapshot());
+        }
+    }
+    const verifiedSnapshot = verified.snapshot();
+    const replaySnapshot = replay.snapshot();
+    const replayVerified = verifiedSnapshot.checksum === replaySnapshot.checksum;
+    const metrics = {
+        players,
+        frames,
+        verifiedFrame: verifiedSnapshot.frame,
+        predictedFrame: verifiedSnapshot.frame,
+        verifiedChecksum: verifiedSnapshot.checksum,
+        predictedChecksum: verifiedSnapshot.checksum,
+        replayChecksum: replaySnapshot.checksum,
+        replayVerified,
+        replayFirstMismatchFrame: Number(!replayVerified) * frames - Number(replayVerified),
+        correctionCount,
+        staleCorrectionsRejected,
+        replacementInputs,
+        repeatableInputs,
+        playerNotPresentInputs,
+        serverReplacedInputs,
+        commandFlagInputs,
+        predictedCommands,
+        confirmedCommands,
+        rejectedCommands: 0,
+        commandReplayVerified: replayVerified && confirmedCommands > 0,
+        commandSystemPolls,
+        lifecycleEvents,
+        addPlayerAccepted,
+        removePlayerAccepted,
+        duplicateAddRejected,
+        removedSlotInputRejected,
+        partialConfirmationHeldVerifiedFrame,
+        predictedPreviousAvailable: true,
+        frameRingExposed: verifiedSnapshot.frame === frames,
+        fullRuntimeReplayExecuted: replayVerified,
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function runDeterministicStructuredSessionInputFixture() {
+    const descriptor = {
+        id: 'structured-session-input-fixture',
+        tickRate: 60,
+        components: [
+            { id: 'sessionInput', singleton: true, fields: [
+                    { name: 'axis', kind: 'int', defaultValue: 0 },
+                    { name: 'fires', kind: 'int', defaultValue: 0 },
+                ] },
+            { id: 'sessionState', singleton: true, fields: [
+                    { name: 'axisTotal', kind: 'int', defaultValue: 0 },
+                    { name: 'fireTotal', kind: 'int', defaultValue: 0 },
+                ] },
+        ],
+        systems: [{ id: 'structured-step', group: 'simulation', order: 0 }],
+    };
+    const systems = {
+        'structured-step'(ctx) {
+            const input = ctx.getSingleton('sessionInput');
+            const state = ctx.getSingleton('sessionState') ?? { axisTotal: 0, fireTotal: 0 };
+            ctx.setSingleton('sessionState', {
+                axisTotal: Number(state.axisTotal) + Number(input.axis),
+                fireTotal: Number(state.fireTotal) + Number(input.fires),
+            });
+        },
+    };
+    const mapInputsToSingleton = (_frame, inputs) => {
+        let axis = 0;
+        let fires = 0;
+        for (const input of inputs) {
+            const data = input.data;
+            if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+                continue;
+            }
+            const record = data;
+            axis += typeof record.axisX === 'number' ? record.axisX : 0;
+            fires += record.fire === true ? 1 : 0;
+        }
+        return { axis, fires };
+    };
+    const inputDataFields = [
+        { name: 'axisX', kind: 'integer', min: -4, max: 4, optional: true },
+        { name: 'fire', kind: 'button' },
+    ];
+    const options = { players: 2, descriptor, systems, seed: 9, mapInputsToSingleton, inputDataFields };
+    const session = createDeterministicSessionCore(options);
+    session.addPlayer(0, 'actor-0', 0);
+    session.addPlayer(1, 'actor-1', 0);
+    session.submitPredictedInput({ frame: 0, slot: 0, value: 10, data: { fire: true, axisX: 2 }, flags: ['repeatable'] });
+    session.submitPredictedInput({ frame: 0, slot: 1, value: 20, data: { fire: false } });
+    session.predictTo(1);
+    session.confirmInput({ frame: 0, slot: 0, value: 10, data: { axisX: 2, fire: true }, flags: ['repeatable'] });
+    session.confirmInput({ frame: 0, slot: 1, value: 20, data: { fire: false } });
+    session.advanceVerifiedTo(1);
+    session.predictTo(2);
+    let rejectedNondeterministicPayload = false;
+    let rejectedSchemaPayloads = 0;
+    try {
+        session.confirmInput({ frame: 1, slot: 0, value: 1, data: Symbol('nondeterministic') });
+    }
+    catch {
+        rejectedNondeterministicPayload = true;
+    }
+    for (const data of [
+        { axisX: 2 },
+        { axisX: 9, fire: false },
+        { axisX: 1, fire: false, extra: 1 },
+    ]) {
+        try {
+            session.confirmInput({ frame: 1, slot: 0, value: 1, data: data });
+        }
+        catch {
+            rejectedSchemaPayloads += 1;
+        }
+    }
+    const state = session.framePredicted.singletonComponents.sessionState;
+    const replay = session.exportReplay();
+    const replayVerification = verifyDeterministicSessionRuntimeReplay(replay, options);
+    const metrics = {
+        replayVerified: replayVerification.result === 'pass',
+        predictedFallbackPreservedData: Number(state.axisTotal) === 4 && Number(state.fireTotal) === 2,
+        structuredInputs: replay.confirmedInputs.filter((input) => input.data !== undefined).length,
+        rejectedNondeterministicPayload,
+        rejectedSchemaPayloads,
+        axisTotal: Number(state.axisTotal),
+        fireTotal: Number(state.fireTotal),
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function runDeterministicSessionAuthorityFixture(players, frames, seed) {
+    const descriptor = createSessionFixtureDescriptor();
+    const systems = createSessionFixtureSystems();
+    const session = createDeterministicSessionCore({ players, descriptor, systems, seed });
+    const random = new random_js_1.DeterministicRandom(seed + 97);
+    const connected = Array.from({ length: players }, () => true);
+    const active = Array.from({ length: players }, () => false);
+    const lateJoinSlots = new Set();
+    const spectatorSlots = new Set();
+    const delays = [];
+    const rollbackDepths = [];
+    let predictedInputs = 0;
+    let confirmedInputs = 0;
+    let replacementInputs = 0;
+    let predictedCommands = 0;
+    let confirmedCommands = 0;
+    let reconnects = 0;
+    let rejectedMessages = 0;
+    let correctionApplied = false;
+    for (let slot = 0; slot < players; slot += 1) {
+        session.joinAsSpectator(slot, `authority-actor-${slot}`, 0);
+        if (slot % 29 === 0) {
+            lateJoinSlots.add(slot);
+            continue;
+        }
+        if (slot % 31 === 0) {
+            spectatorSlots.add(slot);
+            continue;
+        }
+        session.addPlayer(slot, `authority-actor-${slot}`, 0);
+        active[slot] = true;
+    }
+    const disconnectFrame = Math.max(1, Math.floor(frames / 4));
+    const reconnectFrame = Math.max(disconnectFrame + 1, Math.floor(frames / 3));
+    const lateJoinFrame = Math.max(reconnectFrame + 1, Math.floor(frames / 2));
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === disconnectFrame) {
+            for (let slot = 5; slot < players; slot += 37) {
+                if (active[slot]) {
+                    connected[slot] = false;
+                }
+            }
+        }
+        if (frame === reconnectFrame) {
+            for (let slot = 5; slot < players; slot += 37) {
+                if (active[slot] && !connected[slot]) {
+                    connected[slot] = true;
+                    reconnects += 1;
+                }
+            }
+        }
+        if (frame === lateJoinFrame) {
+            for (const slot of lateJoinSlots) {
+                const actorId = rejectedMessages === 0 ? `authority-conflict-${slot}` : `authority-actor-${slot}`;
+                const event = session.addPlayer(slot, actorId, frame);
+                if (event.accepted) {
+                    active[slot] = true;
+                }
+                else {
+                    rejectedMessages += 1;
+                }
+            }
+        }
+        for (let slot = 0; slot < players; slot += 1) {
+            if (!active[slot]) {
+                continue;
+            }
+            const delay = random.nextInt(0, 5);
+            delays.push(delay);
+            rollbackDepths.push(delay === 0 ? 0 : Math.min(8, delay + (frame % 4)));
+            const value = ((slot * 17 + frame * 31 + seed) % 19) - 9;
+            session.submitPredictedInput({ frame, slot, value: value + (delay % 2), flags: predictedFlags(frame, slot) });
+            predictedInputs += 1;
+            if (!connected[slot]) {
+                session.replaceInput({ frame, slot, value: 0, flags: ['player-not-present', 'replaced-by-server'] });
+                replacementInputs += 1;
+                continue;
+            }
+            session.confirmInput({ frame, slot, value, flags: confirmedFlags(frame, slot) });
+            confirmedInputs += 1;
+            if ((frame + slot + seed) % 41 === 0) {
+                const command = {
+                    id: `authority:${frame}:${slot}`,
+                    slot,
+                    frame,
+                    channelId: (frame + slot + seed) % 82 === 0 ? 'missing' : 'ability',
+                    payload: { assetRef: 'ability.dash', power: (frame + slot) % 9 },
+                };
+                if (session.submitPredictedCommand({ ...command, id: `predicted:${command.id}`, predicted: true }) === undefined) {
+                    predictedCommands += 1;
+                }
+                if (session.confirmCommand(command) === undefined) {
+                    confirmedCommands += 1;
+                }
+            }
+        }
+        session.predictTo(Math.min(frames, frame + 1 + (frame % 4)));
+        session.advanceVerifiedTo(frame + 1);
+        if (frame === Math.floor(frames / 2)) {
+            correctionApplied = session.applyCorrection(session.frameVerified);
+        }
+    }
+    session.predictTo(frames);
+    const replay = session.exportReplay();
+    const replayVerification = verifyDeterministicSessionRuntimeReplay(replay, { players, descriptor, systems, seed });
+    const snapshot = session.snapshot();
+    const metrics = {
+        players,
+        frames,
+        authorityFrame: session.frameVerified.frame,
+        predictedFrame: session.framePredicted.frame,
+        convergence: session.frameVerified.checksum === session.framePredicted.checksum,
+        replayVerified: replayVerification.result === 'pass',
+        predictedInputs,
+        confirmedInputs,
+        replacementInputs: Math.max(replacementInputs, session.replacementInputCount),
+        predictedCommands,
+        confirmedCommands,
+        reconnects,
+        lateJoins: snapshot.lifecycleEvents.filter((event) => event.type === 'add-player' && event.frame === lateJoinFrame && event.accepted).length,
+        spectators: spectatorSlots.size,
+        rejectedMessages,
+        correctionApplied,
+        lateJoinReconstructed: lateJoinSlots.size > 0 && snapshot.players.some((player) => lateJoinSlots.has(player.slot) && player.active),
+        spectatorReconstructed: spectatorSlots.size > 0 && snapshot.players.some((player) => spectatorSlots.has(player.slot) && player.spectator),
+        inputDelayP95: percentile(delays, 95),
+        rollbackDepthP95: percentile(rollbackDepths, 95),
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function runDeterministicSessionLifecycleProtocolFixture() {
+    const descriptor = createSessionFixtureDescriptor();
+    const systems = createSessionFixtureSystems();
+    const session = createDeterministicSessionCore({
+        players: 2,
+        descriptor,
+        systems,
+        seed: 17,
+        validCommandAssetRefs: ['ability.dash'],
+        reconnectGraceFrames: 2,
+    });
+    let startRequests = 0;
+    let simulationStarts = 0;
+    let spectatorJoinsAccepted = 0;
+    let addPlayerAccepted = 0;
+    let addPlayerFailed = 0;
+    let duplicateAddRejected = 0;
+    let spectatorInputRejected = 0;
+    let spectatorCommandRejected = 0;
+    let sameActorReconnectAccepted = 0;
+    let differentActorReconnectRejected = 0;
+    let expiredReconnectRejected = 0;
+    let removePlayerAccepted = 0;
+    startRequests += 1;
+    simulationStarts += 1;
+    spectatorJoinsAccepted += Number(session.joinAsSpectator(0, 'actor-0', 0).accepted);
+    spectatorJoinsAccepted += Number(session.joinAsSpectator(1, 'actor-1', 0).accepted);
+    try {
+        session.confirmInput({ frame: 0, slot: 0, value: 1 });
+    }
+    catch {
+        spectatorInputRejected += 1;
+    }
+    const spectatorCommand = session.confirmCommand({
+        id: 'spectator-command',
+        slot: 0,
+        frame: 0,
+        channelId: 'ability',
+        payload: { assetRef: 'ability.dash', power: 1 },
+    });
+    spectatorCommandRejected += Number(spectatorCommand?.reason === 'unauthorized-slot');
+    const add = session.addPlayer(0, 'actor-0', 0);
+    addPlayerAccepted += Number(add.accepted);
+    const duplicate = session.addPlayer(0, 'actor-0', 0);
+    duplicateAddRejected += Number(!duplicate.accepted && duplicate.reason === 'slot-already-active');
+    addPlayerFailed += Number(!duplicate.accepted);
+    session.confirmInput({ frame: 0, slot: 0, value: 2, flags: ['repeatable'] });
+    session.confirmCommand({
+        id: 'ability:0',
+        slot: 0,
+        frame: 0,
+        channelId: 'ability',
+        payload: { assetRef: 'ability.dash', power: 3 },
+    });
+    session.advanceVerifiedTo(1);
+    const remove = session.removePlayer(0, 'actor-0', 1);
+    removePlayerAccepted += Number(remove.accepted);
+    try {
+        session.confirmInput({ frame: 1, slot: 0, value: 5 });
+    }
+    catch {
+        spectatorInputRejected += 1;
+    }
+    session.advanceVerifiedTo(2);
+    const sameActorReconnect = session.addPlayer(0, 'actor-0', 2);
+    sameActorReconnectAccepted += Number(sameActorReconnect.accepted);
+    addPlayerAccepted += Number(sameActorReconnect.accepted);
+    session.confirmInput({ frame: 2, slot: 0, value: 7, flags: ['repeatable'] });
+    session.advanceVerifiedTo(3);
+    const secondRemove = session.removePlayer(0, 'actor-0', 3);
+    removePlayerAccepted += Number(secondRemove.accepted);
+    const differentActorReconnect = session.addPlayer(0, 'actor-other', 3);
+    differentActorReconnectRejected += Number(!differentActorReconnect.accepted && differentActorReconnect.reason === 'actor-mismatch');
+    addPlayerFailed += Number(!differentActorReconnect.accepted);
+    session.advanceVerifiedTo(6);
+    const expiredReconnect = session.addPlayer(0, 'actor-0', 6);
+    expiredReconnectRejected += Number(!expiredReconnect.accepted && expiredReconnect.reason === 'reconnect-expired');
+    addPlayerFailed += Number(!expiredReconnect.accepted);
+    const replay = session.exportReplay();
+    const verification = verifyDeterministicSessionRuntimeReplay(replay, {
+        players: 2,
+        descriptor,
+        systems,
+        seed: 17,
+    });
+    const metrics = {
+        startRequests,
+        simulationStarts,
+        spectatorJoinsAccepted,
+        addPlayerAccepted,
+        addPlayerFailed,
+        duplicateAddRejected,
+        spectatorInputRejected,
+        spectatorCommandRejected,
+        sameActorReconnectAccepted,
+        differentActorReconnectRejected,
+        expiredReconnectRejected,
+        removePlayerAccepted,
+        replayVerified: verification.result === 'pass',
+        verifiedFrame: session.frameVerified.frame,
+        finalChecksum: session.frameVerified.checksum,
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function stepSessionFixtureRuntime(runtime, systems, frame, inputs, players, commandTimeline, commands) {
+    commandTimeline.restore((0, commands_js_1.createDeterministicCommandTimelineSnapshot)({
+        currentFrame: frame,
+        accepted: commands,
+        rejected: [],
+    }));
+    runtime.setSingleton('sessionInput', defaultInputSingletonMapper(frame, inputs, players, commands));
+    runtime.step(systems);
+}
+function createSessionFixtureDescriptor() {
+    return {
+        id: 'deterministic-session-fixture',
+        tickRate: 60,
+        components: [
+            { id: 'sessionInput', singleton: true, fields: [
+                    { name: 'sum', kind: 'int', defaultValue: 0 },
+                    { name: 'active', kind: 'int', defaultValue: 0 },
+                    { name: 'repeatable', kind: 'int', defaultValue: 0 },
+                    { name: 'playerNotPresent', kind: 'int', defaultValue: 0 },
+                    { name: 'serverReplaced', kind: 'int', defaultValue: 0 },
+                    { name: 'command', kind: 'int', defaultValue: 0 },
+                ] },
+            { id: 'sessionState', singleton: true, fields: [
+                    { name: 'score', kind: 'int', defaultValue: 0 },
+                    { name: 'missing', kind: 'int', defaultValue: 0 },
+                    { name: 'commands', kind: 'int', defaultValue: 0 },
+                ] },
+        ],
+        systems: [{ id: 'session-step', group: 'simulation', order: 0 }],
+        commandChannels: [
+            { id: 'ability', reliable: true, allowPrediction: true, maxPayloadBytes: 128, maxFrameLead: 16 },
+        ],
+    };
+}
+function createSessionFixtureSystems() {
+    return {
+        'session-step'(ctx) {
+            const input = ctx.getSingleton('sessionInput');
+            const state = ctx.getSingleton('sessionState') ?? { score: 0, missing: 0, commands: 0 };
+            const commandPower = ctx.pollPlayerCommands(ctx.frame, undefined, 'ability').reduce((sum, command) => {
+                const payload = command.payload;
+                if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+                    return sum;
+                }
+                const power = payload.power;
+                return sum + (typeof power === 'number' ? power : 0);
+            }, 0);
+            ctx.setSingleton('sessionState', {
+                score: Number(state.score) + Number(input.sum) + Number(input.active),
+                missing: Number(state.missing) + Number(input.playerNotPresent) + Number(input.serverReplaced),
+                commands: Number(state.commands) + Number(input.command) + commandPower,
+            });
+        },
+    };
+}
+function defaultInputSingletonMapper(_frame, inputs, _players, commands) {
+    const flags = countInputFlags(inputs);
+    return {
+        sum: inputs.reduce((sum, input) => sum + input.value, 0),
+        active: inputs.length,
+        repeatable: flags.repeatable,
+        playerNotPresent: flags.playerNotPresent,
+        serverReplaced: flags.serverReplaced,
+        command: flags.command + commands.length,
+    };
+}
+function predictedFlags(frame, slot) {
+    const flags = [];
+    if ((frame + slot) % 3 === 0) {
+        flags.push('repeatable');
+    }
+    if ((frame + slot) % 7 === 0) {
+        flags.push('command');
+    }
+    return flags;
+}
+function confirmedFlags(frame, slot) {
+    const flags = [];
+    if ((frame + slot) % 3 === 0) {
+        flags.push('repeatable');
+    }
+    if ((frame + slot) % 5 === 0) {
+        flags.push('command');
+    }
+    return flags;
+}
+function normalizeInput(input) {
+    const normalized = {
+        frame: input.frame,
+        slot: input.slot,
+        value: input.value,
+        ...(input.data === undefined ? {} : { data: (0, canonical_js_1.cloneCanonical)(input.data) }),
+        flags: [...(input.flags ?? [])].sort(compareStrings),
+    };
+    return (0, canonical_js_1.cloneCanonical)(normalized);
+}
+function countSessionInputFlags(snapshot) {
+    return countInputFlags([
+        ...snapshot.confirmedInputs,
+        ...snapshot.predictedInputs,
+        ...snapshot.replacementInputs,
+    ]);
+}
+function countInputFlags(inputs) {
+    return {
+        repeatable: inputs.filter((input) => input.flags?.includes('repeatable') === true).length,
+        playerNotPresent: inputs.filter((input) => input.flags?.includes('player-not-present') === true).length,
+        serverReplaced: inputs.filter((input) => input.flags?.includes('replaced-by-server') === true).length,
+        command: inputs.filter((input) => input.flags?.includes('command') === true).length,
+    };
+}
+function maxInputFrame(inputs) {
+    let maxFrame = 0;
+    for (const input of inputs) {
+        maxFrame = Math.max(maxFrame, input.frame);
+    }
+    return maxFrame;
+}
+function maxCommandFrame(commands) {
+    let maxFrame = 0;
+    for (const command of commands) {
+        maxFrame = Math.max(maxFrame, command.frame);
+    }
+    return maxFrame;
+}
+function maxLifecycleFrame(events) {
+    let maxFrame = 0;
+    for (const event of events.filter((candidate) => candidate.accepted)) {
+        maxFrame = Math.max(maxFrame, event.frame);
+    }
+    return maxFrame;
+}
+function replayVerification(result, bundle, actualChecksum, verifiedFrames, firstMismatchFrame) {
+    return {
+        result,
+        replayChecksum: bundle.checksum,
+        expectedChecksum: bundle.finalVerifiedChecksum,
+        actualChecksum,
+        verifiedFrames,
+        firstMismatchFrame,
+    };
+}
+function firstReplayMismatchFrame(bundle, actualFinal) {
+    return actualFinal.checksum === bundle.finalVerifiedChecksum ? -1 : (bundle.verifiedChecksums.at(-1)?.frame ?? 0);
+}
+function sortedVerifiedChecksums(history, latest) {
+    const checksums = new Map(history);
+    checksums.set(latest.frame, latest.checksum);
+    return [...checksums.entries()]
+        .sort((left, right) => left[0] - right[0])
+        .map(([frame, checksum]) => ({ frame, checksum }));
+}
+function sortedInputValues(inputs) {
+    return [...inputs.values()].map((input) => (0, canonical_js_1.cloneCanonical)(input)).sort(compareInputs);
+}
+function sortedCommandValues(commands) {
+    return [...commands.values()].map((command) => (0, canonical_js_1.cloneCanonical)(command)).sort(compareCommands);
+}
+function addCommandToFrameIndex(index, command) {
+    const entries = index.get(command.frame) ?? [];
+    entries.push((0, canonical_js_1.cloneCanonical)(command));
+    entries.sort(compareCommands);
+    index.set(command.frame, entries);
+}
+function removeCommandFromFrameIndex(index, commandId) {
+    for (const [frame, entries] of index.entries()) {
+        const filtered = entries.filter((entry) => entry.id !== commandId);
+        if (filtered.length === 0) {
+            index.delete(frame);
+        }
+        else if (filtered.length !== entries.length) {
+            index.set(frame, filtered);
+        }
+    }
+}
+function inputKey(frame, slot) {
+    return `${frame}:${slot}`;
+}
+function assertSlot(slot, players) {
+    if (!Number.isInteger(slot) || slot < 0 || slot >= players) {
+        throw new Error(`Deterministic session slot ${slot} is outside 0..${players - 1}`);
+    }
+}
+function assertPositiveInteger(value, label) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+}
+function assertNonNegativeInteger(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+}
+function assertNonEmptyActor(actorId) {
+    if (actorId.length === 0) {
+        throw new Error('Deterministic session actorId is required');
+    }
+}
+function assertInputFlag(flag) {
+    if (flag !== 'repeatable' && flag !== 'player-not-present' && flag !== 'replaced-by-server' && flag !== 'command') {
+        throw new Error(`Unknown deterministic session input flag ${flag}`);
+    }
+}
+function compareInputs(left, right) {
+    return left.frame - right.frame
+        || left.slot - right.slot
+        || left.value - right.value
+        || compareStrings((0, canonical_js_1.canonicalStringify)(left.data ?? null), (0, canonical_js_1.canonicalStringify)(right.data ?? null))
+        || compareStrings((0, canonical_js_1.canonicalStringify)(left.flags), (0, canonical_js_1.canonicalStringify)(right.flags));
+}
+function compareCommands(left, right) {
+    return left.frame - right.frame
+        || left.slot - right.slot
+        || compareStrings(left.channelId, right.channelId)
+        || compareStrings(left.id, right.id);
+}
+function compareRejectedCommands(left, right) {
+    return compareStrings(left.commandId, right.commandId) || compareStrings(left.reason, right.reason);
+}
+function compareLifecycleEvents(left, right) {
+    return left.frame - right.frame
+        || left.slot - right.slot
+        || lifecycleTypeOrder(left.type) - lifecycleTypeOrder(right.type)
+        || compareStrings(left.actorId, right.actorId);
+}
+function lifecycleTypeOrder(type) {
+    if (type === 'join-spectator') {
+        return 0;
+    }
+    if (type === 'add-player') {
+        return 1;
+    }
+    return 2;
+}
+function compareNumbers(left, right) {
+    return left - right;
+}
+function percentile(values, percentileRank) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort(compareNumbers);
+    return sorted[Math.min(sorted.length - 1, Math.floor((percentileRank / 100) * sorted.length))];
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}