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

package/dist/cjs/replay-inspect.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectReplayFrame = inspectReplayFrame;
+exports.inspectReplayFrameWithDescriptor = inspectReplayFrameWithDescriptor;
+exports.explainReplayChecksum = explainReplayChecksum;
+exports.diffReplayFrames = diffReplayFrames;
+exports.stableFrameDumpJson = stableFrameDumpJson;
+exports.stableFrameDiffJson = stableFrameDiffJson;
+const canonical_js_1 = require("./canonical.js");
+const collections_js_1 = require("./collections.js");
+const errors_js_1 = require("./errors.js");
+const offline_session_js_1 = require("./offline-session.js");
+const replay_js_1 = require("./replay.js");
+const schema_artifacts_js_1 = require("./schema-artifacts.js");
+function inspectReplayFrame(config, frame, options = {}) {
+    (0, replay_js_1.assertReplayFileStructure)(config.replay);
+    validateFrame(config.replay, frame);
+    assertReplayIdentity(config);
+    const initialState = (0, canonical_js_1.decodeCanonicalValue)(config.replay.initialState);
+    const session = (0, offline_session_js_1.createOfflineSession)({
+        ...config,
+        initialState,
+        playerCount: config.replay.playerCount,
+        tickRate: config.replay.tickRate,
+        randomSeed: config.replay.randomSeed,
+        replayRecordingMode: 'none',
+        snapshotBufferSize: Math.max(1, frame + 1),
+    });
+    const commandFrames = new Map((config.replay.commandHistory ?? []).map((commandFrame) => [commandFrame.frame, commandFrame.commands]));
+    for (const inputFrame of config.replay.inputFrames) {
+        if (inputFrame.frame >= frame) {
+            break;
+        }
+        if (inputFrame.frame !== session.currentFrame) {
+            throw new errors_js_1.SyncplayError(`Replay input frame ${inputFrame.frame} does not match session frame ${session.currentFrame}`, { code: 'replay.input-frame-gap', frame: session.currentFrame });
+        }
+        inputFrame.inputs.forEach((input, slot) => {
+            const decodedInput = (0, canonical_js_1.decodeCanonicalValue)(input);
+            const flags = inputFrame.inputFlags?.[slot];
+            const replayInput = flags?.playerPresent === false ? config.defaultInput : (config.hydrateInput?.(decodedInput) ?? decodedInput);
+            session.setInput(slot, replayInput);
+            if (flags !== undefined) {
+                session.setInputFlags(slot, flags);
+            }
+        });
+        const commands = commandFrames.get(inputFrame.frame);
+        if (commands !== undefined) {
+            session.recordCommands(commands.map((command) => (0, canonical_js_1.decodeCanonicalValue)(command)));
+        }
+        session.stepFrames(1);
+    }
+    const state = config.canonicalizeState?.(session.getState()) ?? session.getState();
+    const checksum = String(config.checksum?.(session.getState()) ?? (0, canonical_js_1.defaultChecksum)(state));
+    const expectedChecksum = replayChecksumForFrame(config.replay, frame);
+    const dump = {
+        frame,
+        checksum,
+        expectedChecksum,
+        checksumMatch: expectedChecksum === undefined ? undefined : expectedChecksum === checksum,
+        inputFrame: cloneOptional(config.replay.inputFrames.find((record) => record.frame === frame)),
+        commandFrame: cloneOptional(config.replay.commandHistory?.find((record) => record.frame === frame)),
+        appliedInputFrame: cloneOptional(config.replay.inputFrames.find((record) => record.frame === frame - 1)),
+        appliedCommandFrame: cloneOptional(config.replay.commandHistory?.find((record) => record.frame === frame - 1)),
+        state: (0, canonical_js_1.canonicalize)(state),
+    };
+    return {
+        ...dump,
+        checksumExplanation: options.explainChecksum === true ? explainReplayChecksum(dump) : undefined,
+    };
+}
+function inspectReplayFrameWithDescriptor(config, frame, options = {}) {
+    const artifacts = (0, schema_artifacts_js_1.createSchemaArtifacts)(config.descriptor);
+    return inspectReplayFrame({
+        replay: config.replay,
+        step: config.step,
+        defaultInput: config.defaultInput,
+        // The content-hashed identity, matching what runtimes stamp into exported
+        // replays — same contract as verifyReplayWithDescriptor.
+        inputSchemaId: artifacts.descriptor.replayIdentity.inputSchemaId,
+        stateSchemaId: artifacts.descriptor.replayIdentity.stateSchemaId,
+        deterministicVersion: artifacts.descriptor.deterministicVersion,
+        canonicalizeInput(input) {
+            return artifacts.canonicalizeInput(input);
+        },
+        canonicalizeState(state) {
+            return artifacts.canonicalizeState(state);
+        },
+        checksum(state) {
+            return artifacts.checksumState(state);
+        },
+        serializeState(state) {
+            return artifacts.serializeState(state);
+        },
+        deserializeState(bytes) {
+            return artifacts.deserializeState(bytes);
+        },
+        hydrateInput: config.hydrateInput,
+    }, frame, options);
+}
+function explainReplayChecksum(dump) {
+    const state = dump.state;
+    const tables = isRecord(state)
+        ? (0, collections_js_1.stableSortedKeys)(state)
+            .map((key) => explainChecksumTable(`state.${key}`, state[key]))
+        : [explainChecksumTable('state', state)];
+    return {
+        frame: dump.frame,
+        checksum: dump.checksum,
+        tableCount: tables.length,
+        tables,
+    };
+}
+function diffReplayFrames(left, right, maxDifferences = 200) {
+    const differences = [];
+    collectDiffs('state', left.state, right.state, differences, maxDifferences);
+    return {
+        frame: left.frame,
+        leftChecksum: left.checksum,
+        rightChecksum: right.checksum,
+        checksumMatch: left.checksum === right.checksum,
+        differences,
+    };
+}
+function stableFrameDumpJson(dump) {
+    return `${JSON.stringify(dump)}\n`;
+}
+function stableFrameDiffJson(diff) {
+    return `${JSON.stringify(diff)}\n`;
+}
+function collectDiffs(path, left, right, differences, maxDifferences) {
+    if (differences.length >= maxDifferences || stringifyCanonicalForDiff(left) === stringifyCanonicalForDiff(right)) {
+        return;
+    }
+    if (Array.isArray(left) && Array.isArray(right)) {
+        const length = Math.max(left.length, right.length);
+        for (let index = 0; index < length; index += 1) {
+            collectDiffs(`${path}[${index}]`, left[index], right[index], differences, maxDifferences);
+            if (differences.length >= maxDifferences) {
+                return;
+            }
+        }
+        return;
+    }
+    if (!isRecord(left) || !isRecord(right)) {
+        differences.push({ path, left, right });
+        return;
+    }
+    const keys = mergeStableKeys(left, right);
+    for (const key of keys) {
+        collectDiffs(`${path}.${key}`, left[key], right[key], differences, maxDifferences);
+        if (differences.length >= maxDifferences) {
+            return;
+        }
+    }
+}
+function isRecord(value) {
+    return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringifyCanonicalForDiff(value) {
+    return value === undefined ? '<undefined>' : JSON.stringify(value);
+}
+function explainChecksumTable(path, value) {
+    const source = JSON.stringify(value);
+    return {
+        path,
+        checksum: (0, canonical_js_1.defaultChecksum)(source),
+        bytes: (0, canonical_js_1.encodeUtf8)(source).byteLength,
+        entries: countEntries(value),
+        sampleKeys: sampleKeys(value),
+    };
+}
+function countEntries(value) {
+    if (Array.isArray(value)) {
+        return value.length;
+    }
+    if (isRecord(value)) {
+        return (0, collections_js_1.stableSortedKeys)(value).length;
+    }
+    return 1;
+}
+function sampleKeys(value) {
+    if (Array.isArray(value)) {
+        return value.slice(0, 5).map((_, index) => `[${index}]`);
+    }
+    if (isRecord(value)) {
+        return (0, collections_js_1.stableSortedKeys)(value).slice(0, 5);
+    }
+    return [];
+}
+function validateFrame(replay, frame) {
+    if (!Number.isInteger(frame) || frame < 0 || frame > replay.inputFrames.length) {
+        throw new errors_js_1.SyncplayError(`Replay frame ${frame} is outside 0..${replay.inputFrames.length}`, {
+            code: 'replay.inspect-frame',
+            frame,
+        });
+    }
+}
+function mergeStableKeys(left, right) {
+    return [...new Set([...(0, collections_js_1.stableSortedKeys)(left), ...(0, collections_js_1.stableSortedKeys)(right)])].sort(compareStrings);
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}
+function assertReplayIdentity(config) {
+    const checks = [
+        ['deterministicVersion', config.deterministicVersion, config.replay.deterministicVersion],
+        ['inputSchemaId', config.inputSchemaId, config.replay.inputSchemaId],
+        ['stateSchemaId', config.stateSchemaId, config.replay.stateSchemaId],
+        ['engineIdentityHash', config.engineIdentityHash, config.replay.engineIdentityHash],
+        ['assetDbHash', config.assetDbHash, config.replay.assetDbHash],
+        ['configHash', config.configHash, config.replay.configHash],
+    ];
+    for (const [field, actual, expected] of checks) {
+        if (actual === undefined || expected === undefined) {
+            continue;
+        }
+        if (actual !== expected) {
+            throw new errors_js_1.SyncplayError(`Replay ${field} mismatch: expected ${expected}, actual ${actual}`, {
+                code: 'replay.identity-mismatch',
+            });
+        }
+    }
+}
+function replayChecksumForFrame(replay, frame) {
+    const checksums = replay.checksums.filter((record) => record.frame === frame);
+    if (checksums.length > 1) {
+        throw new errors_js_1.SyncplayError(`Replay frame ${frame} has duplicate checksum records`, {
+            code: 'replay.inspect-checksum',
+            frame,
+        });
+    }
+    return checksums[0]?.checksum;
+}
+function cloneOptional(value) {
+    return value === undefined ? undefined : (0, canonical_js_1.cloneCanonical)(value);
+}

package/dist/cjs/replay-scoring.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyScoredReplay = verifyScoredReplay;
+const canonical_js_1 = require("./canonical.js");
+const offline_session_js_1 = require("./offline-session.js");
+const replay_js_1 = require("./replay.js");
+function verifyScoredReplay(config) {
+    const { submittedScore, extractScore, ...verification } = config;
+    const result = (0, replay_js_1.verifyReplay)({ ...verification, throwOnMismatch: false });
+    if (result.mismatches > 0) {
+        return {
+            ok: false,
+            reason: 'replay-mismatch',
+            submittedScore,
+            frames: result.frames,
+            verifiedChecksums: result.checksums,
+            finalChecksum: result.finalChecksum,
+            ...(result.firstMismatch === undefined ? {} : { mismatchFrame: result.firstMismatch.frame }),
+        };
+    }
+    // The replay re-simulated clean — walk it once more to materialize the final
+    // state for score extraction (verifyReplay reports checksums, not state).
+    const replay = config.replay;
+    const session = (0, offline_session_js_1.createOfflineSession)({
+        ...verification,
+        initialState: (0, canonical_js_1.decodeCanonicalValue)(replay.initialState),
+        playerCount: replay.playerCount,
+        tickRate: replay.tickRate,
+        randomSeed: replay.randomSeed,
+    });
+    const commandFrames = new Map((replay.commandHistory ?? []).map((frame) => [frame.frame, frame.commands]));
+    for (const inputFrame of replay.inputFrames) {
+        inputFrame.inputs.forEach((input, slot) => {
+            const decoded = (0, canonical_js_1.decodeCanonicalValue)(input);
+            const flags = inputFrame.inputFlags?.[slot];
+            const replayInput = flags?.playerPresent === false ? config.defaultInput : (config.hydrateInput?.(decoded) ?? decoded);
+            session.setInput(slot, replayInput);
+            if (flags !== undefined) {
+                session.setInputFlags(slot, flags);
+            }
+        });
+        const commands = commandFrames.get(inputFrame.frame);
+        if (commands !== undefined) {
+            session.recordCommands(commands.map((command) => (0, canonical_js_1.decodeCanonicalValue)(command)));
+        }
+        session.stepFrames(1);
+    }
+    const replayScore = extractScore(session.getState());
+    if (replayScore !== submittedScore) {
+        return {
+            ok: false,
+            reason: 'score-mismatch',
+            replayScore,
+            submittedScore,
+            frames: result.frames,
+            verifiedChecksums: result.checksums,
+            finalChecksum: result.finalChecksum,
+        };
+    }
+    return {
+        ok: true,
+        replayScore,
+        submittedScore,
+        frames: result.frames,
+        verifiedChecksums: result.checksums,
+        finalChecksum: result.finalChecksum,
+    };
+}

package/dist/cjs/replay.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyReplay = verifyReplay;
+exports.verifyReplayWithDescriptor = verifyReplayWithDescriptor;
+exports.assertReplayFileStructure = assertReplayFileStructure;
+const canonical_js_1 = require("./canonical.js");
+const errors_js_1 = require("./errors.js");
+const offline_session_js_1 = require("./offline-session.js");
+const schema_artifacts_js_1 = require("./schema-artifacts.js");
+function verifyReplay(config) {
+    const replay = config.replay;
+    assertReplayFileStructure(replay);
+    assertReplayIdentity(config);
+    const initialState = (0, canonical_js_1.decodeCanonicalValue)(replay.initialState);
+    const session = (0, offline_session_js_1.createOfflineSession)({
+        ...config,
+        initialState,
+        playerCount: replay.playerCount,
+        tickRate: replay.tickRate,
+        randomSeed: replay.randomSeed,
+    });
+    const checksums = new Map(replay.checksums.map((checksum) => [checksum.frame, checksum.checksum]));
+    const commandFrames = new Map((replay.commandHistory ?? []).map((commandFrame) => [commandFrame.frame, commandFrame.commands]));
+    let verifiedChecksums = 0;
+    let finalChecksum = String((0, canonical_js_1.defaultChecksum)(initialState));
+    for (const inputFrame of replay.inputFrames) {
+        if (inputFrame.frame !== session.currentFrame) {
+            throw new errors_js_1.SyncplayError(`Replay input frame ${inputFrame.frame} does not match session frame ${session.currentFrame}`, { code: 'replay.input-frame-gap', frame: session.currentFrame });
+        }
+        inputFrame.inputs.forEach((input, slot) => {
+            const decodedInput = (0, canonical_js_1.decodeCanonicalValue)(input);
+            const flags = inputFrame.inputFlags?.[slot];
+            const replayInput = flags?.playerPresent === false ? config.defaultInput : (config.hydrateInput?.(decodedInput) ?? decodedInput);
+            session.setInput(slot, replayInput);
+            if (flags !== undefined) {
+                session.setInputFlags(slot, flags);
+            }
+        });
+        const commands = commandFrames.get(inputFrame.frame);
+        if (commands !== undefined) {
+            session.recordCommands(commands.map((command) => (0, canonical_js_1.decodeCanonicalValue)(command)));
+        }
+        session.stepFrames(1);
+        const expectedChecksum = checksums.get(session.currentFrame);
+        if (expectedChecksum !== undefined) {
+            const actualChecksum = String(config.checksum?.(session.getState()) ?? (0, canonical_js_1.defaultChecksum)(config.canonicalizeState?.(session.getState()) ?? session.getState()));
+            verifiedChecksums += 1;
+            finalChecksum = actualChecksum;
+            if (actualChecksum !== expectedChecksum) {
+                const mismatch = {
+                    frame: session.currentFrame,
+                    expectedChecksum,
+                    actualChecksum,
+                    inputFrame,
+                    state: (0, canonical_js_1.canonicalize)(config.canonicalizeState?.(session.getState()) ?? session.getState()),
+                };
+                if (config.throwOnMismatch === false) {
+                    return {
+                        frames: session.currentFrame,
+                        checksums: verifiedChecksums,
+                        mismatches: 1,
+                        finalChecksum,
+                        firstMismatch: mismatch,
+                    };
+                }
+                throw new errors_js_1.SyncplayError(`Checksum mismatch at frame ${session.currentFrame}: expected ${expectedChecksum}, actual ${actualChecksum}`, { code: 'replay.checksum-mismatch', frame: session.currentFrame });
+            }
+        }
+    }
+    if (verifiedChecksums !== replay.checksums.length) {
+        throw new errors_js_1.SyncplayError(`Replay contained ${replay.checksums.length - verifiedChecksums} checksum records beyond verified input frames`, { code: 'replay.unverified-checksum', frame: session.currentFrame });
+    }
+    return {
+        frames: session.currentFrame,
+        checksums: verifiedChecksums,
+        mismatches: 0,
+        finalChecksum,
+    };
+}
+function verifyReplayWithDescriptor(config) {
+    const artifacts = (0, schema_artifacts_js_1.createSchemaArtifacts)(config.descriptor);
+    return verifyReplay({
+        replay: config.replay,
+        step: config.step,
+        defaultInput: config.defaultInput,
+        // The CONTENT-HASHED identity, not the author label: runtimes stamp
+        // replayIdentity.* into exported replays (a field edit without a label
+        // bump must change the identity), so the descriptor-derived verifier must
+        // compare the same form or every defineSyncplayGame replay fails identity.
+        inputSchemaId: artifacts.descriptor.replayIdentity.inputSchemaId,
+        stateSchemaId: artifacts.descriptor.replayIdentity.stateSchemaId,
+        deterministicVersion: artifacts.descriptor.deterministicVersion,
+        canonicalizeInput(input) {
+            return artifacts.canonicalizeInput(input);
+        },
+        canonicalizeState(state) {
+            return artifacts.canonicalizeState(state);
+        },
+        checksum(state) {
+            return artifacts.checksumState(state);
+        },
+        serializeState(state) {
+            return artifacts.serializeState(state);
+        },
+        deserializeState(bytes) {
+            return artifacts.deserializeState(bytes);
+        },
+        hydrateInput: config.hydrateInput,
+        throwOnMismatch: config.throwOnMismatch,
+    });
+}
+function assertReplayFileStructure(replay) {
+    if (replay.formatVersion !== 1) {
+        throw new errors_js_1.SyncplayError(`Unsupported replay format ${replay.formatVersion}`, {
+            code: 'replay.format-version',
+        });
+    }
+    assertReplayCanonicalValue(replay.initialState, 'Replay initialState is not a valid canonical value', {});
+    for (const inputFrame of replay.inputFrames) {
+        if (inputFrame.inputs.length !== replay.playerCount) {
+            throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} has ${inputFrame.inputs.length} inputs, expected ${replay.playerCount}`, {
+                code: 'replay.input-count',
+                frame: inputFrame.frame,
+            });
+        }
+        validateInputFlags(replay, inputFrame);
+        inputFrame.inputs.forEach((input, slot) => assertReplayCanonicalValue(input, `Replay frame ${inputFrame.frame} input ${slot} is not a valid canonical value`, { frame: inputFrame.frame, slot }));
+    }
+    for (const commandFrame of replay.commandHistory ?? []) {
+        if (!Number.isInteger(commandFrame.frame) || commandFrame.frame < 0 || commandFrame.frame >= replay.inputFrames.length) {
+            throw new errors_js_1.SyncplayError(`Replay command frame ${commandFrame.frame} is outside replay input history`, {
+                code: 'replay.command-frame-gap',
+                frame: commandFrame.frame,
+            });
+        }
+        for (const command of commandFrame.commands) {
+            const canonicalCommand = command;
+            assertReplayCanonicalValue(canonicalCommand, `Replay command frame ${commandFrame.frame} contains a non-canonical command`, { frame: commandFrame.frame });
+        }
+    }
+}
+function assertReplayIdentity(config) {
+    const replay = config.replay;
+    const checks = [
+        ['deterministicVersion', config.deterministicVersion, replay.deterministicVersion],
+        ['inputSchemaId', config.inputSchemaId, replay.inputSchemaId],
+        ['stateSchemaId', config.stateSchemaId, replay.stateSchemaId],
+        ['engineIdentityHash', config.engineIdentityHash, replay.engineIdentityHash],
+        ['assetDbHash', config.assetDbHash, replay.assetDbHash],
+        ['configHash', config.configHash, replay.configHash],
+    ];
+    for (const [field, actual, expected] of checks) {
+        if (actual === undefined || expected === undefined) {
+            continue;
+        }
+        if (actual !== expected) {
+            throw new errors_js_1.SyncplayError(`Replay ${field} mismatch: expected ${expected}, actual ${actual}`, {
+                code: 'replay.identity-mismatch',
+            });
+        }
+    }
+}
+function validateInputFlags(replay, inputFrame) {
+    if (inputFrame.inputFlags === undefined) {
+        return;
+    }
+    if (inputFrame.inputFlags.length !== replay.playerCount) {
+        throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} has ${inputFrame.inputFlags.length} input flag records, expected ${replay.playerCount}`, {
+            code: 'replay.input-flag-count',
+            frame: inputFrame.frame,
+        });
+    }
+    const commandSlots = new Set();
+    for (const commandFrame of replay.commandHistory ?? []) {
+        if (commandFrame.frame !== inputFrame.frame) {
+            continue;
+        }
+        for (const command of commandFrame.commands) {
+            if (!isCanonicalReplayValue(command)) {
+                continue;
+            }
+            let decoded;
+            try {
+                decoded = (0, canonical_js_1.decodeCanonicalValue)(command);
+            }
+            catch {
+                continue;
+            }
+            if (isRecord(decoded) && typeof decoded.slot === 'number') {
+                commandSlots.add(decoded.slot);
+            }
+        }
+    }
+    inputFrame.inputFlags.forEach((flags, slot) => {
+        if (flags.slot !== slot) {
+            throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} input flags slot ${flags.slot} do not match index ${slot}`, {
+                code: 'replay.input-flag-slot',
+                frame: inputFrame.frame,
+                slot,
+            });
+        }
+        if (flags.playerPresent !== true && flags.playerPresent !== false) {
+            throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} input flags for slot ${slot} have invalid playerPresent`, {
+                code: 'replay.input-flag-value',
+                frame: inputFrame.frame,
+                slot,
+            });
+        }
+        if (flags.playerPresent === false && flags.replacedByServer === true) {
+            throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} input flags for slot ${slot} cannot be absent and server-replaced`, {
+                code: 'replay.input-flag-conflict',
+                frame: inputFrame.frame,
+                slot,
+            });
+        }
+        if (flags.commandInput !== commandSlots.has(slot)) {
+            throw new errors_js_1.SyncplayError(`Replay frame ${inputFrame.frame} input command flag for slot ${slot} does not match command history`, {
+                code: 'replay.input-flag-command',
+                frame: inputFrame.frame,
+                slot,
+            });
+        }
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertReplayCanonicalValue(value, message, options) {
+    try {
+        if (!isCanonicalReplayValue(value)) {
+            throw new Error('not canonical');
+        }
+        (0, canonical_js_1.decodeCanonicalValue)(value);
+    }
+    catch {
+        throw new errors_js_1.SyncplayError(message, {
+            code: 'replay.canonical-value',
+            frame: options.frame,
+            slot: options.slot,
+        });
+    }
+}
+function isCanonicalReplayValue(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string') {
+        return true;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && !Object.is(value, -0);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isCanonicalReplayValue(item));
+    }
+    if (!isRecord(value) || Object.getPrototypeOf(value) !== Object.prototype) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(value, '$rdm')) {
+        return isCanonicalReplayTag(value);
+    }
+    if (!replayObjectKeysAreCanonical(value)) {
+        return false;
+    }
+    return replayObjectKeys(value).every((key) => isCanonicalReplayValue(value[key]));
+}
+function isCanonicalReplayTag(value) {
+    const tag = value.$rdm;
+    if (typeof tag !== 'string') {
+        return false;
+    }
+    switch (tag) {
+        case 'nan':
+        case 'infinity':
+        case 'negative-infinity':
+        case 'negative-zero':
+        case 'undefined':
+            return hasExactReplayTagKeys(value, ['$rdm']);
+        case 'bigint':
+            return hasExactReplayTagKeys(value, ['$rdm', 'value']) && typeof value.value === 'string';
+        case 'map':
+            return hasExactReplayTagKeys(value, ['$rdm', 'entries']) &&
+                Array.isArray(value.entries) &&
+                value.entries.every((entry) => Array.isArray(entry) &&
+                    entry.length === 2 &&
+                    isCanonicalReplayValue(entry[0]) &&
+                    isCanonicalReplayValue(entry[1])) &&
+                replayMapEntriesAreCanonical(value.entries);
+        case 'set':
+            return hasExactReplayTagKeys(value, ['$rdm', 'values']) &&
+                Array.isArray(value.values) &&
+                value.values.every((entry) => isCanonicalReplayValue(entry)) &&
+                replaySetValuesAreCanonical(value.values);
+        case 'typed-array':
+            return hasExactReplayTagKeys(value, ['$rdm', 'constructor', 'bytes']) &&
+                typeof value.constructor === 'string' &&
+                Array.isArray(value.bytes) &&
+                value.bytes.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255);
+        default:
+            return false;
+    }
+}
+function hasExactReplayTagKeys(value, expectedKeys) {
+    const actual = replayObjectKeys(value);
+    if (actual.length !== expectedKeys.length) {
+        return false;
+    }
+    return actual.every((key, index) => key === expectedKeys[index]);
+}
+function replayObjectKeysAreCanonical(value) {
+    const actual = replayObjectKeys(value);
+    const expected = [...actual].sort(compareStrings);
+    return actual.every((key, index) => key === expected[index]);
+}
+function replayObjectKeys(value) {
+    // rdm-ignore-next-line determinism/no-object-key-order: replay canonical validation intentionally reads encoded object key order before comparing it to canonical order
+    return Object.keys(value);
+}
+function replayMapEntriesAreCanonical(entries) {
+    let previousKeyText;
+    for (const entry of entries) {
+        const key = entry[0];
+        const keyText = canonicalReplaySortText(key);
+        if (keyText === undefined) {
+            return false;
+        }
+        if (previousKeyText !== undefined && previousKeyText > keyText) {
+            return false;
+        }
+        previousKeyText = keyText;
+    }
+    return true;
+}
+function replaySetValuesAreCanonical(values) {
+    let previousValueText;
+    for (const value of values) {
+        const canonicalValue = value;
+        const valueText = canonicalReplaySortText(canonicalValue);
+        if (valueText === undefined) {
+            return false;
+        }
+        if (previousValueText !== undefined && previousValueText > valueText) {
+            return false;
+        }
+        previousValueText = valueText;
+    }
+    return true;
+}
+function canonicalReplaySortText(value) {
+    try {
+        return (0, canonical_js_1.canonicalStringify)((0, canonical_js_1.decodeCanonicalValue)(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}