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

package/dist/replay-bundle.js

@@ -0,0 +1,1586 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+import { createDeterministicFrameRuntime, createDeterministicSparseSetFrameRuntime, } from './engine-runtime.js';
+export function createDeterministicReplayBundle(bundle) {
+    assertReplayBundleIdentity(bundle);
+    assertReplayRuntimeManifest(bundle.runtimeReplay);
+    const semanticReplayHash = bundle.semanticReplay === undefined ? bundle.semanticReplayHash : defaultChecksum(bundle.semanticReplay);
+    return cloneCanonical({
+        schemaVersion: 1,
+        ...bundle,
+        ...(semanticReplayHash === undefined ? {} : { semanticReplayHash }),
+        inputHistory: [...bundle.inputHistory].sort((left, right) => left.frame - right.frame),
+        commandHistory: [...bundle.commandHistory].sort((left, right) => left.frame - right.frame),
+        checksums: [...bundle.checksums].sort((left, right) => left.frame - right.frame),
+        debugEvents: [...bundle.debugEvents].sort(compareDebugEvents),
+        snapshots: [...bundle.snapshots].sort((left, right) => left.frame - right.frame),
+    });
+}
+export function createDeterministicReplayRuntimeManifest(source) {
+    const manifest = {
+        descriptor: source.descriptor,
+        descriptorHash: source.descriptorHash ?? defaultChecksum(source.descriptor),
+        systemId: source.systemId,
+        beforeFrameId: source.beforeFrameId,
+        systemsSourceHash: source.systemsSourceHash ?? deterministicReplayRuntimeSourceHash(source.systemId, source.beforeFrameId),
+        ...(source.acceptedSystemsSourceHashes === undefined ? {} : {
+            acceptedSystemsSourceHashes: [...source.acceptedSystemsSourceHashes].sort(compareStrings),
+        }),
+        seed: source.seed ?? 1,
+        ...(source.sparse === undefined ? {} : { sparse: source.sparse }),
+    };
+    return {
+        ...manifest,
+        manifestHash: deterministicReplayRuntimeManifestHash(manifest),
+    };
+}
+export function verifyDeterministicReplayBundle(bundle, expected) {
+    const bundleHash = defaultChecksum(bundle);
+    const bundleRecord = bundle !== null && typeof bundle === 'object' && !Array.isArray(bundle)
+        ? bundle
+        : {};
+    const inputHistory = Array.isArray(bundleRecord.inputHistory) ? bundleRecord.inputHistory : [];
+    const commandHistory = Array.isArray(bundleRecord.commandHistory) ? bundleRecord.commandHistory : [];
+    const checksums = Array.isArray(bundleRecord.checksums) ? bundleRecord.checksums : [];
+    const debugEvents = Array.isArray(bundleRecord.debugEvents) ? bundleRecord.debugEvents : [];
+    const snapshots = Array.isArray(bundleRecord.snapshots) ? bundleRecord.snapshots : [];
+    const snapshotBytes = snapshots.reduce((sum, snapshot) => sum + snapshot.bytes.length, 0);
+    const inputCount = inputHistory.reduce((sum, inputFrame) => sum + inputFrame.inputs.length, 0);
+    const commandCount = commandHistory.reduce((sum, commandFrame) => sum + commandFrame.commands.length, 0);
+    const base = {
+        bundleHash,
+        replayBytes: canonicalStringify(bundle).length,
+        snapshotBytes,
+        inputCount,
+        checksumCount: checksums.length,
+        commandCount,
+        debugEventCount: debugEvents.length,
+        semanticReplayExecuted: false,
+        semanticReplayFrames: 0,
+    };
+    const shapeMismatch = findReplayBundleShapeMismatch(bundle);
+    if (shapeMismatch !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: shapeMismatch };
+    }
+    if (bundle.schemaVersion !== 1) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: {
+                frame: 0,
+                subsystem: 'replay-bundle',
+                path: 'schemaVersion',
+                expectedChecksum: '1',
+                actualChecksum: String(bundle.schemaVersion),
+                minimalReproPath: 'artifacts/replays/replay-min-schema-version.json',
+            },
+        };
+    }
+    const identityMismatch = findIdentityMismatch(bundle, expected);
+    if (identityMismatch !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: identityMismatch };
+    }
+    const missingSection = findMissingRequiredSection(bundle, inputCount, commandCount);
+    if (missingSection !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: missingSection };
+    }
+    const duplicateFrame = findDuplicateFrameRecord(bundle);
+    if (duplicateFrame !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: duplicateFrame };
+    }
+    const invalidSlice = findInvalidReplaySlice(bundle);
+    if (invalidSlice !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: invalidSlice };
+    }
+    const nonContiguousFullHistory = findNonContiguousFullHistory(bundle);
+    if (nonContiguousFullHistory !== undefined) {
+        return { ...base, result: 'fail', firstMismatch: nonContiguousFullHistory };
+    }
+    const checksumByFrame = new Map(bundle.checksums.map((checksum) => [checksum.frame, checksum.checksum]));
+    const snapshotByFrame = new Map(bundle.snapshots.map((snapshot) => [snapshot.frame, snapshot]));
+    for (const checksum of bundle.checksums) {
+        if (!snapshotByFrame.has(checksum.frame)) {
+            return {
+                ...base,
+                result: 'fail',
+                firstMismatch: {
+                    frame: checksum.frame,
+                    subsystem: 'replay-bundle',
+                    path: `checksums[frame=${checksum.frame}]`,
+                    expectedChecksum: checksum.checksum,
+                    actualChecksum: 'missing-snapshot',
+                    minimalReproPath: `artifacts/replays/replay-min-${checksum.frame}.json`,
+                },
+            };
+        }
+    }
+    for (const snapshot of bundle.snapshots) {
+        const parsedSnapshot = parseSnapshotBytes(snapshot);
+        if (parsedSnapshot === undefined || parsedSnapshot.frame !== snapshot.frame) {
+            return {
+                ...base,
+                result: 'fail',
+                firstMismatch: {
+                    frame: snapshot.frame,
+                    subsystem: 'snapshot',
+                    path: `snapshots[frame=${snapshot.frame}].bytes.frame`,
+                    expectedChecksum: String(snapshot.frame),
+                    actualChecksum: parsedSnapshot === undefined ? 'unparseable' : String(parsedSnapshot.frame),
+                    minimalReproPath: `artifacts/replays/replay-min-${snapshot.frame}.json`,
+                },
+            };
+        }
+        const actualSnapshotChecksum = defaultChecksum(snapshot.bytes);
+        if (actualSnapshotChecksum !== snapshot.checksum) {
+            return {
+                ...base,
+                result: 'fail',
+                firstMismatch: {
+                    frame: snapshot.frame,
+                    subsystem: 'snapshot',
+                    path: `snapshots[frame=${snapshot.frame}].bytes`,
+                    expectedChecksum: snapshot.checksum,
+                    actualChecksum: actualSnapshotChecksum,
+                    minimalReproPath: `artifacts/replays/replay-min-${snapshot.frame}.json`,
+                },
+            };
+        }
+        const expectedChecksum = checksumByFrame.get(snapshot.frame);
+        if (expectedChecksum === undefined) {
+            return {
+                ...base,
+                result: 'fail',
+                firstMismatch: {
+                    frame: snapshot.frame,
+                    subsystem: 'replay-bundle',
+                    path: `snapshots[frame=${snapshot.frame}]`,
+                    expectedChecksum: 'checksum-present',
+                    actualChecksum: 'missing',
+                    minimalReproPath: `artifacts/replays/replay-min-${snapshot.frame}.json`,
+                },
+            };
+        }
+        if (expectedChecksum !== snapshot.checksum) {
+            return {
+                ...base,
+                result: 'fail',
+                firstMismatch: {
+                    frame: snapshot.frame,
+                    subsystem: 'snapshot',
+                    path: `snapshots[frame=${snapshot.frame}].checksum`,
+                    expectedChecksum,
+                    actualChecksum: snapshot.checksum,
+                    minimalReproPath: `artifacts/replays/replay-min-${snapshot.frame}.json`,
+                },
+            };
+        }
+    }
+    const semantic = verifySemanticReplay(bundle, expected);
+    if (semantic.mismatch !== undefined) {
+        return {
+            ...base,
+            semanticReplayExecuted: semantic.executed,
+            semanticReplayFrames: semantic.frames,
+            result: 'fail',
+            firstMismatch: semantic.mismatch,
+        };
+    }
+    if (semantic.required === true && semantic.executed === false) {
+        return {
+            ...base,
+            semanticReplayExecuted: false,
+            semanticReplayFrames: 0,
+            result: 'fail',
+            firstMismatch: {
+                frame: bundle.snapshots[0].frame,
+                subsystem: 'semantic-replay',
+                path: 'snapshots',
+                expectedChecksum: 'semantic-replayable-snapshot',
+                actualChecksum: 'missing-positions',
+                minimalReproPath: 'artifacts/replays/replay-min-semantic.json',
+            },
+        };
+    }
+    return { ...base, semanticReplayExecuted: semantic.executed, semanticReplayFrames: semantic.frames, result: 'pass' };
+}
+function findReplayBundleShapeMismatch(bundle) {
+    if (bundle === null || typeof bundle !== 'object' || Array.isArray(bundle)) {
+        return replayShapeMismatch('', 'object', typeof bundle);
+    }
+    const fields = [
+        { path: 'schemaVersion', expected: 'number' },
+        { path: 'runtimeVersion', expected: 'string' },
+        { path: 'engineHash', expected: 'string' },
+        { path: 'schemaHash', expected: 'string' },
+        { path: 'assetDbHash', expected: 'string' },
+        { path: 'configHash', expected: 'string' },
+        { path: 'sampleId', expected: 'string' },
+        { path: 'inputHistory', expected: 'array' },
+        { path: 'commandHistory', expected: 'array' },
+        { path: 'checksums', expected: 'array' },
+        { path: 'debugEvents', expected: 'array' },
+        { path: 'snapshots', expected: 'array' },
+        { path: 'metadata', expected: 'object' },
+    ];
+    for (const field of fields) {
+        const value = bundle[field.path];
+        if (field.expected === 'array') {
+            if (!Array.isArray(value)) {
+                return replayShapeMismatch(String(field.path), field.expected, replayShapeOf(value));
+            }
+            continue;
+        }
+        if (field.expected === 'object') {
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                return replayShapeMismatch(String(field.path), field.expected, replayShapeOf(value));
+            }
+            continue;
+        }
+        if (typeof value !== field.expected) {
+            return replayShapeMismatch(String(field.path), field.expected, replayShapeOf(value));
+        }
+    }
+    return undefined;
+}
+function replayShapeMismatch(path, expected, actual) {
+    return {
+        frame: 0,
+        subsystem: 'replay-bundle',
+        path,
+        expectedChecksum: expected,
+        actualChecksum: actual,
+        minimalReproPath: 'artifacts/replays/replay-min-shape.json',
+    };
+}
+function replayShapeOf(value) {
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    return typeof value;
+}
+export function verifyDeterministicFrameRuntimeReplayBundle(bundle, options) {
+    const bundleHash = defaultChecksum(bundle);
+    const snapshots = [...bundle.snapshots].sort((left, right) => left.frame - right.frame);
+    const baseline = snapshots[0];
+    const finalFrame = snapshots.at(-1)?.frame ?? -1;
+    const base = {
+        bundleHash,
+        frames: 0,
+        baselineFrame: baseline?.frame ?? -1,
+        finalFrame,
+        finalChecksum: '',
+    };
+    const manifestMismatch = findRuntimeManifestIdentityMismatch(bundle.runtimeReplay, options);
+    if (manifestMismatch !== undefined) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: manifestMismatch,
+        };
+    }
+    if (baseline === undefined) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: runtimeReplayMismatch(0, 'snapshots', 'baseline-snapshot', 'missing'),
+        };
+    }
+    const runtime = options.sparse === true
+        ? createDeterministicSparseSetFrameRuntime(options.descriptor, options.seed ?? 1)
+        : createDeterministicFrameRuntime(options.descriptor, options.seed ?? 1);
+    const baselineSnapshot = frameSnapshotFromReplaySnapshot(baseline);
+    if (baselineSnapshot === undefined) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: runtimeReplayMismatch(baseline.frame, `snapshots[frame=${baseline.frame}].bytes`, 'frame-runtime-snapshot', 'unparseable'),
+        };
+    }
+    try {
+        runtime.restore(baselineSnapshot);
+    }
+    catch (error) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: runtimeReplayMismatch(baseline.frame, `snapshots[frame=${baseline.frame}].restore`, 'restorable-frame-runtime-snapshot', String(error)),
+        };
+    }
+    const snapshotByFrame = new Map(snapshots.map((snapshot) => [snapshot.frame, snapshot]));
+    const inputByFrame = new Map(bundle.inputHistory.map((frame) => [frame.frame, frame.inputs]));
+    const commandByFrame = new Map(bundle.commandHistory.map((frame) => [frame.frame, frame.commands]));
+    let comparedFrames = 0;
+    const baselineMismatch = compareRuntimeSnapshot(runtime.snapshot(), baseline);
+    /* istanbul ignore next -- runtime.restore validates the snapshot bytes/checksum before this post-restore parity guard. */
+    if (baselineMismatch !== undefined) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: baselineMismatch,
+        };
+    }
+    comparedFrames += 1;
+    for (let frame = baseline.frame; frame < finalFrame; frame += 1) {
+        options.beforeFrame?.(runtime, frame, inputByFrame.get(frame) ?? [], commandByFrame.get(frame) ?? []);
+        runtime.step(options.systems);
+        const expectedSnapshot = snapshotByFrame.get(runtime.frame);
+        if (expectedSnapshot === undefined) {
+            continue;
+        }
+        comparedFrames += 1;
+        const mismatch = compareRuntimeSnapshot(runtime.snapshot(), expectedSnapshot);
+        if (mismatch !== undefined) {
+            return {
+                ...base,
+                frames: comparedFrames,
+                finalChecksum: runtime.snapshot().checksum,
+                result: 'fail',
+                firstMismatch: mismatch,
+            };
+        }
+    }
+    return {
+        ...base,
+        frames: comparedFrames,
+        finalChecksum: runtime.snapshot().checksum,
+        result: 'pass',
+    };
+}
+export function verifyDeterministicSelfContainedFrameRuntimeReplayBundle(bundle, options = {}) {
+    const bundleHash = defaultChecksum(bundle);
+    const snapshots = [...bundle.snapshots].sort((left, right) => left.frame - right.frame);
+    const baseline = snapshots[0];
+    const base = {
+        bundleHash,
+        frames: 0,
+        baselineFrame: baseline?.frame ?? -1,
+        finalFrame: snapshots.at(-1)?.frame ?? -1,
+        finalChecksum: '',
+    };
+    const manifest = bundle.runtimeReplay;
+    if (manifest === undefined) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: runtimeReplayMismatch(0, 'runtimeReplay', 'embedded-runtime-manifest', 'missing'),
+        };
+    }
+    const expectedManifestHash = deterministicReplayRuntimeManifestHash(manifest);
+    if (manifest.manifestHash !== expectedManifestHash) {
+        return {
+            ...base,
+            result: 'fail',
+            firstMismatch: runtimeReplayMismatch(0, 'runtimeReplay.manifestHash', expectedManifestHash, manifest.manifestHash),
+        };
+    }
+    return verifyDeterministicFrameRuntimeReplayBundle(bundle, {
+        descriptor: manifest.descriptor,
+        systems: deterministicReplayRuntimeSystems(manifest.systemId),
+        descriptorHash: manifest.descriptorHash,
+        systemsSourceHash: deterministicReplayRuntimeSourceHash(manifest.systemId, manifest.beforeFrameId),
+        requireRuntimeIdentity: true,
+        seed: manifest.seed,
+        sparse: options.sparse ?? manifest.sparse,
+        beforeFrame: deterministicReplayRuntimeBeforeFrame(manifest.beforeFrameId),
+    });
+}
+function findDuplicateFrameRecord(bundle) {
+    return findDuplicateFrame(bundle.inputHistory.map((frame) => frame.frame), 'inputHistory')
+        ?? findDuplicateFrame(bundle.commandHistory.map((frame) => frame.frame), 'commandHistory')
+        ?? findDuplicateFrame(bundle.checksums.map((checksum) => checksum.frame), 'checksums')
+        ?? findDuplicateFrame(bundle.snapshots.map((snapshot) => snapshot.frame), 'snapshots')
+        ?? findDuplicateFrame(bundle.debugEvents.map((event) => `${event.type}:${event.frame}`), 'debugEvents');
+}
+function frameSnapshotFromReplaySnapshot(snapshot) {
+    const parsed = parseSnapshotBytes(snapshot);
+    if (!isCanonicalRecord(parsed)) {
+        return undefined;
+    }
+    const record = parsed;
+    if (typeof record.frame !== 'number' ||
+        typeof record.nextEntityId !== 'number' ||
+        !Array.isArray(record.freeEntityIds) ||
+        !isCanonicalRecord(record.generations) ||
+        !isCanonicalRecord(record.components) ||
+        !isCanonicalRecord(record.singletonComponents) ||
+        !Array.isArray(record.debugEvents) ||
+        typeof record.randomState !== 'number') {
+        return undefined;
+    }
+    const frameHeap = isCanonicalRecord(record.frameHeap)
+        ? record.frameHeap
+        : { nextHandleId: 1, freeHandleIds: [], generations: {}, collections: {} };
+    return {
+        frame: record.frame,
+        nextEntityId: record.nextEntityId,
+        freeEntityIds: record.freeEntityIds.filter((value) => typeof value === 'number'),
+        generations: record.generations,
+        components: record.components,
+        singletonComponents: record.singletonComponents,
+        frameHeap,
+        debugEvents: record.debugEvents,
+        runtimeEvents: Array.isArray(record.runtimeEvents)
+            ? record.runtimeEvents
+            : [],
+        runtimeSignals: Array.isArray(record.runtimeSignals)
+            ? record.runtimeSignals
+            : [],
+        dispatchedSignals: Array.isArray(record.dispatchedSignals)
+            ? record.dispatchedSignals
+            : [],
+        nextRuntimeMessageSequence: typeof record.nextRuntimeMessageSequence === 'number'
+            ? record.nextRuntimeMessageSequence
+            : 0,
+        ...(isCanonicalRecord(record.commandTimeline) ? { commandTimeline: record.commandTimeline } : {}),
+        randomState: record.randomState,
+        bytes: snapshot.bytes,
+        checksum: snapshot.checksum,
+    };
+}
+function compareRuntimeSnapshot(actual, expected) {
+    if (actual.bytes === expected.bytes && actual.checksum === expected.checksum) {
+        return undefined;
+    }
+    return runtimeReplayMismatch(expected.frame, `snapshots[frame=${expected.frame}].frame-runtime`, expected.checksum, actual.checksum);
+}
+function runtimeReplayMismatch(frame, path, expectedChecksum, actualChecksum) {
+    return {
+        frame,
+        subsystem: 'frame-runtime-replay',
+        path,
+        expectedChecksum,
+        actualChecksum,
+        minimalReproPath: `artifacts/replays/frame-runtime-replay-min-${frame}.json`,
+    };
+}
+function findNonContiguousFullHistory(bundle) {
+    if (bundle.metadata.replaySlice === true || bundle.metadata.checkpointBundle === true) {
+        return undefined;
+    }
+    return findMissingFrame(bundle.inputHistory.map((frame) => frame.frame), 'inputHistory')
+        ?? findMissingFrame(bundle.checksums.map((checksum) => checksum.frame), 'checksums')
+        ?? findMissingFrame(bundle.snapshots.map((snapshot) => snapshot.frame), 'snapshots');
+}
+function findInvalidReplaySlice(bundle) {
+    if (bundle.metadata.replaySlice !== true) {
+        return undefined;
+    }
+    const origin = bundle.sliceOrigin;
+    const sliceStartFrame = typeof bundle.metadata.sliceStartFrame === 'number' ? bundle.metadata.sliceStartFrame : undefined;
+    const sliceEndFrame = typeof bundle.metadata.sliceEndFrame === 'number' ? bundle.metadata.sliceEndFrame : undefined;
+    const baselineFrame = typeof bundle.metadata.baselineFrame === 'number' ? bundle.metadata.baselineFrame : undefined;
+    const baselineChecksum = typeof bundle.metadata.baselineChecksum === 'string' ? bundle.metadata.baselineChecksum : undefined;
+    const sourceBundleHash = typeof bundle.metadata.sourceBundleHash === 'string' ? bundle.metadata.sourceBundleHash : undefined;
+    if (origin === undefined) {
+        return replaySliceMismatch(0, 'sliceOrigin', 'self-contained-slice-origin', 'missing');
+    }
+    if (sliceStartFrame !== origin.sliceStartFrame || sliceEndFrame !== origin.sliceEndFrame) {
+        return replaySliceMismatch(origin.sliceStartFrame, 'metadata.sliceStartFrame/sliceEndFrame', `${origin.sliceStartFrame}-${origin.sliceEndFrame}`, `${String(sliceStartFrame)}-${String(sliceEndFrame)}`);
+    }
+    if (sourceBundleHash !== origin.sourceBundleHash) {
+        return replaySliceMismatch(origin.sliceStartFrame, 'metadata.sourceBundleHash', origin.sourceBundleHash, sourceBundleHash ?? 'missing');
+    }
+    if (baselineFrame !== origin.baselineSnapshot.frame || baselineChecksum !== origin.baselineSnapshot.checksum) {
+        return replaySliceMismatch(origin.sliceStartFrame, 'metadata.baseline', `${origin.baselineSnapshot.frame}:${origin.baselineSnapshot.checksum}`, `${String(baselineFrame)}:${baselineChecksum ?? 'missing'}`);
+    }
+    const baselineChecksumActual = defaultChecksum(origin.baselineSnapshot.bytes);
+    if (baselineChecksumActual !== origin.baselineSnapshot.checksum) {
+        return replaySliceMismatch(origin.baselineSnapshot.frame, 'sliceOrigin.baselineSnapshot.bytes', origin.baselineSnapshot.checksum, baselineChecksumActual);
+    }
+    const parsedBaseline = parseSnapshotBytes(origin.baselineSnapshot);
+    if (parsedBaseline === undefined || parsedBaseline.frame !== origin.baselineSnapshot.frame) {
+        return replaySliceMismatch(origin.baselineSnapshot.frame, 'sliceOrigin.baselineSnapshot.bytes.frame', String(origin.baselineSnapshot.frame), parsedBaseline === undefined ? 'unparseable' : String(parsedBaseline.frame));
+    }
+    const firstChecksumFrame = bundle.checksums[0]?.frame;
+    const lastChecksumFrame = bundle.checksums.at(-1)?.frame;
+    if (firstChecksumFrame !== origin.sliceStartFrame || lastChecksumFrame !== origin.sliceEndFrame) {
+        return replaySliceMismatch(origin.sliceStartFrame, 'checksums.frameRange', `${origin.sliceStartFrame}-${origin.sliceEndFrame}`, `${String(firstChecksumFrame)}-${String(lastChecksumFrame)}`);
+    }
+    if (origin.baselineSnapshot.frame > origin.sliceStartFrame) {
+        return replaySliceMismatch(origin.sliceStartFrame, 'sliceOrigin.baselineSnapshot.frame', `<=${origin.sliceStartFrame}`, String(origin.baselineSnapshot.frame));
+    }
+    return undefined;
+}
+function replaySliceMismatch(frame, path, expectedChecksum, actualChecksum) {
+    return {
+        frame,
+        subsystem: 'replay-slice',
+        path,
+        expectedChecksum,
+        actualChecksum,
+        minimalReproPath: `artifacts/replays/replay-slice-min-${frame}.json`,
+    };
+}
+function findMissingFrame(frames, section) {
+    if (frames.length === 0) {
+        return undefined;
+    }
+    const sortedFrames = [...frames].sort((left, right) => left - right);
+    const startFrame = sortedFrames[0];
+    if (startFrame !== 0) {
+        return {
+            frame: startFrame,
+            subsystem: 'replay-bundle',
+            path: section,
+            expectedChecksum: 'starts-at-frame-0-or-replaySlice',
+            actualChecksum: `starts-at-frame-${startFrame}`,
+            minimalReproPath: `artifacts/replays/replay-noncontiguous-${section}.json`,
+        };
+    }
+    for (let index = 1; index < sortedFrames.length; index += 1) {
+        if (sortedFrames[index] !== sortedFrames[index - 1] + 1) {
+            return {
+                frame: sortedFrames[index],
+                subsystem: 'replay-bundle',
+                path: section,
+                expectedChecksum: `frame-${sortedFrames[index - 1] + 1}`,
+                actualChecksum: `frame-${sortedFrames[index]}`,
+                minimalReproPath: `artifacts/replays/replay-noncontiguous-${section}.json`,
+            };
+        }
+    }
+    return undefined;
+}
+function findDuplicateFrame(frames, section) {
+    const seen = new Set();
+    for (const frame of frames) {
+        if (seen.has(frame)) {
+            return {
+                frame: typeof frame === 'number' ? frame : Number(String(frame).split(':').at(-1)),
+                subsystem: 'replay-bundle',
+                path: section,
+                expectedChecksum: 'unique-frame-records',
+                actualChecksum: `duplicate-${String(frame)}`,
+                minimalReproPath: `artifacts/replays/replay-duplicate-${section}.json`,
+            };
+        }
+        seen.add(frame);
+    }
+    return undefined;
+}
+function parseSnapshotBytes(snapshot) {
+    try {
+        const parsed = JSON.parse(snapshot.bytes);
+        return typeof parsed === 'object' && parsed !== null ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function verifySemanticReplay(bundle, expected) {
+    if (bundle.semanticReplay !== undefined) {
+        const actualSemanticHash = defaultChecksum(bundle.semanticReplay);
+        if (bundle.semanticReplayHash !== actualSemanticHash ||
+            expected?.semanticReplayHash === undefined ||
+            expected.semanticReplayHash !== actualSemanticHash) {
+            return {
+                required: true,
+                executed: false,
+                frames: 0,
+                mismatch: {
+                    frame: bundle.snapshots[0]?.frame ?? 0,
+                    subsystem: 'semantic-replay',
+                    path: 'semanticReplayHash',
+                    expectedChecksum: expected?.semanticReplayHash ?? 'trusted-semantic-replay-hash',
+                    actualChecksum: bundle.semanticReplayHash ?? actualSemanticHash,
+                    minimalReproPath: 'artifacts/replays/replay-min-semantic-hash.json',
+                },
+            };
+        }
+        return verifyOperationModelSemanticReplay(bundle, bundle.semanticReplay);
+    }
+    const semanticSnapshot = bundle.snapshots
+        .map((snapshot) => parseSnapshotBytes(snapshot))
+        .find((snapshot) => Array.isArray(snapshot?.positions) || isCanonicalRecord(snapshot?.components));
+    const required = true;
+    if (semanticSnapshot === undefined) {
+        return { required, executed: false, frames: 0 };
+    }
+    if (isCanonicalRecord(semanticSnapshot.components)) {
+        return verifyComponentSemanticReplay(bundle);
+    }
+    /* istanbul ignore next -- semanticSnapshot reaches this path only through the positions-array predicate; component snapshots return above. */
+    const inferredPlayers = Array.isArray(semanticSnapshot.positions) ? semanticSnapshot.positions.length : undefined;
+    const players = typeof bundle.metadata.players === 'number' ? bundle.metadata.players : inferredPlayers;
+    /* istanbul ignore next -- reaching this branch requires a positions semantic snapshot, so player count is inferred. */
+    if (players === undefined) {
+        return { required, executed: false, frames: 0 };
+    }
+    const inputByFrame = new Map(bundle.inputHistory.map((frame) => [frame.frame, frame.inputs]));
+    const commandByFrame = new Map(bundle.commandHistory.map((frame) => [frame.frame, frame.commands]));
+    const snapshotByFrame = new Map(bundle.snapshots.map((snapshot) => [snapshot.frame, snapshot]));
+    const maxFrame = Math.max(...bundle.snapshots.map((snapshot) => snapshot.frame));
+    const baselineSnapshot = bundle.sliceOrigin?.baselineSnapshot;
+    const parsedBaseline = baselineSnapshot === undefined ? undefined : parseSnapshotBytes(baselineSnapshot);
+    const positions = Array.isArray(parsedBaseline?.positions)
+        ? parsedBaseline.positions.map((value) => typeof value === 'number' ? value : 0)
+        : Array.from({ length: players }, () => 0);
+    while (positions.length < players) {
+        positions.push(0);
+    }
+    let commandScore = typeof parsedBaseline?.commandScore === 'number' ? parsedBaseline.commandScore : 0;
+    let checkedSnapshots = baselineSnapshot !== undefined && snapshotByFrame.has(baselineSnapshot.frame) ? 1 : 0;
+    const startFrame = baselineSnapshot === undefined ? 0 : baselineSnapshot.frame + 1;
+    for (let frame = startFrame; frame <= maxFrame; frame += 1) {
+        for (const input of inputByFrame.get(frame) ?? []) {
+            if (!isCanonicalRecord(input)) {
+                continue;
+            }
+            const slot = canonicalNumber(input, 'slot');
+            if (slot === undefined || slot < 0 || slot >= players) {
+                continue;
+            }
+            positions[slot] += (canonicalNumber(input, 'dx') ?? 0) + (canonicalNumber(input, 'dy') ?? 0);
+        }
+        for (const command of commandByFrame.get(frame) ?? []) {
+            if (!isCanonicalRecord(command)) {
+                continue;
+            }
+            const payload = isCanonicalRecord(command.payload)
+                ? command.payload
+                : {};
+            commandScore += canonicalNumber(payload, 'power') ?? 0;
+        }
+        const snapshot = snapshotByFrame.get(frame);
+        if (snapshot === undefined) {
+            continue;
+        }
+        checkedSnapshots += 1;
+        const expected = canonicalStringify({ frame, positions: [...positions], commandScore });
+        if (snapshot.bytes !== expected) {
+            return {
+                required: true,
+                executed: true,
+                frames: checkedSnapshots,
+                mismatch: {
+                    frame,
+                    subsystem: 'semantic-replay',
+                    path: `snapshots[frame=${frame}].bytes`,
+                    expectedChecksum: defaultChecksum(expected),
+                    actualChecksum: defaultChecksum(snapshot.bytes),
+                    minimalReproPath: `artifacts/replays/replay-min-${frame}.json`,
+                },
+            };
+        }
+    }
+    return { required, executed: true, frames: checkedSnapshots };
+}
+function verifyOperationModelSemanticReplay(bundle, model) {
+    if (model.kind !== 'operation-model-v1') {
+        return { required: true, executed: false, frames: 0 };
+    }
+    const inputByFrame = new Map(bundle.inputHistory.map((frame) => [frame.frame, frame.inputs]));
+    const commandByFrame = new Map(bundle.commandHistory.map((frame) => [frame.frame, frame.commands]));
+    const snapshotByFrame = new Map(bundle.snapshots.map((snapshot) => [snapshot.frame, snapshot]));
+    const maxFrame = Math.max(...bundle.snapshots.map((snapshot) => snapshot.frame));
+    const baselineSnapshot = bundle.sliceOrigin?.baselineSnapshot;
+    const state = baselineSnapshot === undefined
+        ? cloneCanonical(model.initialState)
+        : snapshotStateWithoutFrame(baselineSnapshot);
+    let checkedSnapshots = baselineSnapshot !== undefined && snapshotByFrame.has(baselineSnapshot.frame) ? 1 : 0;
+    const startFrame = baselineSnapshot === undefined ? 0 : baselineSnapshot.frame + 1;
+    for (let frame = startFrame; frame <= maxFrame; frame += 1) {
+        for (const input of inputByFrame.get(frame) ?? []) {
+            applySemanticOperations(state, model.operations, 'input', input);
+        }
+        for (const command of commandByFrame.get(frame) ?? []) {
+            applySemanticOperations(state, model.operations, 'command', command);
+            const payload = isCanonicalRecord(command) && isCanonicalRecord(command.payload) ? command.payload : undefined;
+            if (payload !== undefined) {
+                applySemanticOperations(state, model.operations, 'command.payload', payload);
+            }
+        }
+        const snapshot = snapshotByFrame.get(frame);
+        if (snapshot === undefined) {
+            continue;
+        }
+        checkedSnapshots += 1;
+        const expected = canonicalStringify({ frame, ...stateAsRecord(state) });
+        if (snapshot.bytes !== expected) {
+            return {
+                required: true,
+                executed: true,
+                frames: checkedSnapshots,
+                mismatch: {
+                    frame,
+                    subsystem: 'semantic-replay',
+                    path: `snapshots[frame=${frame}].operation-model`,
+                    expectedChecksum: defaultChecksum(expected),
+                    actualChecksum: defaultChecksum(snapshot.bytes),
+                    minimalReproPath: `artifacts/replays/replay-min-${frame}.json`,
+                },
+            };
+        }
+    }
+    return { required: true, executed: true, frames: checkedSnapshots };
+}
+function applySemanticOperations(state, operations, source, value) {
+    if (!isCanonicalRecord(value)) {
+        return;
+    }
+    for (const operation of operations) {
+        if (operation.source !== source) {
+            continue;
+        }
+        const sourceValue = readPath(value, operation.sourcePath);
+        if (sourceValue === undefined) {
+            continue;
+        }
+        const slot = operation.slotField === undefined ? undefined : canonicalNumber(value, operation.slotField);
+        applyStateOperation(state, operation.targetPath, sourceValue, operation.op, slot);
+    }
+}
+function applyStateOperation(state, targetPath, sourceValue, op, slot) {
+    if (!isCanonicalRecord(state)) {
+        throw new Error('Semantic replay state must be a record');
+    }
+    const arrayMatch = /^([A-Za-z_][A-Za-z0-9_]*)\[\$slot\]$/.exec(targetPath);
+    if (arrayMatch !== null) {
+        if (slot === undefined || !Number.isInteger(slot) || slot < 0) {
+            return;
+        }
+        const array = state[arrayMatch[1]];
+        if (!Array.isArray(array) || slot >= array.length) {
+            return;
+        }
+        const next = op === 'add' ? Number(array[slot] ?? 0) + Number(sourceValue) : sourceValue;
+        array[slot] = next;
+        return;
+    }
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(targetPath)) {
+        return;
+    }
+    const previous = state[targetPath];
+    state[targetPath] = (op === 'add' ? Number(previous ?? 0) + Number(sourceValue) : sourceValue);
+}
+function readPath(value, path) {
+    const parts = path.split('.');
+    let current = value;
+    for (const part of parts) {
+        if (!isCanonicalRecord(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function stateAsRecord(value) {
+    if (!isCanonicalRecord(value)) {
+        throw new Error('Semantic replay state must be a record');
+    }
+    return value;
+}
+function snapshotStateWithoutFrame(snapshot) {
+    const parsed = parseSnapshotBytes(snapshot);
+    if (!isCanonicalRecord(parsed)) {
+        return {};
+    }
+    const record = parsed;
+    return Object.fromEntries(stableKeys(record)
+        .filter((key) => key !== 'frame')
+        .map((key) => [key, cloneCanonical(record[key])]));
+}
+function verifyComponentSemanticReplay(bundle) {
+    const inputByFrame = new Map(bundle.inputHistory.map((frame) => [frame.frame, frame.inputs]));
+    const commandByFrame = new Map(bundle.commandHistory.map((frame) => [frame.frame, frame.commands]));
+    const snapshotByFrame = new Map(bundle.snapshots.map((snapshot) => [snapshot.frame, snapshot]));
+    const maxFrame = Math.max(...bundle.snapshots.map((snapshot) => snapshot.frame));
+    const baselineSnapshot = bundle.sliceOrigin?.baselineSnapshot;
+    const parsedBaseline = baselineSnapshot === undefined ? undefined : parseSnapshotBytes(baselineSnapshot);
+    const components = cloneComponentState(parsedBaseline?.components);
+    let checkedSnapshots = baselineSnapshot !== undefined && snapshotByFrame.has(baselineSnapshot.frame) ? 1 : 0;
+    const startFrame = baselineSnapshot === undefined ? 0 : baselineSnapshot.frame + 1;
+    for (let frame = startFrame; frame <= maxFrame; frame += 1) {
+        for (const input of inputByFrame.get(frame) ?? []) {
+            applyComponentInput(components, input);
+        }
+        for (const command of commandByFrame.get(frame) ?? []) {
+            applyComponentCommand(components, command);
+        }
+        const snapshot = snapshotByFrame.get(frame);
+        if (snapshot === undefined) {
+            continue;
+        }
+        checkedSnapshots += 1;
+        const expected = canonicalStringify({ frame, components });
+        if (snapshot.bytes !== expected) {
+            return {
+                required: true,
+                executed: true,
+                frames: checkedSnapshots,
+                mismatch: {
+                    frame,
+                    subsystem: 'semantic-replay',
+                    path: `snapshots[frame=${frame}].components`,
+                    expectedChecksum: defaultChecksum(expected),
+                    actualChecksum: defaultChecksum(snapshot.bytes),
+                    minimalReproPath: `artifacts/replays/replay-min-${frame}.json`,
+                },
+            };
+        }
+    }
+    return { required: true, executed: true, frames: checkedSnapshots };
+}
+function cloneComponentState(value) {
+    if (!isCanonicalRecord(value)) {
+        return {};
+    }
+    const result = {};
+    const componentState = value;
+    for (const entity of stableKeys(componentState)) {
+        const components = componentState[entity];
+        if (!isCanonicalRecord(components)) {
+            continue;
+        }
+        for (const component of stableKeys(components)) {
+            const fields = components[component];
+            if (!isCanonicalRecord(fields)) {
+                continue;
+            }
+            const target = ensureComponentFields(result, entity, component);
+            for (const field of stableKeys(fields)) {
+                const fieldValue = fields[field];
+                /* istanbul ignore else -- component semantic replay only materializes primitive field values; non-primitives are skipped defensively. */
+                if (typeof fieldValue === 'number' || typeof fieldValue === 'string' || typeof fieldValue === 'boolean') {
+                    target[field] = fieldValue;
+                }
+            }
+        }
+    }
+    return result;
+}
+function applyComponentInput(components, input) {
+    if (!isCanonicalRecord(input)) {
+        return;
+    }
+    const entity = canonicalString(input, 'entity');
+    const component = canonicalString(input, 'component');
+    const field = canonicalString(input, 'field');
+    if (entity === undefined || component === undefined || field === undefined) {
+        return;
+    }
+    const delta = canonicalNumber(input, 'delta');
+    const value = input.value;
+    const fields = ensureComponentFields(components, entity, component);
+    if (delta !== undefined) {
+        const current = typeof fields[field] === 'number' ? fields[field] : 0;
+        fields[field] = current + delta;
+    }
+    else if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
+        fields[field] = value;
+    }
+}
+function applyComponentCommand(components, command) {
+    if (!isCanonicalRecord(command)) {
+        return;
+    }
+    const payload = isCanonicalRecord(command.payload) ? command.payload : command;
+    applyComponentInput(components, payload);
+}
+function ensureComponentFields(components, entity, component) {
+    components[entity] ??= {};
+    components[entity][component] ??= {};
+    return components[entity][component];
+}
+function isCanonicalRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function canonicalNumber(record, key) {
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function canonicalString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function findMissingRequiredSection(bundle, inputCount, _commandCount) {
+    if (bundle.inputHistory.length === 0 || inputCount === 0) {
+        return missingSectionMismatch('input-history');
+    }
+    if (bundle.checksums.length === 0) {
+        return missingSectionMismatch('checksums');
+    }
+    if (bundle.debugEvents.length === 0) {
+        return missingSectionMismatch('debug-events');
+    }
+    if (bundle.snapshots.length === 0 || bundle.snapshots.every((snapshot) => snapshot.bytes.length === 0)) {
+        return missingSectionMismatch('snapshots');
+    }
+    return undefined;
+}
+function missingSectionMismatch(section) {
+    return {
+        frame: 0,
+        subsystem: 'replay-bundle',
+        path: section,
+        expectedChecksum: 'present',
+        actualChecksum: 'missing',
+        minimalReproPath: `artifacts/replays/replay-missing-${section}.json`,
+    };
+}
+export function minimizeDeterministicReplayDesync(expected, actual) {
+    return locateDeterministicReplayDesync(expected, actual).mismatch;
+}
+function locateDeterministicReplayDesync(expected, actual) {
+    const frames = [...new Set([
+            ...expected.checksums.map((checksum) => checksum.frame),
+            ...actual.checksums.map((checksum) => checksum.frame),
+        ])].sort((left, right) => left - right);
+    const expectedByFrame = new Map(expected.checksums.map((checksum) => [checksum.frame, checksum.checksum]));
+    const actualByFrame = new Map(actual.checksums.map((checksum) => [checksum.frame, checksum.checksum]));
+    let searchSteps = 0;
+    for (const frame of frames) {
+        searchSteps += 1;
+        if (expectedByFrame.get(frame) === actualByFrame.get(frame)) {
+            continue;
+        }
+        return {
+            searchSteps,
+            mismatch: {
+                frame,
+                subsystem: firstSubsystemAtFrame(actual, frame),
+                path: `checksums[frame=${frame}]`,
+                expectedChecksum: expectedByFrame.get(frame) ?? 'missing',
+                actualChecksum: actualByFrame.get(frame) ?? 'missing',
+                minimalReproPath: `artifacts/replays/replay-min-${frame}.json`,
+            },
+        };
+    }
+    return { searchSteps };
+}
+export function minimizeDeterministicReplayDesyncBundle(expected, actual) {
+    const located = locateDeterministicReplayDesync(expected, actual);
+    if (located.mismatch === undefined) {
+        return undefined;
+    }
+    const mismatch = located.mismatch;
+    const expectedIdentity = replayIdentity(actual);
+    let minimized = firstVerifierConsumableSlice(actual, mismatch, expectedIdentity);
+    minimized = reduceReplayBundleRecords(minimized, mismatch, expectedIdentity, 'inputHistory');
+    minimized = reduceReplayBundleRecords(minimized, mismatch, expectedIdentity, 'commandHistory');
+    minimized = reduceReplayBundleDebugEvents(minimized, mismatch, expectedIdentity);
+    const verifier = verifyDeterministicReplayBundle(minimized, expectedIdentity);
+    return {
+        mismatch,
+        bundle: minimized,
+        verifier,
+        searchSteps: located.searchSteps,
+        originalReplayBytes: canonicalStringify(actual).length,
+        minimizedReplayBytes: canonicalStringify(minimized).length,
+        removedInputFrames: actual.inputHistory.length - minimized.inputHistory.length,
+        removedInputs: countReplayInputs(actual) - countReplayInputs(minimized),
+        removedCommandFrames: actual.commandHistory.length - minimized.commandHistory.length,
+        removedCommands: countReplayCommands(actual) - countReplayCommands(minimized),
+        removedDebugEvents: actual.debugEvents.length - minimized.debugEvents.length,
+        removedSnapshots: actual.snapshots.length - minimized.snapshots.length,
+        removedChecksumFrames: actual.checksums.length - minimized.checksums.length,
+    };
+}
+export function createDeterministicReplayDebugTables(events) {
+    const table = (type) => events
+        .filter((event) => event.type.startsWith(type))
+        .sort(compareDebugEvents)
+        .map((event) => event.payload);
+    const tables = {
+        ecs: table('ecs'),
+        physics: table('physics'),
+        navigation: table('navigation'),
+        commands: table('command'),
+        events: table('event'),
+        rng: table('rng'),
+        assets: table('asset'),
+        timings: table('timing'),
+    };
+    return {
+        ...tables,
+        checksum: defaultChecksum(tables),
+    };
+}
+export function sliceDeterministicReplayBundle(bundle, startFrame, endFrame) {
+    if (endFrame < startFrame) {
+        throw new Error('Replay slice end frame must be >= start frame');
+    }
+    const baselineSnapshot = [...bundle.snapshots]
+        .filter((snapshot) => snapshot.frame <= startFrame)
+        .sort((left, right) => right.frame - left.frame)[0];
+    if (baselineSnapshot === undefined) {
+        throw new Error(`Replay slice requires a baseline snapshot at or before frame ${startFrame}`);
+    }
+    const sourceBundleHash = defaultChecksum(bundle);
+    const sourceStartFrame = bundle.checksums[0]?.frame ?? 0;
+    const sourceEndFrame = bundle.checksums.at(-1)?.frame ?? sourceStartFrame;
+    return createDeterministicReplayBundle({
+        ...bundle,
+        inputHistory: bundle.inputHistory.filter((frame) => frame.frame >= startFrame && frame.frame <= endFrame),
+        commandHistory: bundle.commandHistory.filter((frame) => frame.frame >= startFrame && frame.frame <= endFrame),
+        checksums: bundle.checksums.filter((checksum) => checksum.frame >= startFrame && checksum.frame <= endFrame),
+        debugEvents: bundle.debugEvents.filter((event) => event.frame >= startFrame && event.frame <= endFrame),
+        snapshots: bundle.snapshots.filter((snapshot) => snapshot.frame >= startFrame && snapshot.frame <= endFrame),
+        sliceOrigin: {
+            sourceBundleHash,
+            sourceStartFrame,
+            sourceEndFrame,
+            sliceStartFrame: startFrame,
+            sliceEndFrame: endFrame,
+            baselineSnapshot,
+        },
+        metadata: {
+            ...bundle.metadata,
+            replaySlice: true,
+            selfContainedSlice: true,
+            sourceBundleHash,
+            sliceStartFrame: startFrame,
+            sliceEndFrame: endFrame,
+            baselineFrame: baselineSnapshot.frame,
+            baselineChecksum: baselineSnapshot.checksum,
+        },
+    });
+}
+function firstVerifierConsumableSlice(bundle, mismatch, expected) {
+    const candidateFrames = [...new Set([
+            mismatch.frame,
+            ...bundle.snapshots.map((snapshot) => snapshot.frame).filter((frame) => frame <= mismatch.frame),
+            ...bundle.checksums.map((checksum) => checksum.frame).filter((frame) => frame <= mismatch.frame),
+            0,
+        ])].sort((left, right) => right - left);
+    for (const frame of candidateFrames) {
+        try {
+            const candidate = sliceDeterministicReplayBundle(bundle, frame, mismatch.frame);
+            if (preservesReplayMismatch(candidate, mismatch, expected)) {
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    try {
+        return sliceDeterministicReplayBundle(bundle, 0, mismatch.frame);
+    }
+    catch {
+        return bundle;
+    }
+}
+function reduceReplayBundleRecords(bundle, mismatch, expected, section) {
+    const current = bundle[section];
+    const mismatchRecord = current.find((record) => record.frame === mismatch.frame);
+    const fallbackRecord = current[0];
+    const singleRecord = mismatchRecord ?? fallbackRecord;
+    if (singleRecord === undefined) {
+        return bundle;
+    }
+    const singleValue = section === 'inputHistory'
+        ? reduceReplayInputRecord(singleRecord)
+        : reduceReplayCommandRecord(singleRecord);
+    const candidate = createDeterministicReplayBundle({
+        ...bundle,
+        [section]: [singleValue],
+    });
+    return preservesReplayMismatch(candidate, mismatch, expected) ? candidate : bundle;
+}
+function reduceReplayInputRecord(record) {
+    return { ...record, inputs: record.inputs.slice(0, 1) };
+}
+function reduceReplayCommandRecord(record) {
+    return { ...record, commands: record.commands.slice(0, 1) };
+}
+function reduceReplayBundleDebugEvents(bundle, mismatch, expected) {
+    const event = bundle.debugEvents.find((candidate) => candidate.frame === mismatch.frame && candidate.type.startsWith(mismatch.subsystem))
+        ?? bundle.debugEvents.find((candidate) => candidate.frame === mismatch.frame)
+        ?? bundle.debugEvents[0];
+    if (event === undefined) {
+        return bundle;
+    }
+    const candidate = createDeterministicReplayBundle({
+        ...bundle,
+        debugEvents: [event],
+    });
+    return preservesReplayMismatch(candidate, mismatch, expected) ? candidate : bundle;
+}
+function preservesReplayMismatch(bundle, mismatch, expected) {
+    const verification = verifyDeterministicReplayBundle(bundle, expected);
+    return verification.result === 'fail'
+        && verification.firstMismatch?.frame === mismatch.frame
+        && verification.firstMismatch.subsystem === mismatch.subsystem;
+}
+function replayIdentity(bundle) {
+    return {
+        runtimeVersion: bundle.runtimeVersion,
+        engineHash: bundle.engineHash,
+        schemaHash: bundle.schemaHash,
+        assetDbHash: bundle.assetDbHash,
+        configHash: bundle.configHash,
+        semanticReplayHash: bundle.semanticReplayHash,
+    };
+}
+function countReplayInputs(bundle) {
+    return bundle.inputHistory.reduce((sum, frame) => sum + frame.inputs.length, 0);
+}
+function countReplayCommands(bundle) {
+    return bundle.commandHistory.reduce((sum, frame) => sum + frame.commands.length, 0);
+}
+function assertReplayBundleIdentity(bundle) {
+    const fields = ['runtimeVersion', 'engineHash', 'schemaHash', 'assetDbHash', 'configHash', 'sampleId'];
+    for (const field of fields) {
+        if (bundle[field].length === 0) {
+            throw new Error(`Replay bundle requires ${field}`);
+        }
+    }
+}
+function assertReplayRuntimeManifest(manifest) {
+    if (manifest === undefined) {
+        return;
+    }
+    const expectedHash = deterministicReplayRuntimeManifestHash(manifest);
+    if (manifest.manifestHash !== expectedHash) {
+        throw new Error('Replay runtime manifest hash mismatch');
+    }
+    deterministicReplayRuntimeSystems(manifest.systemId);
+    deterministicReplayRuntimeBeforeFrame(manifest.beforeFrameId);
+}
+function deterministicReplayRuntimeManifestHash(manifest) {
+    return defaultChecksum({
+        descriptor: manifest.descriptor,
+        descriptorHash: manifest.descriptorHash,
+        systemId: manifest.systemId,
+        beforeFrameId: manifest.beforeFrameId,
+        systemsSourceHash: manifest.systemsSourceHash,
+        acceptedSystemsSourceHashes: [...(manifest.acceptedSystemsSourceHashes ?? [])].sort(compareStrings),
+        seed: manifest.seed,
+        sparse: manifest.sparse === true,
+    });
+}
+function findRuntimeManifestIdentityMismatch(manifest, options) {
+    if (manifest === undefined) {
+        return undefined;
+    }
+    const expectedManifestHash = deterministicReplayRuntimeManifestHash(manifest);
+    if (manifest.manifestHash !== expectedManifestHash) {
+        return runtimeReplayMismatch(0, 'runtimeReplay.manifestHash', expectedManifestHash, manifest.manifestHash);
+    }
+    const descriptorHash = options.descriptorHash ?? defaultChecksum(options.descriptor);
+    if (manifest.descriptorHash !== descriptorHash) {
+        return runtimeReplayMismatch(0, 'runtimeReplay.descriptorHash', manifest.descriptorHash, descriptorHash);
+    }
+    if (options.requireRuntimeIdentity === true || options.systemsSourceHash !== undefined) {
+        const systemsSourceHash = options.systemsSourceHash ?? 'missing';
+        const acceptedSystemsSourceHashes = new Set([manifest.systemsSourceHash, ...(manifest.acceptedSystemsSourceHashes ?? [])]);
+        if (!acceptedSystemsSourceHashes.has(systemsSourceHash)) {
+            return runtimeReplayMismatch(0, 'runtimeReplay.systemsSourceHash', manifest.systemsSourceHash, systemsSourceHash);
+        }
+    }
+    return undefined;
+}
+function deterministicReplayRuntimeSourceHash(systemId, beforeFrameId) {
+    return defaultChecksum({
+        kind: 'deterministic-replay-runtime-source',
+        systemId,
+        beforeFrameId,
+    });
+}
+function deterministicReplayRuntimeSystems(systemId) {
+    switch (systemId) {
+        case 'score-accumulator-v1':
+            return {
+                simulate(ctx) {
+                    const score = ctx.getSingleton('score') ?? { value: 0, inputDelta: 0, commandDelta: 0 };
+                    ctx.setSingleton('score', {
+                        value: Number(score.value ?? 0) + Number(score.inputDelta ?? 0) + Number(score.commandDelta ?? 0),
+                        inputDelta: 0,
+                        commandDelta: 0,
+                    });
+                    ctx.emitDebug('ecs.score', { value: Number(score.value ?? 0) });
+                },
+            };
+        case 'score-runtime-replay-v1':
+            return {
+                simulate(ctx) {
+                    const score = ctx.getSingleton('score') ?? { value: 0, inputDelta: 0, commandDelta: 0 };
+                    ctx.setSingleton('score', {
+                        value: Number(score.value ?? 0) + Number(score.inputDelta ?? 0) + Number(score.commandDelta ?? 0),
+                        inputDelta: 0,
+                        commandDelta: 0,
+                    });
+                    if (ctx.frame % 128 === 0) {
+                        ctx.emitDebug('ecs.runtime-replay', { frame: ctx.frame, value: Number(score.value ?? 0) });
+                    }
+                },
+            };
+        case 'project-game-state-runtime-replay-v1':
+            return {
+                simulate(ctx) {
+                    const state = ctx.getSingleton('runtimeReplayState') ?? { value: 0, inputDelta: 0, commandDelta: 0 };
+                    const value = Number(state.value ?? 0) + Number(state.inputDelta ?? 0) + Number(state.commandDelta ?? 0);
+                    ctx.setSingleton('runtimeReplayState', {
+                        value,
+                        inputDelta: 0,
+                        commandDelta: 0,
+                    });
+                    const gameState = ctx.getSingleton('gameState');
+                    if (gameState !== undefined) {
+                        ctx.setSingleton('gameState', patchProjectGameStateReplay(gameState, ctx.frame + 1, value));
+                    }
+                    if (ctx.frame % 128 === 0) {
+                        ctx.emitDebug('ecs.project-runtime-replay', { frame: ctx.frame, value });
+                    }
+                },
+            };
+    }
+}
+function deterministicReplayRuntimeBeforeFrame(beforeFrameId) {
+    switch (beforeFrameId) {
+        case 'score-input-command-delta-v1':
+            return injectScoreRuntimeReplayFrame;
+        case 'project-game-state-input-command-delta-v1':
+            return injectProjectGameStateRuntimeReplayFrame;
+    }
+}
+function injectScoreRuntimeReplayFrame(runtime, _frame, inputs, commands) {
+    const inputDelta = inputs.reduce((sum, input) => isReplayRecord(input) && typeof input.dx === 'number' ? sum + input.dx : sum, 0);
+    const commandDelta = commands.reduce((sum, command) => {
+        if (!isReplayRecord(command) || !isReplayRecord(command.payload) || typeof command.payload.power !== 'number') {
+            return sum;
+        }
+        return sum + command.payload.power;
+    }, 0);
+    const score = runtime.snapshot().singletonComponents.score ?? { value: 0 };
+    runtime.setSingleton('score', {
+        value: Number(score.value ?? 0),
+        inputDelta,
+        commandDelta,
+    });
+}
+function injectProjectGameStateRuntimeReplayFrame(runtime, frame, inputs, commands) {
+    const inputDelta = inputs.reduce((sum, input) => {
+        if (!isReplayRecord(input)) {
+            return sum;
+        }
+        if (typeof input.dx === 'number') {
+            return sum + input.dx;
+        }
+        if (typeof input.moveX === 'number') {
+            return sum + input.moveX;
+        }
+        return sum;
+    }, 0);
+    const commandDelta = commands.reduce((sum, command) => {
+        if (!isReplayRecord(command) || !isReplayRecord(command.payload)) {
+            return sum;
+        }
+        if (typeof command.payload.power === 'number') {
+            return sum + command.payload.power;
+        }
+        if (typeof command.payload.slot === 'number') {
+            return sum + command.payload.slot;
+        }
+        return sum;
+    }, 0);
+    const state = runtime.snapshot().singletonComponents.runtimeReplayState ?? { value: 0 };
+    runtime.setSingleton('runtimeReplayState', {
+        value: Number(state.value ?? 0),
+        inputDelta,
+        commandDelta,
+    });
+    const gameState = runtime.snapshot().singletonComponents.gameState;
+    if (gameState !== undefined) {
+        runtime.setSingleton('gameState', patchProjectGameStateReplay(gameState, frame, Number(state.value ?? 0)));
+    }
+}
+function patchProjectGameStateReplay(gameState, frame, score) {
+    return Object.fromEntries(stableKeys(gameState).map((key) => {
+        const value = gameState[key];
+        if (key === 'tick' && typeof value === 'number') {
+            return [key, frame];
+        }
+        if (key === 'score' && typeof value === 'number') {
+            return [key, score];
+        }
+        if (key === 'alive' && typeof value === 'boolean') {
+            return [key, true];
+        }
+        return [key, value];
+    }));
+}
+function isReplayRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function findIdentityMismatch(bundle, expected) {
+    if (expected === undefined) {
+        return undefined;
+    }
+    for (const field of stableKeys(expected)) {
+        const value = expected[field];
+        const actual = bundle[field];
+        if (value !== undefined && actual !== value) {
+            return {
+                frame: 0,
+                subsystem: 'identity',
+                path: field,
+                expectedChecksum: String(value),
+                actualChecksum: String(actual),
+                minimalReproPath: 'artifacts/replays/replay-identity-min.json',
+            };
+        }
+    }
+    return undefined;
+}
+function firstSubsystemAtFrame(bundle, frame) {
+    return bundle.debugEvents.find((event) => event.frame === frame)?.type.split('.')[0] ?? 'checksum';
+}
+function compareDebugEvents(left, right) {
+    return left.frame - right.frame || compareStrings(left.type, right.type) || compareStrings(canonicalStringify(left.payload), canonicalStringify(right.payload));
+}
+function stableKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export const __replayBundleCoverageProof = {
+    exercisePrivateFallbacks() {
+        const frame0 = canonicalStringify({ frame: 0, positions: [0], commandScore: 0 });
+        const frame1 = canonicalStringify({ frame: 1, positions: [1], commandScore: 0 });
+        const baseBundle = createDeterministicReplayBundle({
+            runtimeVersion: 'test@1',
+            engineHash: 'engine',
+            schemaHash: 'schema',
+            assetDbHash: 'asset',
+            configHash: 'config',
+            sampleId: 'coverage-proof',
+            inputHistory: [{ frame: 0, inputs: [{ slot: 0, dx: 1 }] }],
+            commandHistory: [{ frame: 0, commands: [] }],
+            checksums: [
+                { frame: 0, checksum: defaultChecksum(frame0) },
+                { frame: 1, checksum: defaultChecksum(frame1) },
+            ],
+            debugEvents: [{ frame: 0, type: 'other.event', payload: { order: 1 } }],
+            snapshots: [
+                { frame: 0, bytes: frame0, checksum: defaultChecksum(frame0) },
+                { frame: 1, bytes: frame1, checksum: defaultChecksum(frame1) },
+            ],
+            metadata: { players: 1 },
+        });
+        const runtimeSnapshotBytes = canonicalStringify({
+            frame: 0,
+            nextEntityId: 1,
+            freeEntityIds: [],
+            generations: {},
+            components: {},
+            singletonComponents: {},
+            debugEvents: [],
+            commandTimeline: {},
+            randomState: 1,
+        });
+        const runtimeSnapshot = frameSnapshotFromReplaySnapshot({
+            frame: 0,
+            bytes: runtimeSnapshotBytes,
+            checksum: defaultChecksum(runtimeSnapshotBytes),
+        });
+        const identityMismatch = {
+            frame: 0,
+            subsystem: 'identity',
+            path: 'engineHash',
+            expectedChecksum: 'expected',
+            actualChecksum: 'engine',
+            minimalReproPath: 'artifacts/replays/replay-identity-min.json',
+        };
+        const expectedIdentity = {
+            runtimeVersion: baseBundle.runtimeVersion,
+            engineHash: 'expected',
+            schemaHash: baseBundle.schemaHash,
+            assetDbHash: baseBundle.assetDbHash,
+            configHash: baseBundle.configHash,
+            semanticReplayHash: baseBundle.semanticReplayHash,
+        };
+        const semanticHash = verifySemanticReplay({
+            ...baseBundle,
+            snapshots: [],
+            semanticReplay: {
+                kind: 'operation-model-v1',
+                initialState: {},
+                operations: [],
+            },
+            semanticReplayHash: undefined,
+        }, {});
+        const selectedSlice = firstVerifierConsumableSlice(baseBundle, identityMismatch, expectedIdentity);
+        const recordReduced = reduceReplayBundleRecords(baseBundle, identityMismatch, expectedIdentity, 'inputHistory');
+        const debugReduced = reduceReplayBundleDebugEvents(baseBundle, identityMismatch, expectedIdentity);
+        const manualDebugFallback = reduceReplayBundleDebugEvents(baseBundle, {
+            ...identityMismatch,
+            subsystem: 'manual-subsystem',
+        }, expectedIdentity);
+        const builtInWrites = [];
+        const makeSystemContext = (frame, singletons) => ({
+            frame,
+            getSingleton(id) {
+                return singletons[id];
+            },
+            setSingleton(id, value) {
+                singletons[id] = value;
+                builtInWrites.push(value);
+            },
+            emitDebug(_type, payload) {
+                builtInWrites.push(payload);
+            },
+        });
+        deterministicReplayRuntimeSystems('score-accumulator-v1').simulate(makeSystemContext(0, {
+            score: {},
+        }));
+        deterministicReplayRuntimeSystems('score-runtime-replay-v1').simulate(makeSystemContext(0, {
+            score: {},
+        }));
+        deterministicReplayRuntimeSystems('score-runtime-replay-v1').simulate(makeSystemContext(1, {
+            score: {},
+        }));
+        deterministicReplayRuntimeSystems('project-game-state-runtime-replay-v1').simulate(makeSystemContext(1, {
+            runtimeReplayState: {},
+            gameState: { tick: 'old', score: 'old', alive: 'old' },
+        }));
+        const fakeRuntime = {
+            snapshot() {
+                return {
+                    singletonComponents: {
+                        score: {},
+                        runtimeReplayState: {},
+                        gameState: { tick: 0, score: 0, alive: false },
+                    },
+                };
+            },
+            setSingleton(_id, value) {
+                builtInWrites.push(value);
+            },
+        };
+        deterministicReplayRuntimeBeforeFrame('score-input-command-delta-v1')?.(fakeRuntime, 0, [{}], [{}]);
+        deterministicReplayRuntimeBeforeFrame('project-game-state-input-command-delta-v1')?.(fakeRuntime, 0, [{ moveX: 2 }, {}], [{ payload: { slot: 1 } }, {}]);
+        const semanticFallbackBaseline = canonicalStringify({ frame: -1, positions: ['bad'], commandScore: 0 });
+        const semanticFallbackFrame = canonicalStringify({ frame: 0, positions: [2], commandScore: 0 });
+        const semanticFallback = verifySemanticReplay(createDeterministicReplayBundle({
+            runtimeVersion: 'test@1',
+            engineHash: 'engine',
+            schemaHash: 'schema',
+            assetDbHash: 'asset',
+            configHash: 'config',
+            sampleId: 'coverage-semantic-fallback',
+            inputHistory: [{ frame: 0, inputs: [{ slot: 0, dy: 1 }, { slot: 0, dx: 1 }, { slot: 0 }] }],
+            commandHistory: [{ frame: 0, commands: [] }],
+            checksums: [{ frame: 0, checksum: defaultChecksum(semanticFallbackFrame) }],
+            debugEvents: [{ frame: 0, type: 'ecs.snapshot', payload: {} }],
+            snapshots: [{ frame: 0, bytes: semanticFallbackFrame, checksum: defaultChecksum(semanticFallbackFrame) }],
+            sliceOrigin: {
+                sourceBundleHash: 'semantic-source',
+                sourceStartFrame: -1,
+                sourceEndFrame: 0,
+                sliceStartFrame: 0,
+                sliceEndFrame: 0,
+                baselineSnapshot: { frame: -1, bytes: semanticFallbackBaseline, checksum: defaultChecksum(semanticFallbackBaseline) },
+            },
+            metadata: {},
+        }));
+        const sparseArray = Array(1);
+        applyStateOperation({ positions: sparseArray }, 'positions[$slot]', 2, 'add', 0);
+        const operationBaselineFrame = canonicalStringify({ frame: -1, positions: [0], bonus: 0 });
+        const operationFinalFrame = canonicalStringify({ frame: 1, positions: [1], bonus: 1 });
+        const operationFallback = verifyOperationModelSemanticReplay(createDeterministicReplayBundle({
+            runtimeVersion: 'test@1',
+            engineHash: 'engine',
+            schemaHash: 'schema',
+            assetDbHash: 'asset',
+            configHash: 'config',
+            sampleId: 'coverage-operation-fallback',
+            inputHistory: [{ frame: 1, inputs: [{ slot: 0, dx: 1, bonus: 1 }] }],
+            commandHistory: [{ frame: 1, commands: [] }],
+            checksums: [
+                { frame: -1, checksum: defaultChecksum(operationBaselineFrame) },
+                { frame: 1, checksum: defaultChecksum(operationFinalFrame) },
+            ],
+            debugEvents: [{ frame: 1, type: 'ecs.snapshot', payload: {} }],
+            snapshots: [
+                { frame: -1, bytes: operationBaselineFrame, checksum: defaultChecksum(operationBaselineFrame) },
+                { frame: 1, bytes: operationFinalFrame, checksum: defaultChecksum(operationFinalFrame) },
+            ],
+            sliceOrigin: {
+                sourceBundleHash: 'operation-source',
+                sourceStartFrame: -1,
+                sourceEndFrame: 1,
+                sliceStartFrame: 0,
+                sliceEndFrame: 1,
+                baselineSnapshot: { frame: -1, bytes: operationBaselineFrame, checksum: defaultChecksum(operationBaselineFrame) },
+            },
+            metadata: {},
+        }), {
+            kind: 'operation-model-v1',
+            initialState: { positions: [0], bonus: 0 },
+            operations: [
+                { source: 'input', sourcePath: 'dx', targetPath: 'positions[$slot]', op: 'add', slotField: 'slot' },
+                { source: 'input', sourcePath: 'bonus', targetPath: 'bonus', op: 'add' },
+            ],
+        });
+        const componentBaselineFrame = canonicalStringify({
+            frame: -1,
+            components: { 1: { position: { nested: null, x: 0 } } },
+        });
+        const componentFinalFrame = canonicalStringify({
+            frame: 1,
+            components: { 1: { position: { x: 1 } } },
+        });
+        const componentFallback = verifyComponentSemanticReplay(createDeterministicReplayBundle({
+            runtimeVersion: 'test@1',
+            engineHash: 'engine',
+            schemaHash: 'schema',
+            assetDbHash: 'asset',
+            configHash: 'config',
+            sampleId: 'coverage-component-fallback',
+            inputHistory: [{ frame: 0, inputs: [{ entity: '1', component: 'position', field: 'ignored', value: { nested: true } }] }],
+            commandHistory: [{ frame: 0, commands: [{ entity: '1', component: 'position', field: 'x', delta: 1 }] }],
+            checksums: [
+                { frame: -1, checksum: defaultChecksum(componentBaselineFrame) },
+                { frame: 1, checksum: defaultChecksum(componentFinalFrame) },
+            ],
+            debugEvents: [{ frame: 1, type: 'ecs.snapshot', payload: {} }],
+            snapshots: [
+                { frame: -1, bytes: componentBaselineFrame, checksum: defaultChecksum(componentBaselineFrame) },
+                { frame: 1, bytes: componentFinalFrame, checksum: defaultChecksum(componentFinalFrame) },
+            ],
+            sliceOrigin: {
+                sourceBundleHash: 'component-source',
+                sourceStartFrame: -1,
+                sourceEndFrame: 1,
+                sliceStartFrame: 0,
+                sliceEndFrame: 1,
+                baselineSnapshot: { frame: -1, bytes: componentBaselineFrame, checksum: defaultChecksum(componentBaselineFrame) },
+            },
+            metadata: {},
+        }));
+        const duplicateStringFrame = findDuplicateFrame(['debug:4', 'debug:4'], 'debugEvents');
+        const emptyChecksumSlice = sliceDeterministicReplayBundle({ ...baseBundle, checksums: [] }, 0, 0);
+        return {
+            emptyMissingFrameIsUndefined: findMissingFrame([], 'inputHistory') === undefined,
+            duplicateStringFrame: duplicateStringFrame.frame,
+            semanticHashFallbackFrame: semanticHash.mismatch.frame,
+            semanticHashFallbackActual: semanticHash.mismatch.actualChecksum,
+            runtimeSnapshotHasDefaultHeap: runtimeSnapshot.frameHeap.nextHandleId,
+            runtimeSnapshotRuntimeEvents: runtimeSnapshot.runtimeEvents.length,
+            runtimeSnapshotCommandTimelineKeys: stableKeys(runtimeSnapshot.commandTimeline).length,
+            nullSnapshotStateKeys: stableKeys(snapshotStateWithoutFrame({
+                frame: -1,
+                bytes: canonicalStringify(null),
+                checksum: defaultChecksum(canonicalStringify(null)),
+            })).length,
+            selectedSliceStart: selectedSlice.sliceOrigin.sliceStartFrame,
+            emptyChecksumSliceStart: emptyChecksumSlice.sliceOrigin.sourceStartFrame,
+            recordReducedInputFrames: recordReduced.inputHistory.length,
+            debugReducedEvents: debugReduced.debugEvents.length,
+            manualDebugFallbackEvents: manualDebugFallback.debugEvents.length,
+            builtInWriteCount: builtInWrites.length,
+            semanticFallbackFrames: semanticFallback.frames,
+            operationFallbackFrames: operationFallback.frames,
+            componentFallbackFrames: componentFallback.frames,
+            sparseArrayFallbackValue: sparseArray[0],
+            compareStringsGreater: compareStrings('b', 'a'),
+        };
+    },
+};