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

package/dist/cjs/certification.js

@@ -0,0 +1,1860 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultCertificationManifest = createDefaultCertificationManifest;
+exports.runCertificationSuite = runCertificationSuite;
+exports.stableCertificationJson = stableCertificationJson;
+const canonical_js_1 = require("./canonical.js");
+const collision_js_1 = require("./collision.js");
+const collections_js_1 = require("./collections.js");
+const events_js_1 = require("./events.js");
+const math_js_1 = require("./math.js");
+const physics_cert_js_1 = require("./physics-cert.js");
+const prediction_culling_js_1 = require("./prediction-culling.js");
+const protocol_lab_js_1 = require("./protocol-lab.js");
+const random_js_1 = require("./random.js");
+const replay_js_1 = require("./replay.js");
+const schema_artifacts_js_1 = require("./schema-artifacts.js");
+const schema_codegen_js_1 = require("./schema-codegen.js");
+const schema_js_1 = require("./schema.js");
+const sample_lab_js_1 = require("./sample-lab.js");
+const timers_js_1 = require("./timers.js");
+const static_checker_js_1 = require("./tools/static-checker.js");
+const defaultArtifactDir = 'artifacts/certification';
+const checksumCostIterations = 100;
+function createDefaultCertificationManifest() {
+    return {
+        manifestId: 'syncplay-v1',
+        artifactDir: defaultArtifactDir,
+        benchmarkProfile: false,
+        fixtures: [
+            {
+                fixtureId: 'fixed-foundation',
+                kind: 'fixed-foundation',
+                required: true,
+                runtimeTarget: 'node',
+                players: 1,
+                frames: 1,
+                seed: 41,
+                budgets: {
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'static-analysis',
+                kind: 'static-analysis',
+                required: true,
+                runtimeTarget: 'node',
+                players: 1,
+                frames: 1,
+                seed: 1,
+            },
+            {
+                fixtureId: 'schema-tooling',
+                kind: 'schema-tooling',
+                required: true,
+                runtimeTarget: 'node',
+                players: 4,
+                frames: 1,
+                seed: 1,
+                budgets: {
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'event-callbacks',
+                kind: 'event-callbacks',
+                required: true,
+                runtimeTarget: 'node',
+                players: 1,
+                frames: 3,
+                seed: 1,
+                budgets: {
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'physics-builtin-fixed',
+                kind: 'physics-builtin',
+                required: true,
+                runtimeTarget: 'node',
+                players: 8,
+                frames: 240,
+                seed: 7,
+                budgets: {
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'prediction-culling',
+                kind: 'prediction-culling',
+                required: true,
+                runtimeTarget: 'node',
+                players: 16,
+                frames: 240,
+                seed: 17,
+                budgets: {
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'external-physics-gate',
+                kind: 'external-physics-gate',
+                required: true,
+                runtimeTarget: 'node',
+                players: 1,
+                frames: 1,
+                seed: 1,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'ecs-lite',
+                kind: 'ecs-lite',
+                required: true,
+                runtimeTarget: 'node',
+                players: 4,
+                frames: 4,
+                seed: 1,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'kcc-lite',
+                kind: 'kcc-lite',
+                required: true,
+                runtimeTarget: 'node',
+                players: 1,
+                frames: 180,
+                seed: 3,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'navigation-grid',
+                kind: 'navigation-grid',
+                required: true,
+                runtimeTarget: 'node',
+                players: 16,
+                frames: 120,
+                seed: 13,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'projectile-hitscan',
+                kind: 'projectile-hitscan',
+                required: true,
+                runtimeTarget: 'node',
+                players: 4,
+                frames: 240,
+                seed: 5,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'bot-replacement',
+                kind: 'bot-replacement',
+                required: true,
+                runtimeTarget: 'node',
+                players: 8,
+                frames: 300,
+                seed: 7,
+                budgets: { requireChecksumConvergence: true },
+            },
+            {
+                fixtureId: 'genre-128-top-down-bots',
+                kind: 'genre-128',
+                required: true,
+                runtimeTarget: 'node',
+                players: 128,
+                frames: 1000,
+                seed: 43,
+                budgets: {
+                    maxRollbackDepth: 120,
+                    requireChecksumConvergence: true,
+                },
+            },
+            {
+                fixtureId: 'reference-samples',
+                kind: 'reference-samples',
+                required: true,
+                runtimeTarget: 'node',
+                players: 16,
+                frames: 300,
+                seed: 59,
+                budgets: { requireChecksumConvergence: true },
+            },
+            createDefaultNetcodeFixture('p128-input-minimal', 'input-minimal', 19),
+            createDefaultNetcodeFixture('p128-moderate-state', 'moderate-state', 23),
+            createDefaultNetcodeFixture('p128-command-bursts', 'command-bursts', 29),
+            {
+                fixtureId: 'protocol-matrix',
+                kind: 'protocol-matrix',
+                required: true,
+                runtimeTarget: 'node',
+                players: 8,
+                frames: 300,
+                seed: 37,
+                profiles: defaultProtocolProfiles,
+                budgets: {
+                    maxRollbackDepth: 80,
+                    requireChecksumConvergence: true,
+                    requireExpectedDesyncArtifacts: true,
+                },
+            },
+            {
+                fixtureId: 'node-replay-lab',
+                kind: 'replay-node',
+                required: true,
+                runtimeTarget: 'node',
+                players: 4,
+                frames: 240,
+                seed: 31,
+                budgets: {
+                    maxReplayBytes: 1_000_000,
+                    maxPackedInputBytesPerSecond: 10_000,
+                    requireChecksumConvergence: true,
+                },
+            },
+        ],
+    };
+}
+function runCertificationSuite(manifestInput = {}) {
+    const manifest = normalizeManifest(manifestInput);
+    const fixtureReports = manifest.fixtures.map((fixture) => runCertificationFixture(manifest, fixture));
+    const failures = fixtureReports.flatMap((fixture) => collectRequiredFixtureFailures(fixture));
+    const reportWithoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        manifestId: manifest.manifestId,
+        artifactDir: manifest.artifactDir,
+        benchmarkProfile: manifest.benchmarkProfile,
+        fixtures: fixtureReports,
+        failures,
+        result: failures.length === 0 ? 'pass' : 'fail',
+    };
+    const report = {
+        ...reportWithoutId,
+        reportId: (0, canonical_js_1.defaultChecksum)(reportWithoutId),
+    };
+    return { report, fixtureReports };
+}
+function collectRequiredFixtureFailures(fixture) {
+    if (!fixture.required || fixture.result !== 'fail') {
+        return [];
+    }
+    /* istanbul ignore next -- createFixtureReport supplies diagnostics for current failing fixtures; this suite fallback protects future fixture implementations. */
+    const failures = fixture.failures.length === 0
+        ? ['fixture failed without diagnostics']
+        : fixture.failures;
+    return failures.map((failure) => `${fixture.fixtureId}: ${failure}`);
+}
+function stableCertificationJson(value) {
+    return `${(0, canonical_js_1.canonicalStringify)(value)}\n`;
+}
+function certificationPassFail(pass) {
+    const results = ['fail', 'pass'];
+    return results[Number(pass)];
+}
+function runCertificationFixture(manifest, fixture) {
+    if (fixture.kind === 'static-analysis') {
+        return runStaticAnalysisFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'schema-tooling') {
+        return runSchemaToolingFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'event-callbacks') {
+        return runEventCallbacksFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'physics-builtin') {
+        return runPhysicsBuiltinFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'prediction-culling') {
+        return runPredictionCullingFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'external-physics-gate') {
+        return runExternalPhysicsGateFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'ecs-lite') {
+        return runEcsLiteFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'kcc-lite') {
+        return runKccLiteFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'navigation-grid') {
+        return runNavigationGridFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'projectile-hitscan') {
+        return runProjectileHitscanFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'bot-replacement') {
+        return runBotReplacementFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'genre-128') {
+        return runGenre128Fixture(manifest, fixture);
+    }
+    if (fixture.kind === 'fixed-foundation') {
+        return runFixedFoundationFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'netcode') {
+        return runNetcodeFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'protocol-matrix') {
+        return runProtocolMatrixFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'reference-samples') {
+        return runReferenceSamplesFixture(manifest, fixture);
+    }
+    if (fixture.kind === 'replay-node') {
+        return runReplayNodeFixture(manifest, fixture);
+    }
+    return createSkippedBrowserFixtureReport(manifest, fixture);
+}
+function runFixedFoundationFixture(manifest, fixture) {
+    const math = (0, math_js_1.createDeterministicMath)();
+    const a = math.toFixed(1.5);
+    const b = math.toFixed(2.5);
+    const circleA = (0, collision_js_1.fixedCircle)((0, collision_js_1.fixedVec2)(100, 200), 50);
+    const circleB = (0, collision_js_1.fixedCircle)((0, collision_js_1.fixedVec2)(140, 210), 40);
+    const rng = new random_js_1.DeterministicRandom(fixture.seed);
+    const rngValues = Array.from({ length: 5 }, () => rng.nextInt(0, 999));
+    const cooldown = (0, timers_js_1.createCooldown)(5);
+    const tickedCooldown = (0, timers_js_1.tickCooldown)(cooldown, 3);
+    const readyCooldown = (0, timers_js_1.tickCooldown)(tickedCooldown, 2);
+    const frameEvents = [
+        (0, timers_js_1.scheduleFrameEvent)(10, 5, { id: 'late' }),
+        (0, timers_js_1.scheduleFrameEvent)(10, 0, { id: 'now' }),
+        (0, timers_js_1.scheduleFrameEvent)(10, 2, { id: 'soon' }),
+    ];
+    const dueEvents = (0, timers_js_1.popDueFrameEvents)(12, frameEvents);
+    const record = { bravo: 2, alpha: 1, charlie: 3 };
+    const stableMap = (0, collections_js_1.createStableIndexedMap)([
+        { id: 'slot-2', value: 2 },
+        { id: 'slot-0', value: 0 },
+        { id: 'slot-1', value: 1 },
+    ]);
+    const goldenWithoutChecksum = {
+        fixedMath: {
+            a,
+            b,
+            add: math.add(a, b),
+            sub: math.sub(b, a),
+            mul: math.mul(a, b),
+            div: math.div(b, a),
+            clamp: math.clamp(4_000, 0, b),
+        },
+        vectors: {
+            a: circleA.center,
+            b: circleB.center,
+            circlesIntersect: (0, collision_js_1.circleIntersects)(circleA, circleB),
+        },
+        rng: rngValues,
+        timers: {
+            milliseconds: (0, timers_js_1.framesToMilliseconds)(3, 30),
+            frames: (0, timers_js_1.millisecondsToFrames)(101, 30),
+            cooldown: {
+                start: cooldown,
+                ticked: tickedCooldown,
+                ready: readyCooldown,
+            },
+            due: dueEvents.due,
+            pending: dueEvents.pending,
+        },
+        collections: {
+            sortedKeys: (0, collections_js_1.stableSortedKeys)(record),
+            stableEntries: (0, collections_js_1.stableEntries)(record),
+            stableMapEntries: [...stableMap],
+            stableSetValues: [...new Set(['bravo', 'alpha', 'charlie'])].sort((left, right) => left.localeCompare(right)),
+            shuffle: (0, collections_js_1.deterministicShuffle)(['a', 'b', 'c', 'd', 'e'], new random_js_1.DeterministicRandom(fixture.seed)),
+        },
+    };
+    const goldenChecksum = (0, canonical_js_1.defaultChecksum)(goldenWithoutChecksum);
+    const metrics = {
+        goldenChecksum,
+        checksumConverged: goldenChecksum === (0, canonical_js_1.defaultChecksum)(goldenWithoutChecksum),
+        ...goldenWithoutChecksum,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runStaticAnalysisFixture(manifest, fixture) {
+    const diagnostics = (0, static_checker_js_1.checkSourceText)('certification/static-analysis-fixture.ts', [
+        'export function step(state: { x: number }): { x: number } {',
+        '  Math.random();',
+        '  Date.now();',
+        '  new Date();',
+        '  performance.now();',
+        '  setTimeout(() => undefined, 1);',
+        '  fetch("/bad");',
+        '  crypto.randomUUID();',
+        '  [3, 2, 1].sort();',
+        '  return { x: state.x + 1 };',
+        '}',
+    ].join('\n'), 'strict');
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === 'warn').length;
+    const alternativesReported = diagnostics.filter((diagnostic) => diagnostic.suggestion.length > 0).length;
+    const metrics = {
+        parser: (0, static_checker_js_1.getDeterminismParserKind)(),
+        dependencyPosture: 'package-internal-no-runtime-parser-dependency',
+        diagnostics: diagnostics.map((diagnostic) => ({
+            ruleId: diagnostic.ruleId,
+            severity: diagnostic.severity,
+            suggestion: diagnostic.suggestion,
+        })),
+        errors,
+        warnings,
+        alternativesReported,
+        result: certificationPassFail(errors === 8 && alternativesReported === 8),
+    };
+    return createFixtureReport(manifest, fixture, metrics, metrics.result);
+}
+function runSchemaToolingFixture(manifest, fixture) {
+    const descriptor = (0, schema_js_1.defineSyncplayGame)(createCertificationDescriptor());
+    const artifacts = (0, schema_artifacts_js_1.createSchemaArtifacts)(descriptor);
+    const state = {
+        health: [3, 2, 1, 3],
+        score: [0, 1, 0, 2],
+    };
+    const input = {
+        attack: true,
+        targetSlot: 2,
+    };
+    const canonicalInput = artifacts.canonicalizeInput(input);
+    const serializedState = artifacts.serializeState(state);
+    const deserializedState = artifacts.deserializeState(serializedState);
+    const frameDump = artifacts.dumpFrame({
+        frame: fixture.frames,
+        state: deserializedState,
+        inputFrame: {
+            frame: fixture.frames,
+            inputs: [canonicalInput],
+        },
+    });
+    const generatedTypes = (0, schema_codegen_js_1.generateSchemaTypes)(descriptor, { rootName: 'CounterDuel' });
+    const generatedRuntimeValidatorsPresent = generatedTypes.includes('function validateCounterDuelInput')
+        && generatedTypes.includes('function validateCounterDuelState')
+        && generatedTypes.includes('function assertCounterDuelExactKeys');
+    const frameDumpChecksumMatch = frameDump.checksum === artifacts.checksumState(state);
+    const metrics = {
+        artifactId: descriptor.artifactId,
+        descriptorId: descriptor.artifactId,
+        commandSchemaId: descriptor.replayIdentity.commandSchemaId,
+        prototypeSchemaId: descriptor.replayIdentity.prototypeSchemaId,
+        defaultInputFactoryPresent: generatedTypes.includes('createCounterDuelDefaultInput'),
+        canonicalInput,
+        serializedStateBytes: serializedState.byteLength,
+        frameDumpChecksum: frameDump.checksum,
+        frameDumpChecksumMatch,
+        generatedTypesBytes: Buffer.byteLength(generatedTypes),
+        generatedHelpers: ['types', 'default-input-factory', 'canonical-serializer', 'runtime-validators', 'frame-dump'],
+        generatedRuntimeValidatorsPresent,
+        checksumConverged: frameDumpChecksumMatch,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runEventCallbacksFixture(manifest, fixture) {
+    const timeline = (0, events_js_1.createDeterministicEventTimeline)();
+    timeline.emitPredicted('entity.created', 1, { slot: 0, kind: 'lifecycle' }, 'entity-created');
+    timeline.emitPredicted('physics.collision', 1, { slot: 0, kind: 'physics' }, 'collision');
+    timeline.emitPredicted('entity.destroyed', 2, { slot: 0, kind: 'lifecycle' }, 'entity-destroyed');
+    timeline.emitPredicted('physics.trigger', 2, { slot: 0, kind: 'physics' }, 'trigger');
+    timeline.confirmThroughFrame(1);
+    timeline.cancelFromFrame(2);
+    timeline.emitVerifiedOnly('verified.score', 3, { slot: 0, kind: 'verified' }, 'verified-score');
+    timeline.emitPredicted('view.predicted', 4, { slot: 0, kind: 'view' }, 'view-predicted');
+    const records = timeline.records();
+    const predictionStates = [...new Set(records.map((record) => record.predictionState))].sort();
+    const eventChecksum = (0, canonical_js_1.defaultChecksum)(records);
+    const metrics = {
+        predictionStates,
+        records: records.length,
+        confirmed: records.filter((record) => record.predictionState === 'confirmed').length,
+        canceled: records.filter((record) => record.predictionState === 'canceled').length,
+        verifiedOnly: records.filter((record) => record.predictionState === 'verifiedOnly').length,
+        lifecycleEvents: records.filter((record) => record.eventId.startsWith('entity.')).length,
+        physicsEvents: records.filter((record) => record.eventId.startsWith('physics.')).length,
+        eventChecksum,
+        checksumConverged: eventChecksum === (0, canonical_js_1.defaultChecksum)(records),
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runPhysicsBuiltinFixture(manifest, fixture) {
+    const result = (0, physics_cert_js_1.runPhysicsCert)({
+        engine: 'builtin-fixed',
+        shape: 'fixed-arena',
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        snapshotEvery: 1,
+    });
+    const metrics = {
+        engine: result.engine,
+        uninterruptedChecksum: result.uninterruptedChecksum,
+        restoredChecksum: result.restoredChecksum,
+        checksumConverged: result.uninterruptedChecksum === result.restoredChecksum && result.result === 'pass',
+        collisionEventsStable: result.collisionEventsStable,
+        queryOrderStable: result.queryOrderStable,
+        snapshotHashStable: result.snapshotHashStable,
+        collisionEvents: result.collisionEvents,
+        snapshotBytesP95: result.snapshotBytesP95,
+        result: result.result,
+    };
+    return createFixtureReport(manifest, fixture, metrics, metrics.result);
+}
+function runPredictionCullingFixture(manifest, fixture) {
+    const passProfile = (0, prediction_culling_js_1.runPredictionCullingLab)({
+        mode: 'local-area',
+        players: fixture.players,
+        objectsPerPlayer: 6,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        radius: 180,
+    });
+    const expectedFailureProfile = (0, prediction_culling_js_1.runPredictionCullingLab)({
+        mode: 'local-area',
+        players: fixture.players,
+        objectsPerPlayer: 6,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        radius: 80,
+        includeHiddenThreat: true,
+    });
+    const metrics = {
+        passProfile,
+        expectedFailureProfile,
+        expectedFailureDetected: expectedFailureProfile.result === 'fail' && expectedFailureProfile.hiddenAuthoritativeInteractions > 0,
+        checksumConverged: passProfile.result === 'pass',
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runExternalPhysicsGateFixture(manifest, fixture) {
+    const certified = false;
+    const checksummedGameplayAllowed = false;
+    const requiredGates = [
+        'uninterrupted-vs-restored-checksum-equality',
+        'stable-query-order',
+        'stable-collision-callbacks',
+        'stable-snapshot-hashes',
+        'documented-version-identity',
+    ];
+    const knownIssue = 'rapier cert currently reproduces snapshot/restore nondeterminism; keep external physics out of checksummed gameplay';
+    const checksummedGameplayRejected = certified === false &&
+        checksummedGameplayAllowed === false &&
+        requiredGates.length === 5 &&
+        knownIssue.includes('nondeterminism');
+    const metrics = {
+        engine: 'rapier2d-compat',
+        packageName: '@dimforge/rapier2d-compat',
+        certified,
+        checksummedGameplayAllowed,
+        checksummedGameplayRejected,
+        requiredGates,
+        knownIssue,
+        checksumConverged: checksummedGameplayRejected,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runEcsLiteFixture(manifest, fixture) {
+    const world = createTinyEcsWorld();
+    const player = ecsCreateEntity(world);
+    const enemy = ecsCreateEntity(world);
+    ecsAddComponent(world, player, 'Position', { x: 10, y: 0 });
+    ecsAddComponent(world, player, 'Velocity', { x: 1, y: 0 });
+    ecsAddComponent(world, enemy, 'Position', { x: 20, y: 0 });
+    ecsSetSingleton(world, 'Match', { frame: fixture.frames });
+    const snapshot = ecsSnapshot(world);
+    const createdAfterSnapshot = ecsCreateEntity(world);
+    ecsAddComponent(world, createdAfterSnapshot, 'Position', { x: 30, y: 0 });
+    ecsDestroyEntity(world, enemy);
+    const restored = ecsRestore(snapshot);
+    const rollbackCreateDestroyEqual = ecsChecksum(restored) === ecsChecksum(ecsRestore(snapshot));
+    const query = ecsQuery(restored, ['Position']);
+    const stableEntityIds = player === 1 && enemy === 2 && createdAfterSnapshot === 3;
+    const queryOrderStable = (0, canonical_js_1.defaultChecksum)(query) === (0, canonical_js_1.defaultChecksum)(ecsQuery(restored, ['Position']));
+    const snapshotRestoreEqual = ecsChecksum(restored) === ecsChecksum(ecsRestore(snapshot));
+    const singletonStateStable = (0, canonical_js_1.defaultChecksum)(restored.singletons) === (0, canonical_js_1.defaultChecksum)({ Match: { frame: fixture.frames } });
+    const componentLifecycleStable = query.length === 2 && ecsQuery(restored, ['Position', 'Velocity']).length === 1;
+    const metrics = {
+        stableEntityIds,
+        queryOrderStable,
+        snapshotRestoreEqual,
+        rollbackCreateDestroyEqual,
+        singletonStateStable,
+        componentLifecycleStable,
+        checksumConverged: stableEntityIds &&
+            queryOrderStable &&
+            snapshotRestoreEqual &&
+            rollbackCreateDestroyEqual &&
+            singletonStateStable &&
+            componentLifecycleStable,
+        worldChecksum: ecsChecksum(restored),
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runKccLiteFixture(manifest, fixture) {
+    const uninterrupted = runKccSimulation(fixture.frames, fixture.seed, -1);
+    const restored = runKccSimulation(fixture.frames, fixture.seed, Math.floor(fixture.frames / 2));
+    const metrics = {
+        groundedFrames: restored.groundedFrames,
+        horizontalTravel: restored.horizontalTravel,
+        jumps: restored.jumps,
+        coyoteJumps: restored.coyoteJumps,
+        wallCollisions: restored.wallCollisions,
+        leftWallCollisions: restored.leftWallCollisions,
+        rightWallCollisions: restored.rightWallCollisions,
+        rollbackChecksumEqual: uninterrupted.finalChecksum === restored.finalChecksum,
+        queryOrderStable: restored.queryOrderStable,
+        finalChecksum: restored.finalChecksum,
+        checksumConverged: uninterrupted.finalChecksum === restored.finalChecksum && restored.queryOrderStable,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runNavigationGridFixture(manifest, fixture) {
+    const uninterrupted = runGridNavigationSimulation(fixture.players, fixture.frames, fixture.seed, -1);
+    const restored = runGridNavigationSimulation(fixture.players, fixture.frames, fixture.seed, Math.floor(fixture.frames / 2));
+    const metrics = {
+        pathChecksum: restored.finalChecksum,
+        pathsFound: restored.pathsFound,
+        unreachableDetected: restored.unreachableDetected,
+        queryOrderStable: restored.queryOrderStable,
+        avoidanceStable: restored.avoidanceStable,
+        rollbackChecksumEqual: uninterrupted.finalChecksum === restored.finalChecksum,
+        checksumConverged: uninterrupted.finalChecksum === restored.finalChecksum &&
+            restored.queryOrderStable &&
+            restored.avoidanceStable &&
+            restored.unreachableDetected,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runProjectileHitscanFixture(manifest, fixture) {
+    const uninterrupted = runProjectileSimulation(fixture.players, fixture.frames, fixture.seed, -1);
+    const restored = runProjectileSimulation(fixture.players, fixture.frames, fixture.seed, Math.floor(fixture.frames / 2));
+    const metrics = {
+        raycastOrderStable: restored.raycastOrderStable,
+        projectileHits: restored.projectileHits,
+        hitscanHits: restored.hitscanHits,
+        cooldownBlocks: restored.cooldownBlocks,
+        respawns: restored.respawns,
+        rollbackChecksumEqual: uninterrupted.finalChecksum === restored.finalChecksum,
+        eventCancellationCount: restored.eventCancellationCount,
+        finalChecksum: restored.finalChecksum,
+        checksumConverged: uninterrupted.finalChecksum === restored.finalChecksum && restored.raycastOrderStable,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runReferenceSamplesFixture(manifest, fixture) {
+    const sampleIds = [
+        'asteroids-basic',
+        'platform-shooter-2d',
+        'simple-fps',
+        'twin-stick-shooter',
+        'arena-brawler',
+        'racer-25d',
+        'turn-flow-mini-golf',
+    ];
+    const samples = sampleIds.map((sampleId, index) => runReferenceSampleSimulation(sampleId, Math.max(2, fixture.players), fixture.frames, fixture.seed + index));
+    const metrics = {
+        samples,
+        sampleIds,
+        checksumConverged: samples.every((sample) => sample.rollbackChecksumEqual && sample.events > 0),
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runBotReplacementFixture(manifest, fixture) {
+    const botSlots = [Math.min(1, fixture.players - 1), Math.min(3, fixture.players - 1)];
+    const authority = (0, protocol_lab_js_1.runProtocolRollbackLab)({
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 6,
+        botSlots,
+    });
+    const replacement = (0, protocol_lab_js_1.runProtocolRollbackLab)({
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 6,
+        botSlots,
+    });
+    const metrics = {
+        botInputFrames: replacement.botInputFrames,
+        disconnectedSlot: botSlots[0],
+        replacementChecksumEqual: authority.authorityChecksum === replacement.authorityChecksum,
+        authorityChecksum: authority.authorityChecksum,
+        replacementChecksum: replacement.authorityChecksum,
+        checksumConverged: authority.authorityChecksum === replacement.authorityChecksum && replacement.result === 'pass',
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runGenre128Fixture(manifest, fixture) {
+    const botSlots = Array.from({ length: 32 }, (_, index) => 96 + index);
+    const protocol = (0, protocol_lab_js_1.runProtocolRollbackLab)({
+        game: 'command-bursts',
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 100,
+        lossPermille: 20,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        botSlots,
+        eventTimelineLimit: 8,
+    });
+    const metrics = {
+        players: fixture.players,
+        frames: fixture.frames,
+        movementFrames: fixture.players * fixture.frames,
+        collisionOrHitResolutions: protocol.eventTimeline.confirmed + protocol.eventTimeline.verifiedOnly,
+        events: protocol.eventTimeline.totalRecords,
+        botInputFrames: protocol.botInputFrames,
+        authorityChecksum: protocol.authorityChecksum,
+        clientChecksum: protocol.clientChecksum,
+        replayVerification: {
+            mismatches: Number(protocol.authorityChecksum !== protocol.clientChecksum),
+            finalChecksum: protocol.clientChecksum,
+        },
+        protocolRollback: {
+            rollbacks: protocol.rollbacks,
+            maxRollbackDepth: protocol.maxRollbackDepth,
+        },
+        checksumConverged: protocol.result === 'pass' && protocol.authorityChecksum === protocol.clientChecksum,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+const defaultProtocolProfiles = [
+    'delay-jitter',
+    'loss-duplicate-reorder',
+    'reconnect',
+    'late-join',
+    'asymmetric-latency',
+    'input-delay',
+    'bots',
+    'command-bursts',
+    'expected-desync',
+];
+function runNetcodeFixture(manifest, fixture) {
+    const hz = fixture.hz ?? 10;
+    const rttMs = fixture.rttMs ?? 200;
+    const jitterMs = fixture.jitterMs ?? 100;
+    const oneWayDelayFrames = Math.max(0, Math.round((rttMs / 2 / 1000) * hz));
+    const jitterFrames = Math.max(0, Math.round((jitterMs / 2 / 1000) * hz));
+    const minDelayFrames = Math.max(0, oneWayDelayFrames - jitterFrames);
+    const maxDelayFrames = Math.max(minDelayFrames, oneWayDelayFrames + jitterFrames);
+    const startedAt = performance.now();
+    const protocol = (0, protocol_lab_js_1.runProtocolRollbackLab)({
+        game: netcodeShapeToGame(fixture.shape),
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        minDelayFrames,
+        maxDelayFrames,
+        bundleSizeFrames: fixture.bundleSizeFrames ?? 1,
+        inputDelayFrames: fixture.inputDelayFrames ?? 0,
+        duplicatePermille: fixture.duplicatePermille ?? 0,
+        lossPermille: (fixture.lossPercent ?? 0) * 10,
+        resendIntervalFrames: Math.max(1, maxDelayFrames + 1),
+        maxResendAttempts: Math.max(1, maxDelayFrames + 6),
+        eventTimelineLimit: fixture.eventTimelineLimit ?? 0,
+    });
+    const elapsedMs = performance.now() - startedAt;
+    const sampleInputRandom = new random_js_1.DeterministicRandom(fixture.seed);
+    const sampleInputs = Array.from({ length: fixture.players }, () => (0, sample_lab_js_1.makeLabInput)(sampleInputRandom));
+    const packedInputBytesPerTick = (0, sample_lab_js_1.packLabInputFrame)(sampleInputs).byteLength;
+    const jsonInputBytesPerTick = estimateJsonBytes({ frame: 0, inputs: sampleInputs });
+    const replayBytes = estimateNetcodeReplayBytes(fixture.shape, fixture.players, fixture.seed, estimateJsonArrayBytes(jsonInputBytesPerTick * fixture.frames, fixture.frames), estimateJsonArrayBytes(estimateJsonBytes({ frame: 0, checksum: '0000000000000000' }) * fixture.frames, fixture.frames));
+    const metrics = {
+        shape: fixture.shape,
+        game: protocol.game,
+        authorityChecksum: protocol.authorityChecksum,
+        clientChecksum: protocol.clientChecksum,
+        checksumConverged: protocol.authorityChecksum === protocol.clientChecksum && protocol.result === 'pass',
+        rollbacks: protocol.rollbacks,
+        maxRollbackDepth: protocol.maxRollbackDepth,
+        replayBytes,
+        packedInputBytesPerTick: packedInputBytesPerTick.toFixed(2),
+        packedInputBytesPerSecond: (packedInputBytesPerTick * hz).toFixed(2),
+        inputBytesPerTick: jsonInputBytesPerTick.toFixed(2),
+        checksumCostMsP95: benchmarkChecksumCost(fixture.shape, fixture.players, fixture.seed),
+        elapsedMs: elapsedMs.toFixed(2),
+        heapUsedBytes: getHeapUsedBytes(),
+        rssBytes: getRssBytes(),
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runReplayNodeFixture(manifest, fixture) {
+    const startedAt = performance.now();
+    const session = (0, sample_lab_js_1.createLabSession)({
+        players: fixture.players,
+        seed: fixture.seed,
+        replayRecordingMode: 'memory',
+    });
+    const inputRandom = new random_js_1.DeterministicRandom(fixture.seed);
+    let packedInputBytes = 0;
+    for (let frame = 0; frame < fixture.frames; frame += 1) {
+        const frameInputs = (0, sample_lab_js_1.applyLabInputs)(session, fixture.players, inputRandom);
+        packedInputBytes += (0, sample_lab_js_1.packLabInputFrame)(frameInputs).byteLength;
+        session.stepFrames(1);
+    }
+    const replay = session.exportReplay();
+    const verification = (0, replay_js_1.verifyReplay)({
+        replay,
+        step: sample_lab_js_1.labStep,
+        defaultInput: sample_lab_js_1.labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        hydrateInput: sample_lab_js_1.hydrateLabInput,
+        throwOnMismatch: false,
+    });
+    const replayBytes = estimateJsonBytes(replay);
+    const elapsedMs = performance.now() - startedAt;
+    const metrics = {
+        finalChecksum: verification.finalChecksum,
+        replayBytes,
+        packedInputBytesPerTick: (packedInputBytes / fixture.frames).toFixed(2),
+        packedInputBytesPerSecond: ((packedInputBytes / fixture.frames) * 30).toFixed(2),
+        replayVerification: {
+            frames: verification.frames,
+            checksums: verification.checksums,
+            mismatches: verification.mismatches,
+            finalChecksum: verification.finalChecksum,
+        },
+        elapsedMs: elapsedMs.toFixed(2),
+        heapUsedBytes: getHeapUsedBytes(),
+        rssBytes: getRssBytes(),
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runProtocolMatrixFixture(manifest, fixture) {
+    const profiles = (fixture.profiles ?? defaultProtocolProfiles).map((profileId) => runProtocolMatrixProfile(fixture, profileId));
+    const frameModel = {
+        currentFrame: fixture.frames,
+        verifiedFrame: fixture.frames,
+        predictedFrame: fixture.frames,
+        previousPredictedFrame: Math.max(0, fixture.frames - 1),
+        rollbackCount: sumProfiles(profiles, 'rollbacks'),
+        correctionCount: profiles.reduce((sum, profile) => sum + profile.corrections, 0),
+        maxRollbackDepth: Math.max(0, ...profiles.map((profile) => profile.maxRollbackDepth)),
+        deterministicStats: {
+            confirmations: sumProfiles(profiles, 'confirmations'),
+            deliveries: sumProfiles(profiles, 'deliveries'),
+            duplicates: sumProfiles(profiles, 'duplicates'),
+            lost: sumProfiles(profiles, 'lost'),
+            reorders: sumProfiles(profiles, 'reorders'),
+            disconnectDrops: sumProfiles(profiles, 'disconnectDrops'),
+            absentInputFrames: sumProfiles(profiles, 'absentInputFrames'),
+            botInputFrames: sumProfiles(profiles, 'botInputFrames'),
+            commandProfiles: profiles.filter((profile) => profile.channel === 'command').length,
+        },
+    };
+    const metrics = {
+        schemaArtifactId: 'protocol-matrix/v1',
+        profiles,
+        frameModel,
+        checksumConverged: profiles.every((profile) => profile.profileId === 'expected-desync' ? profile.result === 'desync' : profile.checksumConverged),
+        expectedDesyncArtifacts: profiles
+            .filter((profile) => profile.profileId === 'expected-desync')
+            .every((profile) => profile.desyncArtifact !== undefined),
+        maxRollbackDepth: frameModel.maxRollbackDepth,
+    };
+    return createFixtureReport(manifest, fixture, metrics);
+}
+function runProtocolMatrixProfile(fixture, profileId) {
+    const options = createProtocolMatrixOptions(fixture, profileId);
+    const result = (0, protocol_lab_js_1.runProtocolRollbackLab)(options);
+    const expectedDesync = profileId === 'expected-desync';
+    const checksumConverged = result.authorityChecksum === result.clientChecksum && result.result === 'pass';
+    const profileResult = expectedDesync && result.result === 'desync'
+        ? 'desync'
+        : certificationPassFail(checksumConverged);
+    const desyncArtifact = expectedDesync && result.result === 'desync'
+        ? createDesyncArtifact(options, result)
+        : undefined;
+    const metrics = {
+        profileId,
+        channel: profileId === 'command-bursts' ? 'command' : 'input',
+        authorityChecksum: result.authorityChecksum,
+        clientChecksum: result.clientChecksum,
+        checksumConverged,
+        rollbacks: result.rollbacks,
+        corrections: result.eventTimeline.canceled,
+        maxRollbackDepth: result.maxRollbackDepth,
+        confirmations: result.confirmations,
+        deliveries: result.deliveries,
+        duplicates: result.duplicates,
+        lost: result.lost,
+        disconnectDrops: result.disconnectDrops,
+        absentInputFrames: result.absentInputFrames,
+        botInputFrames: result.botInputFrames,
+        inputDelayFrames: result.inputDelayFrames,
+        reorders: result.reorders,
+        result: profileResult,
+    };
+    return desyncArtifact === undefined ? metrics : { ...metrics, desyncArtifact };
+}
+function createProtocolMatrixOptions(fixture, profileId) {
+    const base = {
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 6,
+        eventTimelineLimit: 8,
+    };
+    if (profileId === 'loss-duplicate-reorder') {
+        return {
+            ...base,
+            duplicatePermille: 250,
+            lossPermille: 80,
+            resendIntervalFrames: 7,
+            maxResendAttempts: 12,
+        };
+    }
+    if (profileId === 'reconnect') {
+        return {
+            ...base,
+            duplicatePermille: 100,
+            lossPermille: 80,
+            resendIntervalFrames: 7,
+            maxResendAttempts: 12,
+            disconnectStartFrame: Math.max(4, Math.floor(fixture.frames * 0.25)),
+            disconnectEndFrame: Math.max(6, Math.floor(fixture.frames * 0.35)),
+        };
+    }
+    if (profileId === 'late-join') {
+        return {
+            ...base,
+            lateJoinSlot: Math.max(0, fixture.players - 1),
+            lateJoinFrame: Math.floor(fixture.frames / 2),
+        };
+    }
+    if (profileId === 'asymmetric-latency') {
+        return {
+            ...base,
+            latencySkewSlot: Math.max(0, fixture.players - 2),
+            latencySkewFrames: 12,
+        };
+    }
+    if (profileId === 'input-delay') {
+        return {
+            ...base,
+            inputDelayFrames: 8,
+        };
+    }
+    if (profileId === 'bots') {
+        return {
+            ...base,
+            botSlots: [Math.min(1, fixture.players - 1), Math.min(3, fixture.players - 1)],
+        };
+    }
+    if (profileId === 'command-bursts') {
+        return {
+            ...base,
+            game: 'command-bursts',
+            duplicatePermille: 100,
+        };
+    }
+    if (profileId === 'expected-desync') {
+        return {
+            ...base,
+            desyncFrame: Math.floor(fixture.frames / 2),
+            desyncSlot: Math.min(2, fixture.players - 1),
+            expectDesync: true,
+        };
+    }
+    return {
+        ...base,
+        duplicatePermille: 100,
+    };
+}
+function createTinyEcsWorld() {
+    return {
+        nextEntityId: 1,
+        entities: [],
+        components: {},
+        singletons: {},
+    };
+}
+function ecsCreateEntity(world) {
+    const entityId = world.nextEntityId;
+    world.nextEntityId += 1;
+    world.entities.push(entityId);
+    world.entities.sort((left, right) => left - right);
+    return entityId;
+}
+function ecsDestroyEntity(world, entityId) {
+    world.entities = world.entities.filter((id) => id !== entityId);
+    for (const store of Object.values(world.components)) {
+        delete store[String(entityId)];
+    }
+}
+function ecsAddComponent(world, entityId, component, value) {
+    world.components[component] = world.components[component] ?? {};
+    world.components[component][String(entityId)] = value;
+}
+function ecsSetSingleton(world, name, value) {
+    world.singletons[name] = value;
+}
+function ecsQuery(world, components) {
+    return world.entities
+        .filter((entityId) => components.every((component) => world.components[component]?.[String(entityId)] !== undefined))
+        .sort((left, right) => left - right);
+}
+function ecsSnapshot(world) {
+    return (0, canonical_js_1.canonicalStringify)(world);
+}
+function ecsRestore(snapshot) {
+    return JSON.parse(snapshot);
+}
+function ecsChecksum(world) {
+    return (0, canonical_js_1.defaultChecksum)(world);
+}
+function runGridNavigationSimulation(players, frames, seed, restoreFrame) {
+    const width = 16;
+    const height = 16;
+    const obstacles = createNavigationObstacles(width, height, seed);
+    let state = Array.from({ length: players }, (_, slot) => ({
+        x: slot % width,
+        y: Math.floor(slot / width),
+        targetX: (width - 1 - slot) % width,
+        targetY: height - 1 - Math.floor(slot / width),
+    }));
+    let checkpoint;
+    let pathsFound = 0;
+    let avoidanceStable = true;
+    const baselineQuery = findGridPath({ x: 0, y: 0 }, { x: width - 1, y: height - 1 }, width, height, obstacles);
+    const repeatedQuery = findGridPath({ x: 0, y: 0 }, { x: width - 1, y: height - 1 }, width, height, obstacles);
+    const blocked = new Set(obstacles);
+    blocked.add(gridKey(1, 0));
+    blocked.add(gridKey(0, 1));
+    const unreachableDetected = findGridPath({ x: 0, y: 0 }, { x: 2, y: 2 }, width, height, blocked).length === 0;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            checkpoint = (0, canonical_js_1.cloneCanonical)(state);
+        }
+        if (frame === restoreFrame + 3 && checkpoint !== undefined) {
+            state = (0, canonical_js_1.cloneCanonical)(checkpoint);
+            for (let replayFrame = restoreFrame; replayFrame < frame; replayFrame += 1) {
+                state = stepGridNavigation(state, replayFrame, width, height, obstacles);
+            }
+        }
+        state = stepGridNavigation(state, frame, width, height, obstacles);
+        pathsFound += state.length;
+        const occupied = new Set();
+        for (const position of state) {
+            const key = gridKey(position.x, position.y);
+            avoidanceStable = avoidanceStable && !occupied.has(key);
+            occupied.add(key);
+        }
+    }
+    return {
+        finalChecksum: (0, canonical_js_1.defaultChecksum)(state),
+        pathsFound,
+        unreachableDetected,
+        queryOrderStable: (0, canonical_js_1.defaultChecksum)(baselineQuery) === (0, canonical_js_1.defaultChecksum)(repeatedQuery),
+        avoidanceStable,
+    };
+}
+function stepGridNavigation(state, frame, width, height, obstacles) {
+    const reserved = new Set();
+    const occupied = new Set(state.map((agent) => gridKey(agent.x, agent.y)));
+    return state.map((agent, slot) => {
+        const currentKey = gridKey(agent.x, agent.y);
+        occupied.delete(currentKey);
+        const target = {
+            x: (agent.targetX + (frame % 7 === 0 ? slot : 0)) % width,
+            y: (agent.targetY + (frame % 11 === 0 ? 1 : 0)) % height,
+        };
+        const path = findGridPath({ x: agent.x, y: agent.y }, target, width, height, obstacles);
+        const next = path[1] ?? { x: agent.x, y: agent.y };
+        const nextKey = gridKey(next.x, next.y);
+        if (reserved.has(nextKey) || occupied.has(nextKey)) {
+            reserved.add(currentKey);
+            return { ...agent, targetX: target.x, targetY: target.y };
+        }
+        reserved.add(nextKey);
+        return { x: next.x, y: next.y, targetX: target.x, targetY: target.y };
+    });
+}
+function findGridPath(start, target, width, height, obstacles) {
+    if (obstacles.has(gridKey(start.x, start.y)) || obstacles.has(gridKey(target.x, target.y))) {
+        return [];
+    }
+    const queue = [start];
+    const cameFrom = new Map([[gridKey(start.x, start.y), undefined]]);
+    const points = new Map([[gridKey(start.x, start.y), start]]);
+    const directions = [
+        { x: 1, y: 0 },
+        { x: 0, y: 1 },
+        { x: -1, y: 0 },
+        { x: 0, y: -1 },
+    ];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.x === target.x && current.y === target.y) {
+            return reconstructGridPath(target, cameFrom, points);
+        }
+        for (const direction of directions) {
+            const next = { x: current.x + direction.x, y: current.y + direction.y };
+            const key = gridKey(next.x, next.y);
+            if (next.x < 0 ||
+                next.y < 0 ||
+                next.x >= width ||
+                next.y >= height ||
+                obstacles.has(key) ||
+                cameFrom.has(key)) {
+                continue;
+            }
+            cameFrom.set(key, gridKey(current.x, current.y));
+            points.set(key, next);
+            queue.push(next);
+        }
+    }
+    return [];
+}
+function reconstructGridPath(target, cameFrom, points) {
+    const path = [];
+    let key = gridKey(target.x, target.y);
+    while (key !== undefined) {
+        const point = points.get(key);
+        /* istanbul ignore next -- reconstructGridPath receives keys from the points map built by findGridPath. */
+        if (point === undefined) {
+            return [];
+        }
+        path.push(point);
+        key = cameFrom.get(key);
+    }
+    return path.reverse();
+}
+function createNavigationObstacles(width, height, seed) {
+    const obstacles = new Set();
+    for (let y = 1; y < height - 1; y += 3) {
+        for (let x = 2; x < width - 2; x += 5) {
+            if ((x + y + seed) % 4 !== 0) {
+                obstacles.add(gridKey(x, y));
+            }
+        }
+    }
+    return obstacles;
+}
+function gridKey(x, y) {
+    return `${x},${y}`;
+}
+function runReferenceSampleSimulation(sampleId, players, frames, seed) {
+    const uninterrupted = runReferenceSample(sampleId, players, frames, seed, -1);
+    const restored = runReferenceSample(sampleId, players, frames, seed, Math.floor(frames / 2));
+    return {
+        sampleId,
+        players,
+        frames,
+        mechanics: referenceSampleMechanics(sampleId),
+        finalChecksum: uninterrupted.checksum,
+        replayChecksum: restored.checksum,
+        rollbackChecksumEqual: uninterrupted.checksum === restored.checksum,
+        events: restored.events,
+    };
+}
+function runReferenceSample(sampleId, players, frames, seed, restoreFrame) {
+    let state = createReferenceSampleState(sampleId, players, seed);
+    let checkpoint;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            checkpoint = (0, canonical_js_1.cloneCanonical)(state);
+        }
+        if (frame === restoreFrame + 5 && checkpoint !== undefined) {
+            state = (0, canonical_js_1.cloneCanonical)(checkpoint);
+            for (let replayFrame = restoreFrame; replayFrame < frame; replayFrame += 1) {
+                state = stepReferenceSample(state, replayFrame, seed);
+            }
+        }
+        state = stepReferenceSample(state, frame, seed);
+    }
+    return { checksum: (0, canonical_js_1.defaultChecksum)(state), events: state.events };
+}
+function createReferenceSampleState(sampleId, players, seed) {
+    return {
+        frame: 0,
+        sampleId,
+        x: Array.from({ length: players }, (_, slot) => slot * 3 + seed % 5),
+        y: Array.from({ length: players }, (_, slot) => (slot % 4) * 4),
+        z: Array.from({ length: players }, () => 0),
+        hp: Array.from({ length: players }, () => 10),
+        cooldown: Array.from({ length: players }, () => 0),
+        score: Array.from({ length: players }, () => 0),
+        phase: 0,
+        events: 0,
+    };
+}
+function stepReferenceSample(state, frame, seed) {
+    const x = state.x.slice();
+    const y = state.y.slice();
+    const z = state.z.slice();
+    const hp = state.hp.slice();
+    const cooldown = state.cooldown.map((value) => Math.max(0, value - 1));
+    const score = state.score.slice();
+    let events = state.events;
+    for (let slot = 0; slot < x.length; slot += 1) {
+        const direction = ((seed + frame + slot) % 3) - 1;
+        if (state.sampleId === 'platform-shooter-2d') {
+            x[slot] += direction;
+            y[slot] = Math.max(0, y[slot] + (frame % 30 === 0 ? 5 : -1));
+            if (frame % 17 === slot % 17) {
+                events += hitReferenceTarget(slot, hp, score);
+            }
+            continue;
+        }
+        if (state.sampleId === 'simple-fps') {
+            x[slot] += direction * 2;
+            z[slot] += ((frame + slot) % 2) * 2 - 1;
+            if (cooldown[slot] === 0) {
+                cooldown[slot] = 12;
+                events += hitReferenceTarget(slot, hp, score);
+            }
+            continue;
+        }
+        if (state.sampleId === 'racer-25d') {
+            x[slot] = (x[slot] + 2 + slot % 3) % 400;
+            z[slot] = (z[slot] + direction + 9) % 9;
+            if (x[slot] < 3) {
+                score[slot] += 1;
+                events += 1;
+            }
+            continue;
+        }
+        if (state.sampleId === 'turn-flow-mini-golf') {
+            if (frame % Math.max(8, x.length) === slot % Math.max(8, x.length)) {
+                x[slot] += 8 - (slot % 3);
+                y[slot] += direction;
+                score[slot] += x[slot] > 120 ? 1 : 0;
+                events += 1;
+            }
+            continue;
+        }
+        x[slot] += direction;
+        y[slot] += ((frame + slot) % 2) * 2 - 1;
+        if (frame % 13 === slot % 13) {
+            events += hitReferenceTarget(slot, hp, score);
+        }
+    }
+    return {
+        frame: state.frame + 1,
+        sampleId: state.sampleId,
+        x,
+        y,
+        z,
+        hp,
+        cooldown,
+        score,
+        phase: (state.phase + 1) % 1024,
+        events,
+    };
+}
+function hitReferenceTarget(slot, hp, score) {
+    const target = (slot + 1) % hp.length;
+    hp[target] -= 1;
+    score[slot] += 1;
+    if (hp[target] <= 0) {
+        hp[target] = 10;
+        score[target] -= 1;
+        return 2;
+    }
+    return 1;
+}
+function referenceSampleMechanics(sampleId) {
+    if (sampleId === 'platform-shooter-2d') {
+        return ['platformer-movement', 'jump-gravity', 'projectile-hit'];
+    }
+    if (sampleId === 'simple-fps') {
+        return ['3d-position', 'cooldown-hitscan', 'health'];
+    }
+    if (sampleId === 'twin-stick-shooter') {
+        return ['top-down-movement', 'projectile-hit', 'cooldown'];
+    }
+    if (sampleId === 'arena-brawler') {
+        return ['melee-hit-resolution', 'health', 'score'];
+    }
+    if (sampleId === 'racer-25d') {
+        return ['track-progress', 'lane-position', 'lap-score'];
+    }
+    if (sampleId === 'turn-flow-mini-golf') {
+        return ['turn-order', 'ball-motion', 'hole-score'];
+    }
+    return ['wraparound-motion', 'collision-events', 'score'];
+}
+function runKccSimulation(frames, seed, restoreFrame) {
+    let state = { frame: 0, x: 0, y: 0, vx: 0, vy: 0, grounded: true, coyote: 0 };
+    let snapshot = '';
+    let groundedFrames = 0;
+    let horizontalTravel = 0;
+    let jumps = 0;
+    let coyoteJumps = 0;
+    let wallCollisions = 0;
+    let leftWallCollisions = 0;
+    let rightWallCollisions = 0;
+    let queryOrderStable = true;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = (0, canonical_js_1.canonicalStringify)(state);
+            state = JSON.parse(snapshot);
+        }
+        if (frame === 18) {
+            state = { ...state, grounded: false, coyote: 2 };
+        }
+        const move = frame >= 30 && frame < 50 ? 1 : frame >= 60 && frame < 90 ? -1 : ((frame + seed) % 3) - 1;
+        const wantsJump = frame === 2 || frame === 18;
+        const usedCoyoteJump = wantsJump && !state.grounded && state.coyote > 0;
+        if (wantsJump && (state.grounded || state.coyote > 0)) {
+            state = { ...state, vy: 9, grounded: false, coyote: 0 };
+            jumps += 1;
+            if (usedCoyoteJump) {
+                coyoteJumps += 1;
+            }
+        }
+        const previousX = state.x;
+        let x = state.x + move * 2;
+        if (x > 24) {
+            x = 24;
+            wallCollisions += 1;
+            rightWallCollisions += 1;
+        }
+        if (x < -24) {
+            x = -24;
+            wallCollisions += 1;
+            leftWallCollisions += 1;
+        }
+        horizontalTravel += Math.abs(x - previousX);
+        const vy = state.vy - 1;
+        let y = state.y + vy;
+        let grounded = false;
+        let nextVy = vy;
+        if (y <= 0) {
+            y = 0;
+            nextVy = 0;
+            grounded = true;
+            groundedFrames += 1;
+        }
+        const coyote = grounded ? 4 : Math.max(0, state.coyote - 1);
+        const queries = ['ground', 'wall-left', 'wall-right'].sort();
+        queryOrderStable = queryOrderStable && (0, canonical_js_1.defaultChecksum)(queries) === (0, canonical_js_1.defaultChecksum)(['ground', 'wall-left', 'wall-right'].sort());
+        state = { frame: frame + 1, x, y, vx: move * 2, vy: nextVy, grounded, coyote };
+    }
+    return {
+        finalChecksum: (0, canonical_js_1.defaultChecksum)(state),
+        groundedFrames,
+        horizontalTravel,
+        jumps,
+        coyoteJumps,
+        wallCollisions,
+        leftWallCollisions,
+        rightWallCollisions,
+        queryOrderStable,
+    };
+}
+function runProjectileSimulation(players, frames, seed, restoreFrame) {
+    let state = {
+        frame: 0,
+        health: Array.from({ length: players }, () => 3),
+        cooldowns: Array.from({ length: players }, () => 0),
+        projectiles: [],
+        nextProjectileId: 1,
+    };
+    let snapshot = '';
+    let projectileHits = 0;
+    let hitscanHits = 0;
+    let cooldownBlocks = 0;
+    let respawns = 0;
+    let eventCancellationCount = 0;
+    let raycastOrderStable = true;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = (0, canonical_js_1.canonicalStringify)(state);
+            state = JSON.parse(snapshot);
+            eventCancellationCount += 1;
+        }
+        const health = state.health.slice();
+        const cooldowns = state.cooldowns.map((cooldown) => Math.max(0, cooldown - 1));
+        const projectiles = state.projectiles
+            .map((projectile) => ({ ...projectile, x: projectile.x + projectile.vx }))
+            .filter((projectile) => Math.abs(projectile.x) < 80);
+        let nextProjectileId = state.nextProjectileId;
+        for (let slot = 0; slot < players; slot += 1) {
+            const fireCadence = (frame + slot + seed) % 17;
+            const wantsFire = fireCadence === 0 || fireCadence === 1;
+            if (!wantsFire) {
+                continue;
+            }
+            if (cooldowns[slot] > 0) {
+                cooldownBlocks += 1;
+                continue;
+            }
+            cooldowns[slot] = 6;
+            projectiles.push({ id: nextProjectileId, owner: slot, x: slot * 10, vx: slot % 2 === 0 ? 3 : -3 });
+            nextProjectileId += 1;
+            const rayTargets = Array.from({ length: players }, (_, target) => target)
+                .filter((target) => target !== slot)
+                .sort((left, right) => left - right);
+            raycastOrderStable = raycastOrderStable && (0, canonical_js_1.defaultChecksum)(rayTargets) === (0, canonical_js_1.defaultChecksum)([...rayTargets].sort((left, right) => left - right));
+            const target = rayTargets[(frame + slot) % rayTargets.length];
+            health[target] -= 1;
+            hitscanHits += 1;
+        }
+        for (const projectile of projectiles) {
+            const target = Math.abs(Math.trunc(projectile.x / 10)) % players;
+            if (target !== projectile.owner && frame % 19 === 0) {
+                health[target] -= 1;
+                projectileHits += 1;
+            }
+        }
+        for (let slot = 0; slot < players; slot += 1) {
+            if (health[slot] <= 0) {
+                health[slot] = 3;
+                respawns += 1;
+            }
+        }
+        state = { frame: frame + 1, health, cooldowns, projectiles, nextProjectileId };
+    }
+    return {
+        finalChecksum: (0, canonical_js_1.defaultChecksum)(state),
+        raycastOrderStable,
+        projectileHits,
+        hitscanHits,
+        cooldownBlocks,
+        respawns,
+        eventCancellationCount,
+    };
+}
+function createCertificationDescriptor() {
+    return {
+        deterministicVersion: 'counter-duel@1',
+        tickRate: 30,
+        maxPlayers: 8,
+        input: {
+            id: 'counter-duel-input/v1',
+            fields: [
+                {
+                    name: 'attack',
+                    kind: 'boolean',
+                    policy: 'command',
+                    defaultValue: false,
+                },
+                {
+                    name: 'targetSlot',
+                    kind: 'player-slot',
+                    policy: 'repeat',
+                    defaultValue: 0,
+                },
+            ],
+        },
+        commandChannels: [
+            {
+                id: 'combat',
+                fields: [
+                    {
+                        name: 'attack',
+                        kind: 'boolean',
+                    },
+                ],
+                delivery: 'reliable',
+            },
+        ],
+        state: {
+            id: 'counter-duel-state/v1',
+            fields: [
+                {
+                    name: 'health',
+                    kind: 'integer',
+                    numericMode: 'integer',
+                    collectionOrdering: 'indexed',
+                    checksummed: true,
+                },
+                {
+                    name: 'score',
+                    kind: 'integer',
+                    numericMode: 'integer',
+                    collectionOrdering: 'indexed',
+                    checksummed: true,
+                },
+            ],
+        },
+        events: [
+            {
+                id: 'counter-duel.hit',
+                rollback: 'verified-only',
+                payloadFields: [
+                    {
+                        name: 'attacker',
+                        kind: 'player-slot',
+                    },
+                    {
+                        name: 'target',
+                        kind: 'player-slot',
+                    },
+                ],
+            },
+        ],
+        prototypes: [
+            {
+                id: 'player',
+                components: ['Position', 'Health'],
+            },
+        ],
+        systems: [
+            {
+                id: 'cooldowns',
+            },
+            {
+                id: 'combat',
+            },
+        ],
+    };
+}
+function createDesyncArtifact(options, result) {
+    const firstDesyncFrame = options.desyncFrame;
+    return {
+        firstDesyncFrame,
+        localChecksum: result.clientChecksum,
+        authorityChecksum: result.authorityChecksum,
+        inputDump: {
+            frame: firstDesyncFrame,
+            slot: options.desyncSlot,
+            injected: true,
+        },
+        stateDump: {
+            frame: result.frames,
+            localChecksum: result.clientChecksum,
+            authorityChecksum: result.authorityChecksum,
+        },
+        schemaArtifactId: 'protocol-matrix/v1',
+        runtimeConfig: {
+            ...options,
+            disconnectDrops: result.disconnectDrops,
+        },
+        fieldDiff: [
+            {
+                path: '/checksum',
+                local: result.clientChecksum,
+                authority: result.authorityChecksum,
+            },
+        ],
+    };
+}
+function createSkippedBrowserFixtureReport(manifest, fixture) {
+    const metrics = {
+        skippedReason: 'browser replay verification is optional and runs in a separate certification group',
+    };
+    const required = isFixtureRequired(fixture);
+    return createFixtureReport(manifest, fixture, metrics, required ? 'fail' : 'skip', required ? ['required browser replay verification skipped'] : []);
+}
+function createFixtureReport(manifest, fixture, metrics, forcedResult, extraFailures = []) {
+    const tier = resolveFixtureTier(fixture);
+    const required = isFixtureRequired(fixture);
+    const artifactPath = `${manifest.artifactDir}/${fixture.fixtureId}.json`;
+    const reportPath = artifactPath;
+    const budgets = evaluateBudgets(manifest, fixture, metrics);
+    const budgetFailures = budgets
+        .filter((budget) => budget.gating && budget.result === 'fail')
+        .map((budget) => budget.name);
+    const explicitFailures = [
+        ...budgetFailures.map((name) => `budget ${name} failed`),
+        ...extraFailures,
+    ];
+    /* istanbul ignore next -- current failing fixtures provide explicit failures; this fallback protects future forced-fail fixtures. */
+    const failures = forcedResult === 'fail' && explicitFailures.length === 0
+        ? ['fixture reported failure']
+        : explicitFailures;
+    const result = forcedResult === 'skip' ? 'skip' : failures.length === 0 ? (forcedResult ?? 'pass') : 'fail';
+    const reportWithoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        manifestId: manifest.manifestId,
+        fixtureId: fixture.fixtureId,
+        kind: fixture.kind,
+        tier,
+        required,
+        runtimeTarget: fixture.runtimeTarget ?? 'node',
+        players: fixture.players,
+        frames: fixture.frames,
+        seed: fixture.seed,
+        artifactPath,
+        reportPath,
+        metrics,
+        budgets,
+        failures,
+        result,
+    };
+    return {
+        ...reportWithoutId,
+        reportId: (0, canonical_js_1.defaultChecksum)(reportWithoutId),
+    };
+}
+function resolveFixtureTier(fixture) {
+    if (fixture.tier !== undefined) {
+        return fixture.tier;
+    }
+    if (fixture.runtimeTarget === 'chromium' || fixture.runtimeTarget === 'webkit') {
+        return 'optional-browser';
+    }
+    return fixture.required === false ? 'optional' : 'required';
+}
+function isFixtureRequired(fixture) {
+    if (fixture.required !== undefined) {
+        return fixture.required;
+    }
+    return resolveFixtureTier(fixture) === 'required';
+}
+function evaluateBudgets(manifest, fixture, metrics) {
+    const budgets = fixture.budgets ?? {};
+    const results = [];
+    const replayBytes = getReplayBytes(metrics);
+    const packedInputBytesPerSecond = getNumberMetric(metrics, 'packedInputBytesPerSecond');
+    const maxRollbackDepth = getMaxRollbackDepthMetric(metrics);
+    const checksumConverged = getChecksumConverged(metrics);
+    if (budgets.maxReplayBytes !== undefined) {
+        results.push(replayBytes === undefined
+            ? createMissingMetricBudget('maxReplayBytes', budgets.maxReplayBytes, true)
+            : createNumberBudget('maxReplayBytes', replayBytes, budgets.maxReplayBytes, true, replayBytes <= budgets.maxReplayBytes));
+    }
+    if (budgets.maxPackedInputBytesPerSecond !== undefined) {
+        results.push(packedInputBytesPerSecond === undefined
+            ? createMissingMetricBudget('maxPackedInputBytesPerSecond', budgets.maxPackedInputBytesPerSecond, true)
+            : createNumberBudget('maxPackedInputBytesPerSecond', packedInputBytesPerSecond, budgets.maxPackedInputBytesPerSecond, true, packedInputBytesPerSecond <= budgets.maxPackedInputBytesPerSecond));
+    }
+    if (budgets.maxRollbackDepth !== undefined) {
+        results.push(maxRollbackDepth === undefined
+            ? createMissingMetricBudget('maxRollbackDepth', budgets.maxRollbackDepth, true)
+            : createNumberBudget('maxRollbackDepth', maxRollbackDepth, budgets.maxRollbackDepth, true, maxRollbackDepth <= budgets.maxRollbackDepth));
+    }
+    if (budgets.requireChecksumConvergence === true) {
+        results.push(checksumConverged === undefined
+            ? createMissingMetricBudget('requireChecksumConvergence', true, true)
+            : {
+                name: 'requireChecksumConvergence',
+                limit: true,
+                actual: checksumConverged,
+                gating: true,
+                result: certificationPassFail(checksumConverged),
+            });
+    }
+    if (budgets.requireExpectedDesyncArtifacts === true) {
+        const expectedDesyncArtifacts = getExpectedDesyncArtifacts(metrics);
+        results.push({
+            name: 'requireExpectedDesyncArtifacts',
+            limit: true,
+            actual: expectedDesyncArtifacts ?? false,
+            gating: true,
+            result: expectedDesyncArtifacts === true ? 'pass' : 'fail',
+        });
+    }
+    if (budgets.maxElapsedMs !== undefined) {
+        const elapsedMs = getNumberMetric(metrics, 'elapsedMs');
+        results.push(elapsedMs === undefined
+            ? createMissingMetricBudget('maxElapsedMs', budgets.maxElapsedMs, manifest.benchmarkProfile)
+            : createNumberBudget('maxElapsedMs', elapsedMs, budgets.maxElapsedMs, manifest.benchmarkProfile, elapsedMs <= budgets.maxElapsedMs));
+    }
+    if (budgets.maxHeapUsedBytes !== undefined) {
+        const heapUsedBytes = getNumberMetric(metrics, 'heapUsedBytes');
+        results.push(heapUsedBytes === undefined
+            ? createMissingMetricBudget('maxHeapUsedBytes', budgets.maxHeapUsedBytes, manifest.benchmarkProfile)
+            : createNumberBudget('maxHeapUsedBytes', heapUsedBytes, budgets.maxHeapUsedBytes, manifest.benchmarkProfile, heapUsedBytes <= budgets.maxHeapUsedBytes));
+    }
+    if (budgets.maxRssBytes !== undefined) {
+        const rssBytes = getNumberMetric(metrics, 'rssBytes');
+        results.push(rssBytes === undefined
+            ? createMissingMetricBudget('maxRssBytes', budgets.maxRssBytes, manifest.benchmarkProfile)
+            : createNumberBudget('maxRssBytes', rssBytes, budgets.maxRssBytes, manifest.benchmarkProfile, rssBytes <= budgets.maxRssBytes));
+    }
+    return results;
+}
+function createNumberBudget(name, actual, limit, gating, pass) {
+    return {
+        name,
+        limit,
+        actual,
+        gating,
+        result: pass || !gating ? 'pass' : 'fail',
+    };
+}
+function createMissingMetricBudget(name, limit, gating) {
+    return {
+        name,
+        limit,
+        gating,
+        result: gating ? 'fail' : 'skip',
+    };
+}
+function normalizeManifest(manifest) {
+    const defaults = createDefaultCertificationManifest();
+    return {
+        manifestId: manifest.manifestId ?? defaults.manifestId,
+        artifactDir: manifest.artifactDir ?? defaults.artifactDir,
+        benchmarkProfile: manifest.benchmarkProfile ?? defaults.benchmarkProfile,
+        fixtures: manifest.fixtures ?? defaults.fixtures,
+    };
+}
+function createDefaultNetcodeFixture(fixtureId, shape, seed) {
+    return {
+        fixtureId,
+        kind: 'netcode',
+        required: true,
+        runtimeTarget: 'node',
+        shape,
+        players: 128,
+        frames: 1_000,
+        seed,
+        hz: 10,
+        rttMs: 200,
+        jitterMs: 100,
+        lossPercent: 2,
+        duplicatePermille: 100,
+        eventTimelineLimit: 0,
+        budgets: {
+            maxReplayBytes: 16_000_000,
+            maxPackedInputBytesPerSecond: 20_000,
+            maxRollbackDepth: 120,
+            requireChecksumConvergence: true,
+        },
+    };
+}
+function netcodeShapeToGame(shape) {
+    if (shape === 'moderate-state') {
+        return 'moderate-state';
+    }
+    if (shape === 'command-bursts') {
+        return 'command-bursts';
+    }
+    return 'lab';
+}
+function benchmarkChecksumCost(shape, players, seed) {
+    const state = makeNetcodeChecksumState(shape, players, seed);
+    const timings = [];
+    for (let index = 0; index < checksumCostIterations; index += 1) {
+        const startedAt = performance.now();
+        (0, canonical_js_1.defaultChecksum)(state);
+        timings.push(performance.now() - startedAt);
+    }
+    timings.sort((left, right) => left - right);
+    return timings[Math.min(timings.length - 1, Math.floor(timings.length * 0.95))].toFixed(4);
+}
+function makeNetcodeChecksumState(shape, players, seed) {
+    if (shape === 'input-minimal') {
+        return {
+            positions: Array.from({ length: players * 2 }, () => 0),
+            actions: Array.from({ length: players }, () => 0),
+            frame: seed,
+        };
+    }
+    return {
+        frame: seed,
+        positionX: Array.from({ length: players }, (_, slot) => slot * 10),
+        positionY: Array.from({ length: players }, (_, slot) => slot * -10),
+        velocityX: Array.from({ length: players }, (_, slot) => (slot % 3) - 1),
+        velocityY: Array.from({ length: players }, (_, slot) => ((slot + 1) % 3) - 1),
+        health: Array.from({ length: players }, () => 100),
+        cooldown: Array.from({ length: players }, () => 0),
+        flags: Array.from({ length: players }, (_, slot) => slot % 2),
+    };
+}
+function getReplayBytes(metrics) {
+    if ('replayBytes' in metrics) {
+        return metrics.replayBytes;
+    }
+    return undefined;
+}
+function getChecksumConverged(metrics) {
+    if ('checksumConverged' in metrics) {
+        return metrics.checksumConverged;
+    }
+    if ('replayVerification' in metrics) {
+        return metrics.replayVerification.mismatches === 0;
+    }
+    return undefined;
+}
+function getExpectedDesyncArtifacts(metrics) {
+    if ('expectedDesyncArtifacts' in metrics) {
+        return metrics.expectedDesyncArtifacts;
+    }
+    return undefined;
+}
+function sumProfiles(profiles, key) {
+    return profiles.reduce((sum, profile) => sum + profile[key], 0);
+}
+function getNumberMetric(metrics, key) {
+    const value = metrics[key];
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function getMaxRollbackDepthMetric(metrics) {
+    const direct = getNumberMetric(metrics, 'maxRollbackDepth');
+    if (direct !== undefined) {
+        return direct;
+    }
+    const protocolRollback = metrics.protocolRollback;
+    /* istanbul ignore next -- public metrics either expose a finite direct rollback depth or omit protocolRollback entirely. */
+    if (protocolRollback !== null && typeof protocolRollback === 'object') {
+        const value = protocolRollback.maxRollbackDepth;
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function estimateJsonBytes(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+        return Buffer.byteLength(JSON.stringify(value));
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return 2;
+        }
+        return 2 + value.length - 1 + value.reduce((sum, item) => sum + estimateJsonBytes(item), 0);
+    }
+    /* istanbul ignore else -- callers pass JSON-compatible replay/certification values before byte estimation. */
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        /* istanbul ignore next -- byte estimation callers pass non-empty object records. */
+        if (entries.length === 0) {
+            return 2;
+        }
+        return (2 +
+            entries.length -
+            1 +
+            entries.reduce((sum, [key, entryValue]) => {
+                return sum + Buffer.byteLength(JSON.stringify(key)) + 1 + estimateJsonBytes(entryValue);
+            }, 0));
+    }
+    /* istanbul ignore next -- certification byte estimators receive JSON-compatible replay objects. */
+    throw new Error(`Cannot estimate JSON bytes for ${typeof value}`);
+}
+function estimateJsonArrayBytes(itemBytes, itemCount) {
+    /* istanbul ignore next -- replay byte estimation callers pass frame-derived positive counts. */
+    if (itemCount === 0) {
+        return 2;
+    }
+    return 2 + itemCount - 1 + itemBytes;
+}
+function estimateNetcodeReplayBytes(shape, players, seed, inputFramesBytes, checksumsBytes) {
+    const emptyReplay = {
+        formatVersion: 1,
+        deterministicVersion: shape === 'input-minimal' ? '0.0.0-source' : `${shape}@1`,
+        tickRate: 30,
+        playerCount: players,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: shape === 'input-minimal' ? 'lab-state/v1' : 'moderate-state/v1',
+        randomSeed: seed,
+        initialState: (0, canonical_js_1.canonicalize)(makeNetcodeChecksumState(shape, players, seed)),
+        inputFrames: [],
+        checksums: [],
+    };
+    return estimateJsonBytes(emptyReplay) - 4 + inputFramesBytes + checksumsBytes;
+}
+function getHeapUsedBytes() {
+    return process.memoryUsage().heapUsed;
+}
+function getRssBytes() {
+    return process.memoryUsage().rss;
+}