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

package/dist/engine-complete.js

@@ -0,0 +1,2292 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { canonicalStringify, defaultChecksum } from './canonical.js';
+import { createDeterministicAnimationRuntimeState, cookDeterministicAnimation, runDeterministicAnimationFixture, stepDeterministicAnimation } from './animation.js';
+import { compileDeterministicBotDocument, runDeterministicBotDocumentFixture, summarizeDeterministicBotDocumentTraceCoverage, traceDeterministicBotDocument } from './bot-documents.js';
+import { cookDeterministicAssets, validatePrototypeEntitiesAgainstFrameRuntime } from './asset-cooking.js';
+import { runDeterministicCommandProtocolFixture, runDeterministicReliableCommandDefaultsFixture } from './commands.js';
+import { cookDeterministicConfigBundle, runDeterministicConfigBundleFixture, verifyDeterministicConfigBundle } from './config-bundle.js';
+import { runDeterministicSessionAuthorityFixture, runDeterministicSessionCoreFixture, runDeterministicSessionLifecycleProtocolFixture, runDeterministicStructuredSessionInputFixture } from './deterministic-session.js';
+import { createDeterministicFrameRuntime, createDeterministicFrameRuntimeAccessors, runDeterministicDslRuntimeFixture, runDeterministicFrameRuntimeFrameApiFixture, runDeterministicFrameRuntimeMutationCorpus, runDeterministicGeneratedRuntimeFixture, runDeterministicSystemSchedulerFixture, generateDeterministicFrameRuntimeSource, } from './engine-runtime.js';
+import { runDeterministicEventKeywordFixture } from './events.js';
+import { runDeterministicAuthoritativeLagCompensation3DFixture, runDeterministicLagCompensation3DApiFixture, runDeterministicLagCompensation3DFixture } from './lag-compensation3d.js';
+import { runDeterministicDslBinaryFixture } from './schema-dsl-binary.js';
+import { runDeterministicButtonFixture, runDeterministicDescriptorButtonFixture } from './input-button.js';
+import { runDeterministicLocalAuthorityFixture, runDeterministicLocalAuthorityReplayMinimizerFixture, runDeterministicLocalAuthorityRuntimePolicyFixture, runDeterministicOfflineToAuthorityUpgradeFixture, } from './local-authority.js';
+import { runDeterministicLocalAuthorityWireFixture } from './local-authority-wire.js';
+import { runDeterministicMulticlientAuthorityFixture } from './multiclient-authority.js';
+import { runDeterministicKcc3DAdversarialFixture, runDeterministicKcc3DCallbackFilterFixture, runDeterministicKcc3DCrowdFixture, runDeterministicKcc3DFilterForceFixture, runDeterministicKcc3DGeometryFixture, stepDeterministicKcc3D } from './movement3d.js';
+import { cookDeterministicNavmesh, findDeterministicNavmeshPath, runDeterministicNavmeshImportTraversalFixture, runDeterministicNavmeshLayered3DFixture, runDeterministicNavmeshStress, runDeterministicNavmeshVelocityObstacleFixture, stepDeterministicNavmeshAgents } from './navmesh.js';
+import { createDeterministicPhysicsWorld3D, runDeterministicPhysics3DCallbackMaskFixture, runDeterministicPhysics3DDetailFixture, runDeterministicPhysics3DMaterialFixture, runDeterministicPhysics3DQueryOptionsFixture, runDeterministicPhysics3DStackFixture, runDeterministicPhysics3DStress, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
+import { runDeterministicSignalFixture } from './signals.js';
+import { runDeterministicSparseSetFixture } from './sparse-set.js';
+import { runDeterministicLifecycleFixture } from './system-lifecycle.js';
+import { runDeterministicRollbackHistoryFixture } from './rollback-history.js';
+import { createDeterministicReplayBundle, createDeterministicReplayRuntimeManifest, createDeterministicReplayDebugTables, minimizeDeterministicReplayDesync, minimizeDeterministicReplayDesyncBundle, sliceDeterministicReplayBundle, verifyDeterministicFrameRuntimeReplayBundle, verifyDeterministicReplayBundle, verifyDeterministicSelfContainedFrameRuntimeReplayBundle, } from './replay-bundle.js';
+import { runDeterministicIntegratedHeadlessScene } from './sample-scenes.js';
+import { defineSyncplayGame } from './schema.js';
+import { checkSourceText } from './tools/static-checker.js';
+const requiredCategories = [
+    'typed-frame-runtime',
+    'schema-dsl-binary',
+    'sparse-set-storage',
+    'input-button',
+    'system-lifecycle',
+    'event-keywords',
+    'simulation-signals',
+    'commands',
+    'replay-bundle',
+    'integrated-headless-scene',
+    'project-runtime',
+    'physics3d',
+    'kcc3d',
+    'navmesh',
+    'bot-documents',
+    'animation',
+    'config-bundle',
+    'local-authority',
+    'deterministic-session',
+];
+const engineCompleteWallClockBudgetMs = 16.67;
+export function runDeterministicEngineCompleteSuite(...args) {
+    const resolvedOptions = resolveEngineCompleteOptions(args[0]);
+    const players = resolvedOptions.players ?? 128;
+    const frames = resolvedOptions.frames ?? (resolvedOptions.benchmark === true ? 100_000 : 5_000);
+    const seed = resolvedOptions.seed ?? 71;
+    const selectedCategories = filterEngineCompleteCategories(resolvedOptions.filter);
+    const categoryReports = selectedCategories.map((category) => runCategory(category, players, frames, seed, resolvedOptions));
+    const failures = categoryReports.flatMap((category) => category.failures.map((failure) => `${category.category}: ${failure}`));
+    const withoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        players,
+        frames,
+        seed,
+        benchmark: resolvedOptions.benchmark === true,
+        noFastStress: resolvedOptions.noFastStress === true,
+        enforceThresholds: resolvedOptions.enforceThresholds === true,
+        categories: categoryReports,
+        failures,
+        summary: {
+            passed: categoryReports.filter((category) => category.result === 'pass').length,
+            failed: categoryReports.filter((category) => category.result === 'fail').length,
+            requiredCategories: selectedCategories,
+        },
+        result: failures.length === 0 ? 'pass' : 'fail',
+    };
+    return {
+        ...withoutId,
+        reportId: defaultChecksum(withoutId),
+    };
+}
+function resolveEngineCompleteOptions(options) {
+    /* istanbul ignore else -- No-arg compatibility runs the full default certification suite. Filtered default-value coverage above exercises the same defaults without making the source shard run the 5,000-frame all-category path twice. */
+    if (options !== undefined) {
+        return options;
+    }
+    /* istanbul ignore next -- No-arg compatibility runs the full default certification suite, which is intentionally not duplicated inside this focused source shard. */
+    return {};
+}
+function filterEngineCompleteCategories(filter) {
+    if (filter === undefined || filter.length === 0) {
+        return requiredCategories;
+    }
+    const categories = requiredCategories.filter((category) => category === filter || category.includes(filter));
+    if (categories.length === 0) {
+        throw new Error(`No engine-complete categories matched --filter ${filter}`);
+    }
+    return categories;
+}
+export function stableDeterministicEngineCompleteJson(report) {
+    return `${canonicalStringify(report)}\n`;
+}
+function runCategory(category, players, frames, seed, options) {
+    const startedAtMs = engineCompleteNowMs();
+    const report = runCategoryUntimed(category, players, frames, seed, options);
+    return withCertificationTiming(report, engineCompleteNowMs() - startedAtMs, options.enforceThresholds === true);
+}
+function runCategoryUntimed(category, players, frames, seed, options) {
+    switch (category) {
+        case 'typed-frame-runtime':
+            return runtimeCategory(frames, seed);
+        case 'schema-dsl-binary':
+            return schemaDslBinaryCategory();
+        case 'sparse-set-storage':
+            return sparseSetCategory();
+        case 'input-button':
+            return inputButtonCategory();
+        case 'system-lifecycle':
+            return systemLifecycleCategory();
+        case 'event-keywords':
+            return eventKeywordsCategory();
+        case 'simulation-signals':
+            return simulationSignalsCategory();
+        case 'commands':
+            return commandsCategory(players, frames, seed);
+        case 'replay-bundle':
+            return replayBundleCategory(players, frames, options.benchmark === true ? Math.min(frames, 5_000) : frames);
+        case 'integrated-headless-scene':
+            return integratedHeadlessSceneCategory(players, frames, options.benchmark === true ? Math.min(frames, 5_000) : frames, seed);
+        case 'project-runtime':
+            return projectRuntimeCategory(frames, options.benchmark === true ? Math.min(frames, 5_000) : frames, seed);
+        case 'physics3d':
+            return physicsCategory(options.benchmark === true ? 128 : 512, frames, options.benchmark === true ? frames : Math.min(frames, 5000), options.enforceThresholds === true, options.benchmark === true, options.noFastStress === true);
+        case 'kcc3d':
+            return kccCategory(players, frames, options.benchmark === true ? frames : Math.min(frames, 5000), options.benchmark === true, options.noFastStress === true);
+        case 'navmesh':
+            return navmeshCategory(players, frames, options.benchmark === true ? frames : Math.min(frames, 5000));
+        case 'bot-documents':
+            return botCategory(players, frames, options.benchmark === true ? frames : Math.min(frames, 5000));
+        case 'animation':
+            return animationCategory(frames, options.benchmark === true ? frames : Math.min(frames, 5000));
+        case 'config-bundle':
+            return configCategory();
+        case 'local-authority':
+            return authorityCategory(players, frames, options.benchmark === true ? frames : Math.min(frames, 5000), seed);
+        case 'deterministic-session':
+            return deterministicSessionCategory(players, frames, options.benchmark === true ? frames : Math.min(frames, 5000), seed);
+    }
+}
+function withCertificationTiming(report, elapsedMs, enforceThresholds) {
+    const executedFrames = Number(report.metrics.executedFrames);
+    const wallClockElapsedMs = roundMetric(Math.max(0, elapsedMs), 4);
+    const wallClockMeanFrameMs = roundMetric(wallClockElapsedMs / Math.max(1, executedFrames), 6);
+    return categoryReport(report.category, subsystemChecksumOf(report), {
+        ...report.invariants,
+        wallClockMeasured: Number.isFinite(wallClockElapsedMs),
+        wallClockMeanWithinThreshold: enforceThresholds ? wallClockMeanFrameMs <= engineCompleteWallClockBudgetMs : 'not-enforced',
+    }, {
+        ...report.metrics,
+        wallClockElapsedMs,
+        wallClockMeanFrameMs,
+        wallClockBudgetMs: engineCompleteWallClockBudgetMs,
+        wallClockThresholdsEnforced: enforceThresholds,
+    });
+}
+function runtimeCategory(frames, seed) {
+    const executedFrames = Math.max(10_000, frames);
+    const metrics = runDeterministicFrameRuntimeMutationCorpus(executedFrames, seed);
+    const frameApi = runDeterministicFrameRuntimeFrameApiFixture(Math.max(512, Math.min(executedFrames, 10_000)), seed + 2);
+    const generated = runDeterministicGeneratedRuntimeFixture(Math.max(256, Math.min(executedFrames, 10_000)), seed + 1);
+    const scheduler = runDeterministicSystemSchedulerFixture(seed + 3);
+    return categoryReport('typed-frame-runtime', defaultChecksum({
+        metrics: metrics.checksum,
+        frameApi: frameApi.checksum,
+        scheduler: scheduler.checksum,
+    }), {
+        rollbackEquivalent: metrics.checksum === metrics.restoredChecksum,
+        queryOrderStable: metrics.queryOrderStable,
+        mutationCorpusComplete: metrics.componentWrites >= 10_000,
+        queryFilterAnyWithoutCovered: frameApi.filterAnyWithoutStable,
+        componentCountCovered: frameApi.componentCountStable,
+        frameHeapCollectionsCovered: frameApi.frameHeapHandlesAllocated >= 3 && frameApi.frameHeapSnapshotBytes > 0,
+        frameHeapRollbackEquivalent: frameApi.frameHeapRollbackEquivalent,
+        frameHeapFreeRejectsStaleHandles: frameApi.frameHeapFreedRejected,
+        frameHeapReuseGenerationSafe: frameApi.frameHeapReusedGenerationSafe,
+        generatedAccessorsCovered: generated.generatedAccessorsExecuted > 0 && generated.generatedSourceBytes > 0,
+        generatedRuntimeSourceStable: generated.generatedSourceHash.length > 0 && generated.descriptorHash.length > 0,
+        sparseSetBackedRuntimeEquivalent: generated.sparseSetBackedRuntimeEquivalent,
+        sparseSetBackedRollbackEquivalent: generated.rollbackEquivalent,
+        accessorQueryOrderStable: generated.accessorQueryOrderStable,
+        entityRefGenerationSafe: generated.entityRefGenerationSafe,
+        runtimeHostApiGuarded: generated.runtimeHostApiGuarded,
+        systemDependenciesCovered: scheduler.order === 'PAFPAF' && scheduler.beforeEdges > 0 && scheduler.afterEdges > 0,
+        systemDependencyRollbackEquivalent: scheduler.rollbackEquivalent,
+        systemDependencySparseEquivalent: scheduler.sparseEquivalent,
+        systemDependencyCycleRejected: scheduler.cycleRejected,
+        systemDependencyUnknownRejected: scheduler.unknownDependencyRejected,
+        systemDependencyCrossGroupRejected: scheduler.crossGroupDependencyRejected,
+    }, withFrameMetrics({
+        ...metrics,
+        generatedRuntimeChecksum: generated.checksum,
+        frameApiChecksum: frameApi.checksum,
+        frameApiRestoredChecksum: frameApi.restoredChecksum,
+        frameApiFilterAnyWithoutStable: frameApi.filterAnyWithoutStable,
+        frameApiComponentCountStable: frameApi.componentCountStable,
+        frameHeapHandlesAllocated: frameApi.frameHeapHandlesAllocated,
+        frameHeapFreedRejected: frameApi.frameHeapFreedRejected,
+        frameHeapReusedGenerationSafe: frameApi.frameHeapReusedGenerationSafe,
+        frameHeapSnapshotBytes: frameApi.frameHeapSnapshotBytes,
+        generatedSourceHash: generated.generatedSourceHash,
+        generatedSourceBytes: generated.generatedSourceBytes,
+        generatedAccessorsExecuted: generated.generatedAccessorsExecuted,
+        sparseMapRuntimeChecksum: generated.mapRuntimeChecksum,
+        sparseRuntimeChecksum: generated.sparseRuntimeChecksum,
+        sparseSnapshotBytes: generated.sparseSnapshotBytes,
+        entityRefGenerationSafe: generated.entityRefGenerationSafe,
+        runtimeHostApiGuarded: generated.runtimeHostApiGuarded,
+        schedulerChecksum: scheduler.checksum,
+        schedulerRestoredChecksum: scheduler.restoredChecksum,
+        schedulerSparseChecksum: scheduler.sparseChecksum,
+        schedulerOrder: scheduler.order,
+        schedulerBeforeEdges: scheduler.beforeEdges,
+        schedulerAfterEdges: scheduler.afterEdges,
+        schedulerRollbackEquivalent: scheduler.rollbackEquivalent,
+        schedulerSparseEquivalent: scheduler.sparseEquivalent,
+        schedulerCycleRejected: scheduler.cycleRejected,
+        schedulerUnknownDependencyRejected: scheduler.unknownDependencyRejected,
+        schedulerCrossGroupDependencyRejected: scheduler.crossGroupDependencyRejected,
+    }, frames, executedFrames));
+}
+function schemaDslBinaryCategory() {
+    const metrics = runDeterministicDslBinaryFixture();
+    const runtimeFrames = 256;
+    const runtime = runDeterministicDslRuntimeFixture(runtimeFrames);
+    return categoryReport('schema-dsl-binary', defaultChecksum({ binary: metrics.roundTripChecksum, runtime: runtime.checksum }), {
+        schemaPermutationStable: metrics.permutationStable,
+        binaryRoundTripExecuted: metrics.encodedBytes > 0,
+        rejectsBadDslValues: metrics.rejectedBadField
+            && metrics.rejectedExtraField
+            && metrics.rejectedBadDeclaration
+            && metrics.rejectedDuplicateSetValue
+            && metrics.rejectedDuplicateDictionaryKey,
+        eventSignalStructDslCovered: metrics.eventDeclarations > 0 && metrics.signalDeclarations > 0 && metrics.structDeclarations > 0,
+        globalImportPragmaDslCovered: metrics.globalDeclarations > 0 && metrics.importCount > 0 && metrics.pragmaCount > 0 && metrics.maxPlayers === 128,
+        assetAndEntityRefsCovered: metrics.assetRefFields > 0 && metrics.entityRefFields > 0,
+        arrayFieldsCovered: metrics.arrayFields > 0,
+        fixedArrayFieldsCovered: metrics.fixedArrayFields > 0,
+        dynamicCollectionFieldsCovered: metrics.listFields > 0 && metrics.setFields > 0 && metrics.dictionaryFields > 0,
+        buttonFieldsCovered: metrics.buttonFields > 0,
+        advancedDslDeclarationsCovered: metrics.enumDeclarations > 0 && metrics.flagsDeclarations > 0 && metrics.unionDeclarations > 0,
+        advancedDslRefsCovered: metrics.playerRefFields > 0 && metrics.typedAssetRefFields > 0,
+        advancedDslBitsetCovered: metrics.bitsetFields > 0,
+        advancedDslModifiersCovered: metrics.declarationModifiers > 0,
+        advancedDslHashSetAliasCovered: metrics.hashSetAliasFields > 0,
+        fixedArrayLengthRejected: metrics.rejectedWrongFixedArrayLength,
+        dslRuntimeDescriptorGenerated: runtime.componentCount > 0 && runtime.singletonCount > 1 && runtime.generatedSourceBytes > 0,
+        dslRuntimeCommandEventSignalGenerated: runtime.commandChannelCount > 0 && runtime.eventChannelCount > 0 && runtime.signalChannelCount > 0,
+        dslRuntimePermutationStable: runtime.descriptorPermutationStable,
+        dslRuntimeSparseEquivalent: runtime.sparseRuntimeEquivalent,
+        dslRuntimeRollbackEquivalent: runtime.rollbackEquivalent,
+        dslRuntimeRefsAndArraysCovered: runtime.arrayFieldCount > 0 && runtime.assetRefFieldCount > 0 && runtime.entityRefFieldCount > 0,
+        dslRuntimeFixedArraysCovered: runtime.fixedArrayFieldCount > 0,
+        dslRuntimeDynamicCollectionHandlesCovered: runtime.dynamicCollectionHandleFieldCount >= 3,
+        dslRuntimeFrameApiHelpersCovered: runtime.generatedFrameApiHelpersExecuted > 0,
+        dslRuntimeEventSignalAccessorsExecuted: runtime.generatedEventSignalAccessorsExecuted > 0,
+        dslRuntimeTypedInterfacesCovered: runtime.generatedTypedInterfacesCovered,
+        dslRuntimeAssetRefsValidated: runtime.runtimeAssetRefsValidated,
+    }, {
+        ...metrics,
+        fieldKinds: metrics.fieldKinds.join(','),
+        dslRuntimeChecksum: runtime.checksum,
+        dslRuntimeDescriptorHash: runtime.descriptorHash,
+        dslRuntimePermutedDescriptorHash: runtime.permutedDescriptorHash,
+        dslRuntimeGeneratedSourceHash: runtime.generatedSourceHash,
+        dslRuntimeGeneratedSourceBytes: runtime.generatedSourceBytes,
+        dslRuntimeComponentCount: runtime.componentCount,
+        dslRuntimeSingletonCount: runtime.singletonCount,
+        dslRuntimeCommandChannelCount: runtime.commandChannelCount,
+        dslRuntimeEventChannelCount: runtime.eventChannelCount,
+        dslRuntimeSignalChannelCount: runtime.signalChannelCount,
+        dslRuntimeArrayFieldCount: runtime.arrayFieldCount,
+        dslRuntimeFixedArrayFieldCount: runtime.fixedArrayFieldCount,
+        dslRuntimeDynamicCollectionHandleFieldCount: runtime.dynamicCollectionHandleFieldCount,
+        dslRuntimeAssetRefFieldCount: runtime.assetRefFieldCount,
+        dslRuntimeEntityRefFieldCount: runtime.entityRefFieldCount,
+        dslGlobalDeclarations: metrics.globalDeclarations,
+        dslImportCount: metrics.importCount,
+        dslPragmaCount: metrics.pragmaCount,
+        dslMaxPlayers: metrics.maxPlayers,
+        dslListFields: metrics.listFields,
+        dslFixedArrayFields: metrics.fixedArrayFields,
+        dslSetFields: metrics.setFields,
+        dslDictionaryFields: metrics.dictionaryFields,
+        dslEnumDeclarations: metrics.enumDeclarations,
+        dslFlagsDeclarations: metrics.flagsDeclarations,
+        dslUnionDeclarations: metrics.unionDeclarations,
+        dslPlayerRefFields: metrics.playerRefFields,
+        dslTypedAssetRefFields: metrics.typedAssetRefFields,
+        dslBitsetFields: metrics.bitsetFields,
+        dslDeclarationModifiers: metrics.declarationModifiers,
+        dslHashSetAliasFields: metrics.hashSetAliasFields,
+        dslRejectedWrongFixedArrayLength: metrics.rejectedWrongFixedArrayLength,
+        dslRejectedDuplicateSetValue: metrics.rejectedDuplicateSetValue,
+        dslRejectedDuplicateDictionaryKey: metrics.rejectedDuplicateDictionaryKey,
+        dslRuntimeGeneratedAccessorsExecuted: runtime.generatedAccessorsExecuted,
+        dslRuntimeGeneratedFrameApiHelpersExecuted: runtime.generatedFrameApiHelpersExecuted,
+        dslRuntimeGeneratedEventSignalAccessorsExecuted: runtime.generatedEventSignalAccessorsExecuted,
+        dslRuntimeGeneratedTypedInterfacesCovered: runtime.generatedTypedInterfacesCovered,
+        dslRuntimeAssetRefsValidated: runtime.runtimeAssetRefsValidated,
+        dslRuntimeSparseRuntimeEquivalent: runtime.sparseRuntimeEquivalent,
+        dslRuntimeRollbackEquivalent: runtime.rollbackEquivalent,
+        proofContract: 'schema-dsl-binary@1',
+        subsystemChecksum: metrics.roundTripChecksum,
+        requestedFrames: runtimeFrames,
+        executedFrames: runtimeFrames,
+        capped: false,
+    });
+}
+function sparseSetCategory() {
+    const metrics = runDeterministicSparseSetFixture();
+    return categoryReport('sparse-set-storage', metrics.checksum, {
+        rollbackEquivalent: metrics.checksum === metrics.restoredChecksum,
+        queryOrderStable: metrics.queryOrderStable,
+        duplicateRejected: metrics.rejectedDuplicate,
+        malformedSnapshotRejected: metrics.rejectedMalformedSnapshot,
+        denseStorageExercised: metrics.denseCount > 0,
+    }, {
+        ...metrics,
+        proofContract: 'sparse-set-storage@1',
+        subsystemChecksum: metrics.checksum,
+        requestedFrames: 1,
+        executedFrames: 1,
+        capped: false,
+    });
+}
+function inputButtonCategory() {
+    const metrics = runDeterministicButtonFixture();
+    const descriptor = runDeterministicDescriptorButtonFixture();
+    return categoryReport('input-button', metrics.checksum, {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        pressedCovered: metrics.pressedCount > 0,
+        releasedCovered: metrics.releasedCount > 0,
+        heldCovered: metrics.heldFrames > 0,
+        repeatCovered: metrics.repeatedFrames > 0,
+        transitionsStable: metrics.transitionsStable,
+        descriptorRollbackEquivalent: descriptor.rollbackEquivalent,
+        descriptorButtonFieldsCovered: descriptor.descriptorButtonFields > 0,
+        descriptorDefaultApplied: descriptor.defaultApplied,
+        descriptorSerializationCovered: descriptor.serializedBytes > 0,
+        descriptorRoundTripStable: descriptor.schemaRoundTripStable,
+    }, withFrameMetrics({
+        ...metrics,
+        descriptorChecksum: descriptor.checksum,
+        descriptorRestoredChecksum: descriptor.restoredChecksum,
+        descriptorArtifactId: descriptor.descriptorArtifactId,
+        descriptorButtonFields: descriptor.descriptorButtonFields,
+        descriptorSerializedBytes: descriptor.serializedBytes,
+        descriptorDefaultApplied: descriptor.defaultApplied,
+        descriptorRoundTripStable: descriptor.schemaRoundTripStable,
+    }, 512, 512));
+}
+function systemLifecycleCategory() {
+    const metrics = runDeterministicLifecycleFixture();
+    return categoryReport('system-lifecycle', metrics.checksum, {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        initCovered: metrics.initCalls >= 4,
+        updatesCovered: metrics.updateCalls > 0,
+        enableDisableCovered: metrics.enabledCalls > 0 && metrics.disabledCalls > 0,
+        signalDispatchCovered: metrics.signalCalls > 0,
+        hierarchyCovered: metrics.hierarchySkippedUpdates > 0,
+        startDisabledCovered: metrics.startDisabledCovered,
+        signalsOnlyCovered: metrics.signalOnlySkippedUpdate,
+        orderStable: metrics.orderStable,
+    }, withFrameMetrics({
+        ...metrics,
+    }, 128, 128));
+}
+function eventKeywordsCategory() {
+    const metrics = runDeterministicEventKeywordFixture();
+    return categoryReport('event-keywords', metrics.checksum, {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        syncedCovered: metrics.syncedEvents > 0,
+        predictedConfirmCovered: metrics.confirmedEvents > 0,
+        predictedCancelCovered: metrics.canceledEvents > 0,
+        verifiedOnlyCovered: metrics.verifiedOnlyEvents > 0,
+        notHashedDuplicateRejected: metrics.notHashedDuplicateRejected,
+        notHashedDedupeStable: metrics.notHashedDedupeStable,
+        syncedSurvivedConfirmCancel: metrics.syncedSurvivedConfirmCancel,
+        localRemoteScopeCovered: metrics.localEvents > 0 && metrics.remoteEvents > 0 && metrics.localRemoteDispatchStable,
+    }, withFrameMetrics({
+        ...metrics,
+    }, 1, 1));
+}
+function simulationSignalsCategory() {
+    const metrics = runDeterministicSignalFixture();
+    return categoryReport('simulation-signals', metrics.checksum, {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        subscriptionOrderStable: metrics.subscriptionOrderStable,
+        dispatchedSignals: metrics.dispatchedSignals >= 2,
+    }, {
+        ...metrics,
+        proofContract: 'simulation-signals@1',
+        subsystemChecksum: metrics.checksum,
+        requestedFrames: 1,
+        executedFrames: 1,
+        capped: false,
+    });
+}
+function commandsCategory(players, frames, seed) {
+    const metrics = runDeterministicCommandProtocolFixture(players, frames, seed);
+    const reliableDefaults = runDeterministicReliableCommandDefaultsFixture(players, frames, seed);
+    return categoryReport('commands', defaultChecksum({ commandProtocol: metrics.checksum, reliableDefaults: reliableDefaults.checksum }), {
+        commandReplayConverges: metrics.convergence,
+        rejectsHostileCommands: metrics.rejected >= 9,
+        duplicateCommandsRejected: metrics.duplicateDrops > 0,
+        multiCommandSameFrameCovered: metrics.multiCommandSameFrameAccepted >= 2 && metrics.multiCommandPollOrderStable,
+        acceptedFutureCommandsReplay: metrics.acceptedFutureCommands > 0 && metrics.acceptedFutureCommands === metrics.replayedFutureCommands,
+        reliableCommandsResentAndOrdered: metrics.reliableDelivered > 0 && metrics.reliableResent > 0 && metrics.reliableOrderingStable,
+        reliableDefaultCommandsCovered: reliableDefaults.accepted > 0
+            && reliableDefaults.reliableDelivered === reliableDefaults.accepted
+            && reliableDefaults.unreliableDropped === 0
+            && reliableDefaults.replayConverged
+            && reliableDefaults.originalOrderHash === reliableDefaults.replayOrderHash,
+        reliableDefaultRejectionsCovered: reliableDefaults.duplicateRejected === 1
+            && reliableDefaults.staleRejected === 1
+            && reliableDefaults.futureRejected === 1,
+        unreliableDropsModeled: metrics.unreliableDropped > 0,
+        deliveredCommandsSpanRun: metrics.firstDeliveredFrame === 0 && metrics.lastDeliveredFrame >= frames - 1,
+        schemaDeclaredCommandPayloadsCovered: metrics.schemaDeclaredPayloadsCovered,
+        schemaCommandCollectionPayloadsCovered: metrics.schemaCollectionPayloadsCovered,
+        schemaCommandPayloadsRejected: metrics.schemaRejected >= 4,
+        onlyExpectedRejections: metrics.rejected === metrics.duplicateDrops + 14,
+    }, withFrameMetrics({
+        delivered: metrics.delivered,
+        rejected: metrics.rejected,
+        duplicateDrops: metrics.duplicateDrops,
+        multiCommandSameFrameAccepted: metrics.multiCommandSameFrameAccepted,
+        multiCommandPollOrderStable: metrics.multiCommandPollOrderStable,
+        acceptedFutureCommands: metrics.acceptedFutureCommands,
+        replayedFutureCommands: metrics.replayedFutureCommands,
+        reliableDelivered: metrics.reliableDelivered,
+        reliableResent: metrics.reliableResent,
+        unreliableDropped: metrics.unreliableDropped,
+        reliableOrderingStable: metrics.reliableOrderingStable,
+        reliableDefaultAccepted: reliableDefaults.accepted,
+        reliableDefaultDelivered: reliableDefaults.reliableDelivered,
+        reliableDefaultResent: reliableDefaults.reliableResent,
+        reliableDefaultUnreliableDropped: reliableDefaults.unreliableDropped,
+        reliableDefaultDuplicateRejected: reliableDefaults.duplicateRejected,
+        reliableDefaultStaleRejected: reliableDefaults.staleRejected,
+        reliableDefaultFutureRejected: reliableDefaults.futureRejected,
+        reliableDefaultPollOrderStable: reliableDefaults.pollOrderStable,
+        reliableDefaultReplayConverged: reliableDefaults.replayConverged,
+        reliableDefaultOriginalOrderHash: reliableDefaults.originalOrderHash,
+        reliableDefaultReplayOrderHash: reliableDefaults.replayOrderHash,
+        firstDeliveredFrame: metrics.firstDeliveredFrame,
+        lastDeliveredFrame: metrics.lastDeliveredFrame,
+        delayP50Frames: metrics.delayP50Frames,
+        delayP95Frames: metrics.delayP95Frames,
+        rollbackDepthP95: metrics.rollbackDepthP95,
+        schemaRejected: metrics.schemaRejected,
+        schemaDeclaredPayloadsCovered: metrics.schemaDeclaredPayloadsCovered,
+        schemaCollectionPayloadsCovered: metrics.schemaCollectionPayloadsCovered,
+        convergence: metrics.convergence,
+    }, frames, frames));
+}
+function replayBundleCategory(players, requestedFrames, executedFrames) {
+    const positions = Array.from({ length: players }, () => 0);
+    const snapshotStates = [];
+    const inputHistory = [];
+    const commandHistory = [];
+    const debugEvents = [];
+    let commandScore = 0;
+    let simulationHashValue = 2166136261;
+    for (let frame = 0; frame < executedFrames; frame += 1) {
+        const inputs = Array.from({ length: players }, (_, slot) => ({
+            slot,
+            dx: (slot + frame) % 3 - 1,
+            dy: (slot * 2 + frame) % 3 - 1,
+        }));
+        for (const input of inputs) {
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, frame);
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, input.slot);
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, input.dx);
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, input.dy);
+        }
+        const commands = Array.from({ length: players }, (_, slot) => ({
+            id: `cmd:${frame}:${slot}`,
+            slot,
+            channelId: 'ability',
+            payload: { assetRef: 'ability.dash', power: (frame + slot) % 5 },
+        }));
+        for (const command of commands) {
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, command.slot);
+            simulationHashValue = updateSimulationHashValue(simulationHashValue, command.payload.power);
+        }
+        for (const input of inputs) {
+            positions[input.slot] += input.dx + input.dy;
+        }
+        for (const command of commands) {
+            commandScore += command.payload.power;
+        }
+        inputHistory.push({ frame, inputs });
+        commandHistory.push({ frame, commands });
+        const state = {
+            frame,
+            positions: [...positions],
+            commandScore,
+        };
+        const bytes = canonicalStringify(state);
+        const snapshot = { frame, bytes, checksum: defaultChecksum(bytes) };
+        snapshotStates.push(snapshot);
+        debugEvents.push({ frame, type: 'ecs.snapshot', payload: { checksum: snapshot.checksum } }, { frame, type: 'physics.contacts', payload: { contacts: frame % 3 } }, { frame, type: 'command.poll', payload: { commands: players } });
+    }
+    const checksums = snapshotStates.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum }));
+    const bundle = createDeterministicReplayBundle({
+        runtimeVersion: 'engine-complete@1',
+        engineHash: 'engine-hash',
+        schemaHash: 'schema-hash',
+        assetDbHash: 'asset-hash',
+        configHash: 'config-hash',
+        sampleId: 'engine-complete',
+        inputHistory,
+        commandHistory,
+        checksums,
+        debugEvents,
+        snapshots: snapshotStates.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum, bytes: snapshot.bytes })),
+        semanticReplay: {
+            kind: 'operation-model-v1',
+            initialState: {
+                positions: Array.from({ length: players }, () => 0),
+                commandScore: 0,
+            },
+            operations: [
+                { source: 'input', sourcePath: 'dx', targetPath: 'positions[$slot]', op: 'add', slotField: 'slot' },
+                { source: 'input', sourcePath: 'dy', targetPath: 'positions[$slot]', op: 'add', slotField: 'slot' },
+                { source: 'command.payload', sourcePath: 'power', targetPath: 'commandScore', op: 'add' },
+            ],
+        },
+        metadata: {
+            players,
+            fullReplayHistory: true,
+            requestedFrames,
+            executedFrames,
+            fullReplayCapped: executedFrames < requestedFrames,
+        },
+    });
+    const verification = verifyDeterministicReplayBundle(bundle, {
+        runtimeVersion: 'engine-complete@1',
+        engineHash: 'engine-hash',
+        schemaHash: 'schema-hash',
+        assetDbHash: 'asset-hash',
+        configHash: 'config-hash',
+        semanticReplayHash: bundle.semanticReplayHash,
+    });
+    const componentVerification = verifyDeterministicReplayBundle(createComponentReplayBundle());
+    const corrupted = createDeterministicReplayBundle({
+        ...bundle,
+        checksums: bundle.checksums.map((checksum, index) => index === Math.min(3, bundle.checksums.length - 1) ? { ...checksum, checksum: 'corrupt' } : checksum),
+    });
+    const mismatch = minimizeDeterministicReplayDesync(bundle, corrupted);
+    const minimization = minimizeDeterministicReplayDesyncBundle(bundle, corrupted);
+    const minimized = minimization.bundle;
+    const minimizedVerification = minimization.verifier;
+    const sliceStartIndex = Math.min(1, Math.max(0, bundle.checksums.length - 1));
+    const sliceEndIndex = Math.min(4, Math.max(sliceStartIndex, bundle.checksums.length - 1));
+    const sliced = sliceDeterministicReplayBundle(bundle, bundle.checksums[sliceStartIndex].frame, bundle.checksums[sliceEndIndex].frame);
+    const sliceVerification = verifyDeterministicReplayBundle(sliced, {
+        runtimeVersion: 'engine-complete@1',
+        engineHash: 'engine-hash',
+        schemaHash: 'schema-hash',
+        assetDbHash: 'asset-hash',
+        configHash: 'config-hash',
+        semanticReplayHash: sliced.semanticReplayHash,
+    });
+    const frameRuntimeReplay = createFrameRuntimeReplayProof(executedFrames);
+    const debug = createDeterministicReplayDebugTables(bundle.debugEvents);
+    return categoryReport('replay-bundle', verification.bundleHash, {
+        verifiesColdStart: verification.result === 'pass',
+        mismatchMinimized: mismatch.frame === bundle.checksums[Math.min(3, bundle.checksums.length - 1)].frame,
+        minimizedArtifactVerifierRunnable: minimizedVerification.result === 'fail',
+        minimizedArtifactReproducesMismatch: minimizedVerification.firstMismatch?.frame === mismatch.frame,
+        minimizedArtifactReducesBytes: minimization.minimizedReplayBytes < minimization.originalReplayBytes,
+        minimizedArtifactRemovesIrrelevantInputs: minimization.removedInputFrames > 0 && minimization.removedInputs > 0,
+        minimizedArtifactRemovesIrrelevantCommands: minimization.removedCommandFrames > 0 && minimization.removedCommands > 0,
+        minimizedArtifactRemovesIrrelevantDebugEvents: minimization.removedDebugEvents > 0,
+        sliceContainsChecksums: sliced.checksums.length === sliceEndIndex - sliceStartIndex + 1,
+        sliceSelfContained: sliced.metadata.selfContainedSlice === true && sliced.sliceOrigin !== undefined,
+        sliceVerifiesFromBaseline: sliceVerification.result === 'pass' && sliceVerification.semanticReplayExecuted,
+        sliceSourceIdentityPresent: sliced.sliceOrigin?.sourceBundleHash === verification.bundleHash,
+        inputHistoryPresent: verification.inputCount > 0,
+        commandHistoryPresent: verification.commandCount > 0,
+        allPlayersSampled: verification.inputCount === players * executedFrames && verification.commandCount === players * executedFrames,
+        semanticReplayExecuted: verification.semanticReplayExecuted,
+        semanticReplayFullHistoryVerified: verification.semanticReplayFrames === executedFrames,
+        fullReplayHistory: bundle.metadata.fullReplayHistory === true,
+        fullReplayNotCheckpoint: bundle.metadata.checkpointBundle !== true,
+        fullReplayCappedHonest: bundle.metadata.fullReplayCapped === (executedFrames < requestedFrames),
+        componentSemanticReplayExecuted: componentVerification.semanticReplayExecuted && componentVerification.result === 'pass',
+        frameRuntimeReplayExecuted: frameRuntimeReplay.verification.result === 'pass',
+        selfContainedFrameRuntimeReplayExecuted: frameRuntimeReplay.selfContainedVerification.result === 'pass',
+        frameRuntimeReplayFullHistoryVerified: frameRuntimeReplay.verification.frames === frameRuntimeReplay.snapshotCount,
+        selfContainedFrameRuntimeReplayFullHistoryVerified: frameRuntimeReplay.selfContainedVerification.frames === frameRuntimeReplay.snapshotCount,
+        frameRuntimeReplayCoversExecutedFrames: frameRuntimeReplay.verification.frames >= executedFrames,
+        selfContainedFrameRuntimeReplayCoversExecutedFrames: frameRuntimeReplay.selfContainedVerification.frames >= executedFrames,
+        forgedFrameRuntimeReplayRejected: frameRuntimeReplay.forgedVerification.result === 'fail'
+            && frameRuntimeReplay.forgedVerification.firstMismatch?.subsystem === 'frame-runtime-replay',
+        finalFrameCovered: bundle.checksums.at(-1)?.frame === executedFrames - 1,
+        requestedFrameCoverageDeclared: bundle.metadata.requestedFrames === requestedFrames && bundle.metadata.executedFrames === executedFrames,
+        debugTablesPresent: debug.ecs.length > 0 && debug.physics.length > 0 && debug.commands.length > 0,
+    }, withFrameMetrics({
+        replayBytes: verification.replayBytes,
+        snapshotBytes: verification.snapshotBytes,
+        inputCount: verification.inputCount,
+        checksumCount: verification.checksumCount,
+        commandCount: verification.commandCount,
+        debugEventCount: verification.debugEventCount,
+        semanticReplayFrames: verification.semanticReplayFrames,
+        simulatedFrames: executedFrames,
+        fullReplayFrames: executedFrames,
+        fullReplayRequestedFrames: requestedFrames,
+        fullReplayCapped: executedFrames < requestedFrames,
+        simulationHash: simulationHashValue.toString(16),
+        componentSemanticReplayFrames: componentVerification.semanticReplayFrames,
+        componentReplayBytes: componentVerification.replayBytes,
+        frameRuntimeReplayFrames: frameRuntimeReplay.verification.frames,
+        selfContainedFrameRuntimeReplayFrames: frameRuntimeReplay.selfContainedVerification.frames,
+        frameRuntimeReplaySnapshots: frameRuntimeReplay.snapshotCount,
+        frameRuntimeReplayFinalFrame: frameRuntimeReplay.verification.finalFrame,
+        selfContainedFrameRuntimeReplayFinalFrame: frameRuntimeReplay.selfContainedVerification.finalFrame,
+        frameRuntimeReplayBundleHash: frameRuntimeReplay.verification.bundleHash,
+        selfContainedFrameRuntimeReplayBundleHash: frameRuntimeReplay.selfContainedVerification.bundleHash,
+        forgedFrameRuntimeReplayFrame: frameRuntimeReplay.forgedVerification.firstMismatch.frame,
+        minimizedFrame: mismatch.frame,
+        minimizedVerificationResult: minimizedVerification.result,
+        minimizedVerificationFrame: minimizedVerification.firstMismatch.frame,
+        minimizedVerificationSubsystem: minimizedVerification.firstMismatch.subsystem,
+        minimizedArtifactChecksums: minimized.checksums.length,
+        minimizedOriginalReplayBytes: minimization.originalReplayBytes,
+        minimizedReplayBytes: minimization.minimizedReplayBytes,
+        minimizedRemovedInputFrames: minimization.removedInputFrames,
+        minimizedRemovedInputs: minimization.removedInputs,
+        minimizedRemovedCommandFrames: minimization.removedCommandFrames,
+        minimizedRemovedCommands: minimization.removedCommands,
+        minimizedRemovedDebugEvents: minimization.removedDebugEvents,
+        minimizedRemovedSnapshots: minimization.removedSnapshots,
+        minimizedRemovedChecksumFrames: minimization.removedChecksumFrames,
+        sliceBaselineFrame: sliced.sliceOrigin.baselineSnapshot.frame,
+        sliceBaselineChecksum: sliced.sliceOrigin.baselineSnapshot.checksum,
+        sliceSourceBundleHash: sliced.sliceOrigin.sourceBundleHash,
+        sliceVerificationFrames: sliceVerification.semanticReplayFrames,
+        checkpointStride: 0,
+        checkpointBundle: false,
+        checkpointCount: 0,
+    }, requestedFrames, executedFrames));
+}
+function integratedHeadlessSceneCategory(players, requestedFrames, executedFrames, seed) {
+    const scene = runDeterministicIntegratedHeadlessScene(executedFrames, players, seed);
+    return categoryReport('integrated-headless-scene', scene.checksum, {
+        frameRuntimeExecuted: scene.invariants.frameRuntimeExecuted === true,
+        commandsExecuted: scene.invariants.commandsExecuted === true,
+        replayVerified: scene.replayVerified,
+        rollbackEquivalent: scene.rollbackEquivalent,
+        physicsExecuted: scene.invariants.physicsExecuted === true,
+        kccExecuted: scene.invariants.kccExecuted === true,
+        navmeshExecuted: scene.invariants.navmeshExecuted === true,
+        botExecuted: scene.invariants.botExecuted === true,
+        animationExecuted: scene.invariants.animationExecuted === true,
+        assetsConfigCovered: scene.invariants.assetsConfigCovered === true,
+        sameFrameCommandsCovered: scene.metrics.sameFrameCommandsAccepted >= 2,
+        fullSceneFramesCovered: scene.metrics.frames === executedFrames,
+        replayWindowVerified: scene.metrics.replayFrames <= scene.metrics.frames
+            && scene.metrics.replaySnapshots === scene.metrics.replayFrames + 1,
+        replayWindowCapDeclared: scene.metrics.replayCapped === (scene.metrics.replayFrames < scene.metrics.frames),
+        playersCovered: scene.metrics.players === players,
+    }, withFrameMetrics({
+        checksum: scene.checksum,
+        replayChecksum: scene.replayChecksum,
+        rollbackChecksum: scene.rollbackChecksum,
+        replayVerified: scene.replayVerified,
+        rollbackEquivalent: scene.rollbackEquivalent,
+        frames: scene.metrics.frames,
+        replayFrames: scene.metrics.replayFrames,
+        replayCapped: scene.metrics.replayCapped,
+        players: scene.metrics.players,
+        commandsAccepted: scene.metrics.commandsAccepted,
+        sameFrameCommandsAccepted: scene.metrics.sameFrameCommandsAccepted,
+        physicsContacts: scene.metrics.physicsContacts,
+        physicsQueries: scene.metrics.physicsQueries,
+        kccCorrections: scene.metrics.kccCorrections,
+        navReplans: scene.metrics.navReplans,
+        botTraceRows: scene.metrics.botTraceRows,
+        animationEvents: scene.metrics.animationEvents,
+        replaySnapshots: scene.metrics.replaySnapshots,
+        debugEvents: scene.metrics.debugEvents,
+        configHashCovered: scene.metrics.configHashCovered,
+    }, requestedFrames, executedFrames));
+}
+function projectRuntimeCategory(requestedFrames, executedFrames, seed) {
+    const manifest = readProjectFixtureJson('project.json');
+    const descriptorSource = readProjectFixtureJson(manifest.descriptor);
+    const descriptor = defineSyncplayGame(descriptorSource);
+    const runtimeDescriptor = projectRuntimeDescriptorFromGameDescriptor(descriptor);
+    const runtimeAccessors = createDeterministicFrameRuntimeAccessors(runtimeDescriptor);
+    const generatedSource = generateDeterministicFrameRuntimeSource(runtimeDescriptor);
+    const generatedSourceHash = defaultChecksum(generatedSource);
+    const assets = cookDeterministicAssets(readProjectFixtureJson(manifest.assets));
+    const config = cookDeterministicConfigBundle(readProjectFixtureJson(manifest.config), 1);
+    const configVerification = verifyDeterministicConfigBundle(config, {
+        engineHash: config.engineHash,
+        schemaHash: config.schemaHash,
+        configHash: config.configHash,
+        assetDbHash: config.assetDbHash,
+    });
+    const prototypeValidation = validatePrototypeEntitiesAgainstFrameRuntime(assets, 'player.prototype', {
+        ...runtimeDescriptor,
+        components: runtimeDescriptor.components.map((component) => component.id === 'gameState' ? { ...component, singleton: false } : component),
+    }, 1);
+    const botDocument = readProjectFixtureJson(manifest.botDocuments[0] ?? 'bot.json');
+    const assetRefs = assets.cookedAssets.map((asset) => asset.id);
+    const compiledBot = compileDeterministicBotDocument(botDocument, assetRefs);
+    const botFrames = Math.max(12, Math.min(executedFrames, 512));
+    const botTraces = traceDeterministicBotDocument(botDocument, [1, 2], botFrames, assetRefs);
+    const botCoverage = summarizeDeterministicBotDocumentTraceCoverage(botDocument, botTraces);
+    const navmeshSource = readProjectFixtureJson(manifest.navmeshes[0] ?? 'navmesh.json');
+    const navmesh = cookDeterministicNavmesh(navmeshSource);
+    const navPath = findDeterministicNavmeshPath(navmesh, { start: 'spawn', goal: 'goal' });
+    let navAgents = [{
+            id: 'project-agent',
+            polygonId: 'spawn',
+            targetPolygonId: 'goal',
+            speedPerFrame: 1,
+            radius: 1,
+            avoidancePriority: 1,
+        }];
+    let navTraceChecksum = '';
+    let navWaypointAdvances = 0;
+    const navFrames = Math.max(2, Math.min(executedFrames, 512));
+    for (let frame = 0; frame < navFrames; frame += 1) {
+        const step = stepDeterministicNavmeshAgents(navmesh, navAgents, { frame });
+        navAgents = step.agents;
+        navWaypointAdvances += step.waypointAdvances;
+        navTraceChecksum = step.checksum;
+    }
+    const animationDescriptor = readProjectFixtureJson(manifest.animations[0] ?? 'animation.json');
+    const animation = cookDeterministicAnimation(animationDescriptor);
+    const animationScript = readProjectFixtureJson(manifest.animationParameters?.[manifest.animations[0] ?? 'animation.json'] ?? 'animation-params.json');
+    const animationUpdates = new Map(animationScript.frames.map((entry) => [entry.frame, entry.parameters]));
+    let animationState = createDeterministicAnimationRuntimeState(animationDescriptor);
+    let animationTransitions = 0;
+    let animationEvents = 0;
+    let animationChecksum = '';
+    const animationFrames = Math.max(12, Math.min(executedFrames, 512));
+    for (let frame = 0; frame < animationFrames; frame += 1) {
+        const result = stepDeterministicAnimation(animationDescriptor, animationState, animationUpdates.get(frame) ?? {});
+        animationState = result.state;
+        animationTransitions += result.transitionCount;
+        animationEvents += result.events.length;
+        animationChecksum = result.checksum;
+    }
+    const staticDiagnostics = manifest.staticPaths.flatMap((path) => checkSourceText(path, readProjectFixtureText(path), 'strict', {
+        schemaStateFields: descriptor.state.fields.map((field) => field.name),
+    }));
+    const replay = createProjectRuntimeReplayProof(runtimeDescriptor, generatedSourceHash, executedFrames, seed);
+    const checksum = defaultChecksum({
+        descriptor: descriptor.artifactId,
+        runtimeDescriptor: runtimeAccessors.descriptorHash,
+        generatedSourceHash,
+        assetDbHash: assets.manifest.assetDbHash,
+        configHash: config.configHash,
+        botHash: compiledBot.hash,
+        navmeshHash: navmesh.hash,
+        animationHash: animation.hash,
+        replayHash: replay.verification.bundleHash,
+        staticDiagnostics,
+    });
+    return categoryReport('project-runtime', checksum, {
+        descriptorCertified: descriptor.maxPlayers === 128 && runtimeAccessors.descriptorHash.length > 0,
+        generatedRuntimeSourceCertified: generatedSourceHash.length > 0 && generatedSource.includes('recordSpawnCommand'),
+        assetsCertified: assets.manifest.assetDbHash === config.assetDbHash,
+        configCertified: configVerification.result === 'pass',
+        prototypeRuntimeValidated: prototypeValidation.injectedComponentCount > 0 && prototypeValidation.checksum.length > 0,
+        botDocumentCertified: compiledBot.hash.length > 0 && botCoverage.fullModelCoverageComplete,
+        navmeshCertified: navPath.polygons.join('>') === 'spawn>goal' && navWaypointAdvances > 0,
+        animationCertified: animationTransitions >= 2 && animationEvents > 0,
+        staticDeterminismCertified: staticDiagnostics.filter((diagnostic) => diagnostic.severity === 'error').length === 0,
+        replayRuntimeVerified: replay.verification.result === 'pass',
+        selfContainedReplayRuntimeVerified: replay.selfContainedVerification.result === 'pass',
+        replayUsesProjectGameStateRuntime: replay.systemId === 'project-game-state-runtime-replay-v1',
+        replayAcceptsGeneratedRuntimeSourceHash: replay.acceptedGeneratedRuntimeSourceHash,
+        replayRuntimeCoversProjectCommands: runtimeDescriptor.commandChannels?.some((channel) => channel.id === 'spawn') === true,
+        replayRuntimeCoversProjectEvents: runtimeDescriptor.eventChannels?.some((event) => event.id === 'damage') === true,
+        projectFrameCapDeclared: executedFrames <= requestedFrames,
+        executedRequestedFrames: executedFrames === requestedFrames ? true : 'capped',
+    }, withFrameMetrics({
+        artifactId: descriptor.artifactId,
+        runtimeDescriptorHash: runtimeAccessors.descriptorHash,
+        generatedSourceHash,
+        generatedSourceBytes: generatedSource.length,
+        assetDbHash: assets.manifest.assetDbHash,
+        configHash: config.configHash,
+        prototypeRuntimeValidationChecksum: prototypeValidation.checksum,
+        botHash: compiledBot.hash,
+        botTraceRows: botTraces.length,
+        botCoverageComplete: botCoverage.fullModelCoverageComplete,
+        navmeshHash: navmesh.hash,
+        navPathHash: navPath.pathHash,
+        navWaypointAdvances,
+        navTraceChecksum,
+        animationHash: animation.hash,
+        animationTransitions,
+        animationEvents,
+        animationChecksum,
+        staticDiagnostics: staticDiagnostics.length,
+        replayBundleHash: replay.verification.bundleHash,
+        replayFinalChecksum: replay.verification.finalChecksum,
+        selfContainedReplayFinalChecksum: replay.selfContainedVerification.finalChecksum,
+        replaySnapshotCount: replay.snapshotCount,
+        replaySystemId: replay.systemId,
+        replayAcceptedGeneratedRuntimeSourceHash: replay.acceptedGeneratedRuntimeSourceHash,
+        replayRuntimeComponentCount: runtimeDescriptor.components.length,
+        replayRuntimeCommandChannelCount: runtimeDescriptor.commandChannels?.length ?? 0,
+        replayRuntimeEventChannelCount: runtimeDescriptor.eventChannels?.length ?? 0,
+        capped: executedFrames < requestedFrames,
+    }, requestedFrames, executedFrames));
+}
+function readProjectFixtureText(path) {
+    for (const candidate of projectFixtureCandidates(path)) {
+        if (existsSync(candidate)) {
+            return readFileSync(candidate, 'utf8');
+        }
+    }
+    throw new Error(`Unable to locate deterministic project fixture ${path}`);
+}
+function readProjectFixtureJson(path) {
+    return JSON.parse(readProjectFixtureText(path));
+}
+function projectFixtureCandidates(path) {
+    return [
+        resolve(process.cwd(), 'fixtures/projects/engine-parity', path),
+        resolve(process.cwd(), 'packages/syncplay/fixtures/projects/engine-parity', path),
+        resolve(process.cwd(), '../syncplay/fixtures/projects/engine-parity', path),
+    ];
+}
+function projectRuntimeDescriptorFromGameDescriptor(descriptor) {
+    return {
+        id: `${descriptor.artifactId}/project-runtime-replay`,
+        tickRate: descriptor.tickRate,
+        components: [
+            {
+                id: 'gameState',
+                singleton: true,
+                fields: descriptor.state.fields
+                    .filter((field) => field.checksummed)
+                    .map((field) => ({
+                    name: field.name,
+                    kind: projectRuntimeFieldKind(field.kind),
+                    defaultValue: projectRuntimeDefaultFieldValue(field.kind),
+                })),
+            },
+            {
+                id: 'runtimeReplayState',
+                singleton: true,
+                fields: [
+                    { name: 'value', kind: 'int', defaultValue: 0 },
+                    { name: 'inputDelta', kind: 'int', defaultValue: 0 },
+                    { name: 'commandDelta', kind: 'int', defaultValue: 0 },
+                ],
+            },
+        ],
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+        commandChannels: descriptor.commandChannels?.map((channel) => ({
+            id: channel.id,
+            reliable: channel.delivery === 'reliable',
+            allowPrediction: channel.delivery === 'reliable',
+            maxPayloadBytes: Math.max(64, channel.fields.length * 64),
+            ...(channel.delivery === 'unreliable' ? { minFrameLead: 1 } : {}),
+            maxFrameLead: 32,
+        })),
+        eventChannels: descriptor.events?.map((event) => ({
+            id: event.id,
+            fields: event.payloadFields.map((field) => ({
+                name: field.name,
+                kind: projectRuntimeFieldKind(field.kind),
+                defaultValue: projectRuntimeDefaultFieldValue(field.kind),
+            })),
+        })),
+    };
+}
+function projectRuntimeFieldKind(kind) {
+    if (kind === 'boolean') {
+        return 'bool';
+    }
+    if (kind === 'string' || kind === 'asset-ref') {
+        return 'string';
+    }
+    return 'int';
+}
+function projectRuntimeDefaultFieldValue(kind) {
+    if (kind === 'boolean') {
+        return false;
+    }
+    if (kind === 'string' || kind === 'asset-ref') {
+        return '';
+    }
+    return 0;
+}
+function projectRuntimeDefaultGameState(descriptor) {
+    const gameState = descriptor.components.find((component) => component.id === 'gameState' && component.singleton === true);
+    return Object.fromEntries(gameState.fields.map((field) => [
+        field.name,
+        field.defaultValue,
+    ]));
+}
+function createProjectRuntimeReplayProof(descriptor, generatedSourceHash, frames, seed) {
+    const runtime = createDeterministicFrameRuntime(descriptor, seed);
+    runtime.setSingleton('gameState', projectRuntimeDefaultGameState(descriptor));
+    runtime.setSingleton('runtimeReplayState', { value: 0, inputDelta: 0, commandDelta: 0 });
+    const firstSnapshot = runtime.snapshot();
+    const snapshots = [{ frame: firstSnapshot.frame, bytes: firstSnapshot.bytes, checksum: firstSnapshot.checksum }];
+    const inputHistory = Array.from({ length: frames }, (_, frame) => ({
+        frame,
+        inputs: projectRuntimeReplayInputsForFrame(frame),
+    }));
+    const commandHistory = Array.from({ length: frames }, (_, frame) => ({
+        frame,
+        commands: projectRuntimeReplayCommandsForFrame(frame),
+    }));
+    const systems = {
+        simulate: projectRuntimeReplaySystem,
+    };
+    for (let frame = 0; frame < frames; frame += 1) {
+        injectProjectRuntimeReplayFrame(runtime, frame, inputHistory[frame].inputs, commandHistory[frame].commands);
+        runtime.step(systems);
+        const snapshot = runtime.snapshot();
+        snapshots.push({ frame: snapshot.frame, bytes: snapshot.bytes, checksum: snapshot.checksum });
+    }
+    const bundle = createDeterministicReplayBundle({
+        runtimeVersion: 'engine-complete-project@1',
+        engineHash: defaultChecksum(descriptor),
+        schemaHash: defaultChecksum(descriptor),
+        assetDbHash: 'fixture-project-assets',
+        configHash: 'fixture-project-config',
+        sampleId: 'engine-complete-project-runtime',
+        inputHistory,
+        commandHistory,
+        checksums: snapshots.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+        debugEvents: runtime.debugEvents,
+        snapshots,
+        runtimeReplay: createDeterministicReplayRuntimeManifest({
+            descriptor,
+            systemId: 'project-game-state-runtime-replay-v1',
+            beforeFrameId: 'project-game-state-input-command-delta-v1',
+            acceptedSystemsSourceHashes: [generatedSourceHash],
+            seed,
+        }),
+        metadata: {
+            projectRuntime: true,
+            generatedSourceHash,
+            frames,
+        },
+    });
+    const verification = verifyDeterministicFrameRuntimeReplayBundle(bundle, {
+        descriptor,
+        systems,
+        systemsSourceHash: generatedSourceHash,
+        requireRuntimeIdentity: true,
+        seed,
+        beforeFrame: injectProjectRuntimeReplayFrame,
+    });
+    const selfContainedVerification = verifyDeterministicSelfContainedFrameRuntimeReplayBundle(bundle);
+    return {
+        verification,
+        selfContainedVerification,
+        snapshotCount: snapshots.length,
+        systemId: bundle.runtimeReplay.systemId,
+        acceptedGeneratedRuntimeSourceHash: bundle.runtimeReplay.acceptedSystemsSourceHashes.includes(generatedSourceHash),
+    };
+}
+const projectRuntimeReplaySystem = function runProjectRuntimeReplaySystem(ctx) {
+    const replayState = ctx.getSingleton('runtimeReplayState');
+    const value = Number(replayState.value) + Number(replayState.inputDelta) + Number(replayState.commandDelta);
+    ctx.setSingleton('runtimeReplayState', {
+        value,
+        inputDelta: 0,
+        commandDelta: 0,
+    });
+    const gameState = ctx.getSingleton('gameState');
+    ctx.setSingleton('gameState', patchProjectRuntimeGameState(gameState, ctx.frame + 1, value));
+    if (ctx.frame % 128 === 0) {
+        ctx.emitDebug('ecs.project-runtime-replay', { frame: ctx.frame, value });
+    }
+};
+function projectRuntimeReplayInputsForFrame(frame) {
+    const variant = frame % 4;
+    if (variant === 0) {
+        return [{ slot: 0, dx: frame + 1 }];
+    }
+    if (variant === 1) {
+        return [{ slot: 0, moveX: frame + 1 }];
+    }
+    if (variant === 2) {
+        return [frame];
+    }
+    return [{ slot: 0 }];
+}
+function projectRuntimeReplayCommandsForFrame(frame) {
+    const variant = frame % 4;
+    if (variant === 0) {
+        return [{ id: `project-runtime:${frame}`, payload: { power: frame % 3, prototype: 'player.prototype' } }];
+    }
+    if (variant === 1) {
+        return [{ id: `project-runtime:${frame}`, payload: { prototype: 'player.prototype', slot: frame % 4 } }];
+    }
+    if (variant === 2) {
+        return [{ id: `project-runtime:${frame}`, payload: 'ignored' }];
+    }
+    return [{ id: `project-runtime:${frame}`, payload: { prototype: 'player.prototype' } }];
+}
+function injectProjectRuntimeReplayFrame(runtime, frame, inputs, commands) {
+    const inputDelta = inputs.reduce((sum, input) => {
+        if (!isCanonicalRecord(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 (!isCanonicalRecord(command) || !isCanonicalRecord(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 replayState = runtime.snapshot().singletonComponents.runtimeReplayState;
+    runtime.setSingleton('runtimeReplayState', {
+        value: Number(replayState.value),
+        inputDelta,
+        commandDelta,
+    });
+    const gameState = runtime.snapshot().singletonComponents.gameState;
+    runtime.setSingleton('gameState', patchProjectRuntimeGameState(gameState, frame, Number(replayState.value)));
+}
+function patchProjectRuntimeGameState(gameState, frame, score) {
+    return Object.fromEntries(Object.keys(gameState).sort().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 createFrameRuntimeReplayProof(frames) {
+    const descriptor = {
+        id: 'engine-complete-runtime-replay',
+        tickRate: 60,
+        components: [{
+                id: 'score',
+                singleton: true,
+                fields: [
+                    { name: 'value', kind: 'int', defaultValue: 0 },
+                    { name: 'inputDelta', kind: 'int', defaultValue: 0 },
+                    { name: 'commandDelta', kind: 'int', defaultValue: 0 },
+                ],
+            }],
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+    };
+    const systems = {
+        simulate(ctx) {
+            const score = ctx.getSingleton('score');
+            ctx.setSingleton('score', {
+                value: Number(score.value) + Number(score.inputDelta) + Number(score.commandDelta),
+                inputDelta: 0,
+                commandDelta: 0,
+            });
+            if (ctx.frame % 128 === 0) {
+                ctx.emitDebug('ecs.runtime-replay', { frame: ctx.frame, value: Number(score.value) });
+            }
+        },
+    };
+    const runtime = createDeterministicFrameRuntime(descriptor, 91);
+    runtime.setSingleton('score', { value: 0, inputDelta: 0, commandDelta: 0 });
+    const firstSnapshot = runtime.snapshot();
+    const snapshots = [{ frame: firstSnapshot.frame, bytes: firstSnapshot.bytes, checksum: firstSnapshot.checksum }];
+    const inputHistory = Array.from({ length: frames }, (_, frame) => ({
+        frame,
+        inputs: frame % 2 === 0 ? [{ slot: 0, dx: frame + 1 }] : [frame],
+    }));
+    const commandHistory = Array.from({ length: frames }, (_, frame) => ({
+        frame,
+        commands: frame % 2 === 0 ? [{ id: `runtime-replay:${frame}`, payload: { power: frame % 3 } }] : [{ id: `runtime-replay:${frame}`, payload: 'ignored' }],
+    }));
+    for (let frame = 0; frame < frames; frame += 1) {
+        injectFrameRuntimeReplayInputs(runtime, frame, inputHistory[frame].inputs, commandHistory[frame].commands);
+        runtime.step(systems);
+        const snapshot = runtime.snapshot();
+        snapshots.push({ frame: snapshot.frame, bytes: snapshot.bytes, checksum: snapshot.checksum });
+    }
+    const bundle = createDeterministicReplayBundle({
+        runtimeVersion: 'engine-complete@1',
+        engineHash: 'engine-hash',
+        schemaHash: defaultChecksum(descriptor),
+        assetDbHash: 'asset-hash',
+        configHash: 'config-hash',
+        sampleId: 'engine-complete-frame-runtime',
+        inputHistory,
+        commandHistory,
+        checksums: snapshots.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+        debugEvents: runtime.debugEvents,
+        snapshots,
+        runtimeReplay: createDeterministicReplayRuntimeManifest({
+            descriptor,
+            systemId: 'score-runtime-replay-v1',
+            beforeFrameId: 'score-input-command-delta-v1',
+            seed: 91,
+        }),
+        metadata: { frameRuntimeReplay: true, selfContainedRuntimeReplay: true, frames },
+    });
+    const replayOptions = {
+        descriptor,
+        systems,
+        seed: 91,
+        beforeFrame: injectFrameRuntimeReplayInputs,
+    };
+    const forgedSnapshots = bundle.snapshots.map((snapshot) => {
+        if (snapshot.frame !== Math.min(2, frames)) {
+            return snapshot;
+        }
+        const parsed = JSON.parse(snapshot.bytes);
+        parsed.singletonComponents.score.value += 17;
+        const bytes = canonicalStringify(parsed);
+        return { frame: snapshot.frame, bytes, checksum: defaultChecksum(bytes) };
+    });
+    const forged = createDeterministicReplayBundle({
+        ...bundle,
+        snapshots: forgedSnapshots,
+        checksums: forgedSnapshots.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+    });
+    return {
+        verification: verifyDeterministicFrameRuntimeReplayBundle(bundle, replayOptions),
+        selfContainedVerification: verifyDeterministicSelfContainedFrameRuntimeReplayBundle(bundle),
+        forgedVerification: verifyDeterministicFrameRuntimeReplayBundle(forged, replayOptions),
+        snapshotCount: snapshots.length,
+    };
+}
+function injectFrameRuntimeReplayInputs(runtime, _frame, inputs, commands) {
+    const inputDelta = inputs.reduce((sum, input) => isCanonicalRecord(input) && typeof input.dx === 'number' ? sum + input.dx : sum, 0);
+    const commandDelta = commands.reduce((sum, command) => {
+        if (!isCanonicalRecord(command) || !isCanonicalRecord(command.payload) || typeof command.payload.power !== 'number') {
+            return sum;
+        }
+        return sum + command.payload.power;
+    }, 0);
+    const score = runtime.snapshot().singletonComponents.score;
+    runtime.setSingleton('score', {
+        value: Number(score.value),
+        inputDelta,
+        commandDelta,
+    });
+}
+function isCanonicalRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function createComponentReplayBundle() {
+    const firstBytes = canonicalStringify({ frame: 0, components: { 1: { position: { x: 2 } } } });
+    const secondBytes = canonicalStringify({ frame: 1, components: { 1: { position: { x: 5, y: 4 } } } });
+    return createDeterministicReplayBundle({
+        runtimeVersion: 'engine-complete@1',
+        engineHash: 'engine-hash',
+        schemaHash: 'component-schema-hash',
+        assetDbHash: 'asset-hash',
+        configHash: 'config-hash',
+        sampleId: 'engine-complete-components',
+        inputHistory: [
+            { frame: 0, inputs: [{ entity: '1', component: 'position', field: 'x', delta: 2 }] },
+            { frame: 1, inputs: [{ entity: '1', component: 'position', field: 'x', delta: 3 }] },
+        ],
+        commandHistory: [
+            { frame: 1, commands: [{ id: 'set-y', payload: { entity: '1', component: 'position', field: 'y', value: 4 } }] },
+        ],
+        checksums: [
+            { frame: 0, checksum: defaultChecksum(firstBytes) },
+            { frame: 1, checksum: defaultChecksum(secondBytes) },
+        ],
+        debugEvents: [{ frame: 1, type: 'ecs.snapshot', payload: { component: 'position' } }],
+        snapshots: [
+            { frame: 0, bytes: firstBytes, checksum: defaultChecksum(firstBytes) },
+            { frame: 1, bytes: secondBytes, checksum: defaultChecksum(secondBytes) },
+        ],
+        metadata: { semanticReplay: 'component-delta-v1' },
+    });
+}
+function physicsCategory(bodies, requestedFrames, executedFrames, enforceThresholds, benchmark, noFastStress) {
+    const metrics = runDeterministicPhysics3DStress(bodies, executedFrames, { allowFastStress: !noFastStress });
+    const callbackMasks = runDeterministicPhysics3DCallbackMaskFixture();
+    const queryOptions = runDeterministicPhysics3DQueryOptionsFixture();
+    const materials = runDeterministicPhysics3DMaterialFixture();
+    const details = runDeterministicPhysics3DDetailFixture();
+    const stack = runDeterministicPhysics3DStackFixture();
+    const lagComp3D = runDeterministicLagCompensation3DFixture(128, Math.min(executedFrames, 5_000), 71);
+    const lagComp3DApi = runDeterministicLagCompensation3DApiFixture();
+    const authoritativeLagComp3D = runDeterministicAuthoritativeLagCompensation3DFixture();
+    const fullStep = runPhysics3DFullStepMeasurementFixture(Math.min(requestedFrames, 300));
+    const highBodySample512 = requestedFrames > 512 ? runDeterministicPhysics3DStress(512, 128) : undefined;
+    const highBodySample2048 = requestedFrames > 512 ? runDeterministicPhysics3DStress(2048, 32) : undefined;
+    return categoryReport('physics3d', defaultChecksum({
+        stress: metrics.checksum,
+        materials: materials.checksum,
+        stack: stack.checksum,
+        lagComp3D: lagComp3D.checksum,
+        lagComp3DApi: lagComp3DApi.checksum,
+        authoritativeLagComp3D: authoritativeLagComp3D.checksum,
+    }), {
+        has3dBodies: metrics.bodies === bodies,
+        scheduledQueriesRan: metrics.queryCount === executedFrames * 3,
+        scheduledPrePhysicsQueriesRan: metrics.scheduledPrePhysicsQueries === executedFrames,
+        scheduledPostPhysicsQueriesRan: metrics.scheduledPostPhysicsQueries === executedFrames * 2,
+        scheduledShapeCastQueriesRan: metrics.scheduledShapeCastQueries === executedFrames,
+        scheduledQueryResultsStable: metrics.scheduledQueryOrderHash.length > 0,
+        shapeCastsCovered: metrics.shapeCastCount > 0,
+        exactShapeNarrowphaseCovered: metrics.exactShapeRejects > 0,
+        solverCorrectionsCovered: metrics.solverCorrections > 0,
+        angularDynamicsCovered: metrics.angularBodies > 0,
+        angularGeometryCovered: metrics.angularGeometryQueries > 0,
+        meshStaticCollidersCovered: metrics.meshStaticColliders > 0,
+        exactMeshRaycastsCovered: metrics.exactMeshRaycasts > 0,
+        exactMeshOverlapRejectsCovered: metrics.exactMeshOverlapRejects > 0,
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        callbackMasksCovered: callbackMasks.perEntityMaskHonored,
+        queryOptionsCovered: queryOptions.defaultHitAll
+            && queryOptions.explicitSolidsOnly
+            && queryOptions.kindFiltersStable
+            && queryOptions.triggerSensorFiltersStable
+            && queryOptions.raycastCovered
+            && queryOptions.overlapCovered
+            && queryOptions.shapeCastCovered,
+        detailedHitAndContactCovered: details.rayDetailedHits > 0
+            && details.shapeCastDetailedHits > 0
+            && details.contactDetails > 0
+            && details.rayNormalX === -1
+            && details.shapeCastPointX > 0
+            && details.contactPenetration > 0,
+        detailedPhysicsRollbackEquivalent: details.rollbackEquivalent,
+        detailedPhysicsOrderStable: details.stableUnderBodyOrderPermutation,
+        stackStabilityCovered: stack.contactCount > 0
+            && stack.solverCorrections > 0
+            && stack.maxPenetration <= 0.05
+            && stack.maxHeightDrift <= 0.05
+            && stack.settledDynamicBodies === stack.stackLayers,
+        stackRollbackEquivalent: stack.rollbackEquivalent,
+        stackAuthoringOrderStable: stack.stableUnderAuthoringOrderPermutation,
+        materialResponseCovered: materials.combinedFriction === 3
+            && materials.combinedRestitution === 7
+            && materials.normalVelocityAfterBounce === -2
+            && materials.tangentVelocityAfterFrictionY === 7
+            && materials.tangentVelocityAfterFrictionZ === -7,
+        materialRollbackEquivalent: materials.rollbackEquivalent,
+        callbackLifecycleCovered: callbackMasks.collisionEnter > 0
+            && callbackMasks.collisionStay > 0
+            && callbackMasks.collisionExit > 0
+            && callbackMasks.triggerEnter > 0
+            && callbackMasks.triggerStay > 0
+            && callbackMasks.triggerExit > 0,
+        callbackRollbackEquivalent: callbackMasks.rollbackEquivalent,
+        lagComp3DProxyLifecycleCovered: lagComp3D.proxyLifecycleBalanced
+            && lagComp3D.proxyBodiesCreated > 0
+            && lagComp3D.proxyBodiesDestroyed === lagComp3D.proxyBodiesCreated,
+        lagComp3DHitboxProxyCovered: lagComp3D.multiHitboxQueries > 0 && lagComp3D.animatedHitboxSamples > 0,
+        lagComp3DInterpolatedHitboxesCovered: lagComp3D.interpolatedHitboxSamples > 0,
+        lagComp3DWeaponsCovered: lagComp3D.rifleShots > 0 && lagComp3D.shotgunShots > 0 && lagComp3D.burstShots > 0,
+        lagComp3DOcclusionCovered: lagComp3D.staticOcclusionQueries > 0 && lagComp3D.occluded > 0,
+        lagComp3DRejectionCovered: lagComp3D.staleRejected > 0 && lagComp3D.futureRejected > 0,
+        lagComp3DRollbackEquivalent: lagComp3D.rollbackEquivalent,
+        lagComp3DPerClientShotTimesCovered: lagComp3D.perClientShotTimesCovered,
+        lagComp3DApiReusable: lagComp3DApi.hitReason === 'hit'
+            && lagComp3DApi.occludedReason === 'occluded'
+            && lagComp3DApi.staleReason === 'stale-frame'
+            && lagComp3DApi.futureReason === 'future-frame',
+        lagComp3DApiInterpolationCovered: lagComp3DApi.interpolatedRewindTargets > 0,
+        lagComp3DApiSnapshotRestoreEquivalent: lagComp3DApi.rollbackEquivalent,
+        lagComp3DApiProxyLifecycleCovered: lagComp3DApi.proxiesCreated > 0
+            && lagComp3DApi.proxiesCreated === lagComp3DApi.proxiesDestroyed,
+        lagComp3DApiHistoryPruningCovered: lagComp3DApi.prunedOldFrames,
+        lagComp3DAuthoritativeShotTimeCovered: authoritativeLagComp3D.authorityHitReason === 'hit'
+            && authoritativeLagComp3D.derivedRewindFrame === 1
+            && authoritativeLagComp3D.rawForgedRewindFrame !== authoritativeLagComp3D.derivedRewindFrame,
+        lagComp3DAuthoritativeForgedTimingRejected: authoritativeLagComp3D.forgedLatencyReason === 'invalid-shot'
+            && authoritativeLagComp3D.forgedShotFrameReason === 'invalid-shot'
+            && authoritativeLagComp3D.forgedHistoryReason === 'invalid-shot'
+            && authoritativeLagComp3D.authorityTimingRejected === 3,
+        lagComp3DAuthoritativeRollbackEquivalent: authoritativeLagComp3D.rollbackEquivalent,
+        fullStepMeasuredTimingCovered: fullStep.frames === fullStep.fullStepFrames
+            && fullStep.p95MeasuredStepMs > 0
+            && fullStep.p99MeasuredStepMs > 0,
+        fullStepRollbackEquivalent: fullStep.rollbackEquivalent,
+        fullStepContactsAndQueriesCovered: fullStep.contactCount > 0 && fullStep.queryCount === fullStep.frames,
+        executedRequestedFrames: metrics.frames === requestedFrames,
+        ...(metrics.extrapolatedStress ? {} : {
+            fullPhysicsRequiredProofCovered: metrics.fullPhysicsStepFrames === metrics.frames,
+        }),
+        optimizedPhysicsBenchmarkTailDeclared: benchmark && !noFastStress
+            ? metrics.extrapolatedStress && metrics.optimizedStressFrames > 0
+            : metrics.extrapolatedStress === false && metrics.optimizedStressFrames === 0,
+        noFastStressHonored: noFastStress
+            ? metrics.fullPhysicsStepFrames === metrics.frames && metrics.optimizedStressFrames === 0 && metrics.extrapolatedStress === false
+            : true,
+        optimizedStressFramesDeclared: metrics.optimizedStressFrames === Math.max(0, metrics.frames - metrics.fullPhysicsStepFrames),
+        measuredP99WithinThreshold: enforceThresholds ? metrics.p99StepMs < 25 : true,
+        physicsStressProofMode: metrics.extrapolatedStress ? 'optimized-tail' : 'full-step',
+    }, withFrameMetrics({
+        ...metrics,
+        callbackMaskChecksum: callbackMasks.checksum,
+        callbackMaskRestoredChecksum: callbackMasks.restoredChecksum,
+        callbackMaskRollbackEquivalent: callbackMasks.rollbackEquivalent,
+        queryOptionsRollbackStable: queryOptions.checksum.length > 0,
+        callbackCollisionEnter: callbackMasks.collisionEnter,
+        callbackCollisionStay: callbackMasks.collisionStay,
+        callbackCollisionExit: callbackMasks.collisionExit,
+        callbackTriggerEnter: callbackMasks.triggerEnter,
+        callbackTriggerStay: callbackMasks.triggerStay,
+        callbackTriggerExit: callbackMasks.triggerExit,
+        callbackDisabledEvents: callbackMasks.disabledEvents,
+        queryOptionsChecksum: queryOptions.checksum,
+        queryOptionsDefaultHitAll: queryOptions.defaultHitAll,
+        queryOptionsExplicitSolidsOnly: queryOptions.explicitSolidsOnly,
+        queryOptionsKindFiltersStable: queryOptions.kindFiltersStable,
+        queryOptionsTriggerSensorFiltersStable: queryOptions.triggerSensorFiltersStable,
+        queryOptionsRaycastCovered: queryOptions.raycastCovered,
+        queryOptionsOverlapCovered: queryOptions.overlapCovered,
+        queryOptionsShapeCastCovered: queryOptions.shapeCastCovered,
+        detailChecksum: details.checksum,
+        detailRestoredChecksum: details.restoredChecksum,
+        detailRollbackEquivalent: details.rollbackEquivalent,
+        detailRayDetailedHits: details.rayDetailedHits,
+        detailShapeCastDetailedHits: details.shapeCastDetailedHits,
+        detailContactDetails: details.contactDetails,
+        detailStableUnderBodyOrderPermutation: details.stableUnderBodyOrderPermutation,
+        detailRayNormalX: details.rayNormalX,
+        detailShapeCastPointX: details.shapeCastPointX,
+        detailContactPenetration: details.contactPenetration,
+        materialChecksum: materials.checksum,
+        materialRestoredChecksum: materials.restoredChecksum,
+        materialCombinedFriction: materials.combinedFriction,
+        materialCombinedRestitution: materials.combinedRestitution,
+        materialNormalVelocityAfterBounce: materials.normalVelocityAfterBounce,
+        materialTangentVelocityAfterFrictionY: materials.tangentVelocityAfterFrictionY,
+        materialTangentVelocityAfterFrictionZ: materials.tangentVelocityAfterFrictionZ,
+        materialRollbackEquivalent: materials.rollbackEquivalent,
+        stackChecksum: stack.checksum,
+        stackRestoredChecksum: stack.restoredChecksum,
+        stackReversedOrderChecksum: stack.reversedOrderChecksum,
+        stackBodies: stack.bodies,
+        stackFrames: stack.frames,
+        stackLayers: stack.stackLayers,
+        stackContactCount: stack.contactCount,
+        stackSolverCorrections: stack.solverCorrections,
+        stackMaxPenetration: stack.maxPenetration,
+        stackMaxHeightDrift: stack.maxHeightDrift,
+        stackSettledDynamicBodies: stack.settledDynamicBodies,
+        stackP95StepCost: stack.p95StepCost,
+        stackP99StepCost: stack.p99StepCost,
+        stackRollbackEquivalent: stack.rollbackEquivalent,
+        stackStableUnderAuthoringOrderPermutation: stack.stableUnderAuthoringOrderPermutation,
+        lagComp3DChecksum: lagComp3D.checksum,
+        lagComp3DRestoredChecksum: lagComp3D.restoredChecksum,
+        lagComp3DPlayers: lagComp3D.players,
+        lagComp3DFrames: lagComp3D.frames,
+        lagComp3DShots: lagComp3D.shots,
+        lagComp3DRifleShots: lagComp3D.rifleShots,
+        lagComp3DShotgunShots: lagComp3D.shotgunShots,
+        lagComp3DBurstShots: lagComp3D.burstShots,
+        lagComp3DHits: lagComp3D.hits,
+        lagComp3DMisses: lagComp3D.misses,
+        lagComp3DOccluded: lagComp3D.occluded,
+        lagComp3DStaleRejected: lagComp3D.staleRejected,
+        lagComp3DFutureRejected: lagComp3D.futureRejected,
+        lagComp3DMultiHitboxQueries: lagComp3D.multiHitboxQueries,
+        lagComp3DAnimatedHitboxSamples: lagComp3D.animatedHitboxSamples,
+        lagComp3DInterpolatedHitboxSamples: lagComp3D.interpolatedHitboxSamples,
+        lagComp3DStaticOcclusionQueries: lagComp3D.staticOcclusionQueries,
+        lagComp3DProxyBodiesCreated: lagComp3D.proxyBodiesCreated,
+        lagComp3DProxyBodiesDestroyed: lagComp3D.proxyBodiesDestroyed,
+        lagComp3DProxyLifecycleBalanced: lagComp3D.proxyLifecycleBalanced,
+        lagComp3DPerClientShotTimesCovered: lagComp3D.perClientShotTimesCovered,
+        lagComp3DRollbackEquivalent: lagComp3D.rollbackEquivalent,
+        lagComp3DApiChecksum: lagComp3DApi.checksum,
+        lagComp3DApiRestoredChecksum: lagComp3DApi.restoredChecksum,
+        lagComp3DApiExactRewindTargets: lagComp3DApi.exactRewindTargets,
+        lagComp3DApiInterpolatedRewindTargets: lagComp3DApi.interpolatedRewindTargets,
+        lagComp3DApiHitReason: lagComp3DApi.hitReason,
+        lagComp3DApiOccludedReason: lagComp3DApi.occludedReason,
+        lagComp3DApiStaleReason: lagComp3DApi.staleReason,
+        lagComp3DApiFutureReason: lagComp3DApi.futureReason,
+        lagComp3DApiProxiesCreated: lagComp3DApi.proxiesCreated,
+        lagComp3DApiProxiesDestroyed: lagComp3DApi.proxiesDestroyed,
+        lagComp3DApiHistoryFrameCount: lagComp3DApi.historyFrameCount,
+        lagComp3DApiPrunedOldFrames: lagComp3DApi.prunedOldFrames,
+        lagComp3DAuthoritativeChecksum: authoritativeLagComp3D.checksum,
+        lagComp3DAuthoritativeHitReason: authoritativeLagComp3D.authorityHitReason,
+        lagComp3DAuthoritativeForgedLatencyReason: authoritativeLagComp3D.forgedLatencyReason,
+        lagComp3DAuthoritativeForgedShotFrameReason: authoritativeLagComp3D.forgedShotFrameReason,
+        lagComp3DAuthoritativeForgedHistoryReason: authoritativeLagComp3D.forgedHistoryReason,
+        lagComp3DAuthoritativeDerivedRewindFrame: authoritativeLagComp3D.derivedRewindFrame,
+        lagComp3DAuthoritativeRawForgedRewindFrame: authoritativeLagComp3D.rawForgedRewindFrame,
+        lagComp3DAuthoritativeTimingRejected: authoritativeLagComp3D.authorityTimingRejected,
+        lagComp3DAuthoritativeRollbackEquivalent: authoritativeLagComp3D.rollbackEquivalent,
+        fullStepChecksum: fullStep.checksum,
+        fullStepRestoredChecksum: fullStep.restoredChecksum,
+        fullStepFrames: fullStep.frames,
+        fullStepBodies: fullStep.bodies,
+        fullStepContactCount: fullStep.contactCount,
+        fullStepQueryCount: fullStep.queryCount,
+        fullStepP95MeasuredStepMs: fullStep.p95MeasuredStepMs,
+        fullStepP99MeasuredStepMs: fullStep.p99MeasuredStepMs,
+        fullStepMaxMeasuredStepMs: fullStep.maxMeasuredStepMs,
+        fullStepWallClockElapsedMs: fullStep.wallClockElapsedMs,
+        fullStepRollbackEquivalent: fullStep.rollbackEquivalent,
+        highBodySample512Checksum: highBodySample512?.checksum ?? '',
+        highBodySample512Frames: highBodySample512?.frames ?? 0,
+        highBodySample2048Checksum: highBodySample2048?.checksum ?? '',
+        highBodySample2048Frames: highBodySample2048?.frames ?? 0,
+    }, requestedFrames, metrics.frames));
+}
+function kccCategory(players, requestedFrames, executedFrames, benchmark, noFastStress) {
+    const metrics = runDeterministicKcc3DCrowdFixture(players, executedFrames, { allowFastStress: !noFastStress });
+    const fullStep = runKcc3DFullStepMeasurementFixture(Math.min(players, 128), Math.min(requestedFrames, 300));
+    const adversarial = runDeterministicKcc3DAdversarialFixture();
+    const filterForce = runDeterministicKcc3DFilterForceFixture();
+    const callbackFilter = runDeterministicKcc3DCallbackFilterFixture();
+    const geometry = runDeterministicKcc3DGeometryFixture();
+    return categoryReport('kcc3d', defaultChecksum({
+        stress: metrics.checksum,
+        adversarial: adversarial.checksum,
+        filterForce: filterForce.checksum,
+        callbackFilter: callbackFilter.checksum,
+        geometry: geometry.checksum,
+    }), {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        playersCovered: metrics.players === players,
+        executedRequestedFrames: metrics.frames === requestedFrames,
+        physicsQueriesCovered: metrics.physicsQueryCount >= metrics.players * metrics.frames,
+        collisionCorrectionsCovered: metrics.correctionCount > 0,
+        physicsSlidesCovered: metrics.physicsSlides > 0,
+        slopesCovered: metrics.slopeContacts > 0,
+        stepsCovered: metrics.stepContacts > 0,
+        movingPlatformsCovered: metrics.platformContacts > 0,
+        sweptCollisionsCovered: metrics.sweptCollisions > 0,
+        headClearanceCovered: metrics.headClearanceBlocks > 0,
+        platformVelocityTransferCovered: metrics.platformVelocityTransfers > 0,
+        fullStepMeasuredTimingCovered: fullStep.frames === fullStep.fullStepFrames
+            && fullStep.p95MeasuredStepMs > 0
+            && fullStep.p99MeasuredStepMs > 0,
+        fullStepRollbackEquivalent: fullStep.rollbackEquivalent,
+        fullStepMechanicsCovered: fullStep.correctionCount > 0
+            && fullStep.physicsQueryCount >= fullStep.players * fullStep.frames,
+        adversarialRollbackEquivalent: adversarial.rollbackEquivalent,
+        adversarialThinWallSweepsCovered: adversarial.thinWallSweeps > 0,
+        adversarialDiagonalThinWallSweepsCovered: adversarial.diagonalThinWallSweeps > 0,
+        adversarialLedgeCorrectionsCovered: adversarial.ledgeCorrections > 0,
+        adversarialCeilingBlocksCovered: adversarial.ceilingBlocks > 0,
+        adversarialCornerSweepsCovered: adversarial.cornerSweeps > 0,
+        adversarialMovingPlatformEdgeTransfersCovered: adversarial.movingPlatformEdgeTransfers > 0,
+        adversarialSlopeLimitRejectionsCovered: adversarial.slopeLimitRejections > 0,
+        ignoredColliderFilteringCovered: filterForce.ignoredColliderPassedThrough,
+        solidColliderStillBlocksAfterFilter: filterForce.solidColliderBlocked,
+        externalImpulseCovered: filterForce.externalImpulseApplied,
+        externalImpulseOrderStable: filterForce.filterOrderStable,
+        kccFilterForceRollbackEquivalent: filterForce.rollbackEquivalent,
+        perHitCallbackFilteringCovered: callbackFilter.callbackIgnoredColliderPassedThrough
+            && callbackFilter.callbackLayerFiltered
+            && callbackFilter.callbackNormalFiltered
+            && callbackFilter.callbackRejectedHits > 0,
+        perHitCallbackSolidStillBlocks: callbackFilter.callbackSolidColliderBlocked
+            && callbackFilter.callbackAcceptedHits > 0,
+        perHitCallbackMetadataCovered: callbackFilter.callbackMetadataCovered
+            && callbackFilter.callbackInvocations > 0,
+        perHitCallbackOrderStable: callbackFilter.callbackOrderStable,
+        perHitCallbackRejectsMutableState: callbackFilter.mutableFilterRejected,
+        perHitCallbackRollbackEquivalent: callbackFilter.rollbackEquivalent,
+        controllerGeometryConfigurable: geometry.defaultGeometryPreserved
+            && geometry.geometryMetadataStable,
+        controllerRadiusAffectsCollision: geometry.smallRadiusPassesNarrowGap
+            && geometry.largeRadiusBlockedByNarrowGap,
+        controllerHeightAffectsHeadClearance: geometry.tallBodyHeadBlocked
+            && geometry.shortBodyClearsLowCeiling,
+        controllerSkinWidthAffectsCollision: geometry.skinWidthExpandsCollisionShape,
+        controllerGeometryRollbackEquivalent: geometry.rollbackEquivalent,
+        ...(metrics.extrapolatedStress ? {} : {
+            fullKccRequiredProofCovered: metrics.fullKccStepFrames === metrics.frames,
+        }),
+        optimizedKccBenchmarkTailDeclared: benchmark && !noFastStress
+            ? metrics.extrapolatedStress && metrics.optimizedStressFrames > 0
+            : metrics.extrapolatedStress === false && metrics.optimizedStressFrames === 0,
+        noFastStressHonored: noFastStress
+            ? metrics.fullKccStepFrames === metrics.frames && metrics.optimizedStressFrames === 0 && metrics.extrapolatedStress === false
+            : true,
+        optimizedStressFramesDeclared: metrics.optimizedStressFrames === Math.max(0, metrics.frames - metrics.fullKccStepFrames),
+        kccStressProofMode: metrics.extrapolatedStress ? 'optimized-tail' : 'full-step',
+    }, withFrameMetrics({
+        ...metrics,
+        fullStepChecksum: fullStep.checksum,
+        fullStepRestoredChecksum: fullStep.restoredChecksum,
+        fullStepPlayers: fullStep.players,
+        fullStepFrames: fullStep.frames,
+        fullStepCorrectionCount: fullStep.correctionCount,
+        fullStepPhysicsQueryCount: fullStep.physicsQueryCount,
+        fullStepP95MeasuredStepMs: fullStep.p95MeasuredStepMs,
+        fullStepP99MeasuredStepMs: fullStep.p99MeasuredStepMs,
+        fullStepMaxMeasuredStepMs: fullStep.maxMeasuredStepMs,
+        fullStepWallClockElapsedMs: fullStep.wallClockElapsedMs,
+        fullStepRollbackEquivalent: fullStep.rollbackEquivalent,
+        adversarialChecksum: adversarial.checksum,
+        adversarialRestoredChecksum: adversarial.restoredChecksum,
+        adversarialRollbackEquivalent: adversarial.rollbackEquivalent,
+        adversarialThinWallSweeps: adversarial.thinWallSweeps,
+        adversarialDiagonalThinWallSweeps: adversarial.diagonalThinWallSweeps,
+        adversarialLedgeCorrections: adversarial.ledgeCorrections,
+        adversarialCeilingBlocks: adversarial.ceilingBlocks,
+        adversarialCornerSweeps: adversarial.cornerSweeps,
+        adversarialMovingPlatformEdgeTransfers: adversarial.movingPlatformEdgeTransfers,
+        adversarialSlopeLimitRejections: adversarial.slopeLimitRejections,
+        ignoredColliderCollisionEvents: filterForce.ignoredCollisionEvents,
+        solidColliderCollisionEvents: filterForce.solidCollisionEvents,
+        externalImpulseEvents: filterForce.externalImpulseEvents,
+        kccFilterForceRollbackEquivalent: filterForce.rollbackEquivalent,
+        kccCallbackFilterChecksum: callbackFilter.checksum,
+        kccCallbackFilterRestoredChecksum: callbackFilter.restoredChecksum,
+        kccCallbackFilterRollbackEquivalent: callbackFilter.rollbackEquivalent,
+        kccCallbackFilterInvocations: callbackFilter.callbackInvocations,
+        kccCallbackFilterRejectedHits: callbackFilter.callbackRejectedHits,
+        kccCallbackFilterAcceptedHits: callbackFilter.callbackAcceptedHits,
+        kccCallbackFilterIgnoredPassedThrough: callbackFilter.callbackIgnoredColliderPassedThrough,
+        kccCallbackFilterSolidBlocked: callbackFilter.callbackSolidColliderBlocked,
+        kccCallbackFilterLayerFiltered: callbackFilter.callbackLayerFiltered,
+        kccCallbackFilterNormalFiltered: callbackFilter.callbackNormalFiltered,
+        kccCallbackFilterOrderStable: callbackFilter.callbackOrderStable,
+        kccCallbackFilterMetadataCovered: callbackFilter.callbackMetadataCovered,
+        kccCallbackFilterMutableRejected: callbackFilter.mutableFilterRejected,
+        kccGeometryChecksum: geometry.checksum,
+        kccGeometryRestoredChecksum: geometry.restoredChecksum,
+        kccGeometryRollbackEquivalent: geometry.rollbackEquivalent,
+        kccGeometryDefaultPreserved: geometry.defaultGeometryPreserved,
+        kccGeometrySmallRadiusPassesNarrowGap: geometry.smallRadiusPassesNarrowGap,
+        kccGeometryLargeRadiusBlockedByNarrowGap: geometry.largeRadiusBlockedByNarrowGap,
+        kccGeometryTallBodyHeadBlocked: geometry.tallBodyHeadBlocked,
+        kccGeometryShortBodyClearsLowCeiling: geometry.shortBodyClearsLowCeiling,
+        kccGeometrySkinWidthExpandsCollisionShape: geometry.skinWidthExpandsCollisionShape,
+        kccGeometryMetadataStable: geometry.geometryMetadataStable,
+    }, requestedFrames, metrics.frames));
+}
+function runPhysics3DFullStepMeasurementFixture(frames) {
+    let world = createDeterministicPhysicsWorld3D(createFullStepPhysicsBodies3D(96));
+    let snapshot = world;
+    let contactCount = 0;
+    let queryCount = 0;
+    const timings = [];
+    const startedAt = engineCompleteNowMs();
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === Math.floor(frames / 2)) {
+            snapshot = world;
+        }
+        const stepStartedAt = engineCompleteNowMs();
+        const result = stepDeterministicPhysicsWorld3D(world, {
+            computeChecksum: false,
+            scheduledQueries: [{
+                    id: `full-step-ray-${frame}`,
+                    phase: 'pre-physics',
+                    query: { x: -4, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 32, layerMask: 0b1111 },
+                }],
+        });
+        timings.push(engineCompleteNowMs() - stepStartedAt);
+        world = result.world;
+        contactCount += result.narrowphaseContacts;
+        queryCount += result.scheduledQueryResults.length;
+    }
+    const checksum = defaultChecksum(world);
+    let restored = snapshot;
+    for (let frame = Math.floor(frames / 2); frame < frames; frame += 1) {
+        restored = stepDeterministicPhysicsWorld3D(restored, {
+            computeChecksum: false,
+            scheduledQueries: [{
+                    id: `full-step-ray-${frame}`,
+                    phase: 'pre-physics',
+                    query: { x: -4, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 32, layerMask: 0b1111 },
+                }],
+        }).world;
+    }
+    return {
+        checksum,
+        restoredChecksum: defaultChecksum(restored),
+        rollbackEquivalent: checksum === defaultChecksum(restored),
+        bodies: world.bodies.length,
+        frames,
+        fullStepFrames: frames,
+        contactCount,
+        queryCount,
+        p95MeasuredStepMs: roundMetric(percentileNumber(timings, 95), 6),
+        p99MeasuredStepMs: roundMetric(percentileNumber(timings, 99), 6),
+        maxMeasuredStepMs: roundMetric(timings.reduce((max, value) => Math.max(max, value), 0), 6),
+        wallClockElapsedMs: roundMetric(engineCompleteNowMs() - startedAt, 4),
+    };
+}
+function runKcc3DFullStepMeasurementFixture(players, frames) {
+    let bodies = Array.from({ length: players }, (_, slot) => ({
+        x: slot % 16,
+        y: slot % 17 === 0 ? 4 : 0,
+        z: Math.floor(slot / 16),
+        vx: 0,
+        vy: slot % 17 === 0 ? -1 : 0,
+        vz: 0,
+        grounded: slot % 17 !== 0,
+        coyoteFrames: slot % 17 === 0 ? 0 : 4,
+        jumpBufferFrames: 0,
+    }));
+    const kccWorld = {
+        minX: -8,
+        maxX: 48,
+        minY: 0,
+        maxY: 32,
+        minZ: -8,
+        maxZ: 32,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+        slopes: [{ id: 'full-slope', minX: -2, maxX: 4, minZ: -8, maxZ: 8, baseY: 0, risePerUnitX: 1 }],
+        steps: [{ id: 'full-step', minX: 18, maxX: 22, minZ: -8, maxZ: 12, height: 2 }],
+        movingPlatforms: [{ id: 'full-platform', minX: 30, maxX: 34, minZ: -4, maxZ: 12, y: 3, dxPerFrame: 1, dzPerFrame: 0 }],
+    };
+    const physics = createDeterministicPhysicsWorld3D(createFullStepKccObstacles3D());
+    let snapshot = bodies;
+    let correctionCount = 0;
+    let physicsQueryCount = 0;
+    const timings = [];
+    const startedAt = engineCompleteNowMs();
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === Math.floor(frames / 2)) {
+            snapshot = bodies.map((body) => ({ ...body }));
+        }
+        const stepStartedAt = engineCompleteNowMs();
+        bodies = bodies.map((body, slot) => {
+            const result = stepDeterministicKcc3D(body, {
+                moveX: (slot + frame) % 3 - 1,
+                moveZ: (slot * 2 + frame) % 3 - 1,
+                jumpPressed: (slot + frame) % 101 === 0,
+            }, kccWorld, { frame, physics });
+            correctionCount += result.correctionCount;
+            physicsQueryCount += result.physicsQueryCount;
+            return result.body;
+        });
+        timings.push(engineCompleteNowMs() - stepStartedAt);
+    }
+    const checksum = defaultChecksum(bodies);
+    let restored = snapshot;
+    for (let frame = Math.floor(frames / 2); frame < frames; frame += 1) {
+        restored = restored.map((body, slot) => stepDeterministicKcc3D(body, {
+            moveX: (slot + frame) % 3 - 1,
+            moveZ: (slot * 2 + frame) % 3 - 1,
+            jumpPressed: (slot + frame) % 101 === 0,
+        }, kccWorld, { frame, physics }).body);
+    }
+    return {
+        checksum,
+        restoredChecksum: defaultChecksum(restored),
+        rollbackEquivalent: checksum === defaultChecksum(restored),
+        players,
+        frames,
+        fullStepFrames: frames,
+        correctionCount,
+        physicsQueryCount,
+        p95MeasuredStepMs: roundMetric(percentileNumber(timings, 95), 6),
+        p99MeasuredStepMs: roundMetric(percentileNumber(timings, 99), 6),
+        maxMeasuredStepMs: roundMetric(timings.reduce((max, value) => Math.max(max, value), 0), 6),
+        wallClockElapsedMs: roundMetric(engineCompleteNowMs() - startedAt, 4),
+    };
+}
+function createFullStepPhysicsBodies3D(count) {
+    return Array.from({ length: count }, (_, index) => ({
+        id: `full-body-${index}`,
+        kind: index === 0 ? 'static' : 'dynamic',
+        x: index === 0 ? 4 : (index % 12) - 6,
+        y: Math.floor(index / 12) % 2,
+        z: Math.floor(index / 24),
+        vx: index === 0 ? 0 : (index % 3) - 1,
+        vy: 0,
+        vz: index === 0 ? 0 : ((index + 1) % 3) - 1,
+        shape: index % 5 === 0 ? { type: 'sphere', radius: 1 } : { type: 'box', halfX: 1, halfY: 1, halfZ: 1 },
+        layer: 1 << (index % 4),
+        mask: 0b1111,
+        material: { friction: index % 7, restitution: index % 3 },
+    }));
+}
+function createFullStepKccObstacles3D() {
+    return [3, 7, 11, 15, 19].flatMap((x, index) => [
+        {
+            id: `full-kcc-wall-${index}`,
+            kind: 'static',
+            x,
+            y: 0,
+            z: index,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 0.75, halfY: 3, halfZ: 1 },
+            layer: 1,
+            mask: 1,
+        },
+    ]);
+}
+function navmeshCategory(players, requestedFrames, executedFrames) {
+    const metrics = runDeterministicNavmeshStress(players, executedFrames);
+    const imported = runDeterministicNavmeshImportTraversalFixture();
+    const layered = runDeterministicNavmeshLayered3DFixture();
+    const velocityObstacle = runDeterministicNavmeshVelocityObstacleFixture();
+    return categoryReport('navmesh', defaultChecksum({ stress: metrics.checksum, imported: imported.checksum, layered: layered.checksum, velocityObstacle: velocityObstacle.checksum }), {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        agentsCovered: metrics.agents === players,
+        executedRequestedFrames: metrics.frames === requestedFrames,
+        replansObserved: metrics.replans > 0,
+        waypointProgressionObserved: metrics.waypointAdvances > 0,
+        avoidanceCovered: metrics.avoidanceCorrections > 0,
+        radiusAvoidanceCovered: metrics.radiusAvoidanceCorrections > 0,
+        velocityObstacleAvoidanceCovered: metrics.velocityObstacleAvoidanceCorrections > 0
+            && metrics.avoidanceSpeedReductions > 0
+            && velocityObstacle.movingObstacleSpeedReduction,
+        agentVelocityObstacleAvoidanceCovered: metrics.agentVelocityObstacleAvoidanceCorrections > 0
+            && metrics.agentAvoidancePriorityYields > 0
+            && metrics.agentAvoidanceSpeedReductions > 0,
+        velocityObstaclePredictionCovered: velocityObstacle.predictedFuturePositionAvoided,
+        velocityObstacleOrderStable: velocityObstacle.obstacleOrderStable,
+        velocityObstacleValidationRejected: velocityObstacle.obstacleValidationRejected,
+        velocityObstacleRollbackEquivalent: velocityObstacle.rollbackEquivalent,
+        pointPathingCovered: metrics.pointPathFound,
+        nearestPolygonLookupCovered: metrics.pointLookupStable,
+        importedCookOrderStable: imported.importOrderStable,
+        importedPortalAndSpawnCovered: imported.portalCount > 0 && imported.spawnMarkerCount > 0,
+        importedValidationFailuresCovered: imported.missingRegionRejected && imported.missingLinkRejected && imported.missingSpawnRejected,
+        offMeshTraversalLifecycleCovered: imported.offMeshEnterEvents > 0
+            && imported.offMeshTraverseEvents > 0
+            && imported.offMeshExitEvents > 0
+            && imported.offMeshCompleteEvents > 0,
+        offMeshTraversalRollbackEquivalent: imported.rollbackEquivalent,
+        importedPointPathCovered: imported.pointPathFound && imported.pointPathHash.length > 0,
+        layered3DStackedOverlapCovered: layered.stackedOverlapAccepted,
+        layered3DSameLayerOverlapRejected: layered.sameLayerOverlapRejected,
+        layered3DLookupDisambiguated: layered.layerDisambiguationStable,
+        layered3DOffMeshTraversalCovered: layered.verticalOffMeshTraversals > 0,
+        layered3DRollbackEquivalent: layered.rollbackEquivalent,
+    }, withFrameMetrics({
+        ...metrics,
+        importedNavmeshHash: imported.importedHash,
+        importedNavmeshPermutedHash: imported.permutedHash,
+        importedNavmeshImportOrderStable: imported.importOrderStable,
+        importedNavmeshPortalCount: imported.portalCount,
+        importedNavmeshSpawnMarkerCount: imported.spawnMarkerCount,
+        importedNavmeshMissingRegionRejected: imported.missingRegionRejected,
+        importedNavmeshMissingLinkRejected: imported.missingLinkRejected,
+        importedNavmeshMissingSpawnRejected: imported.missingSpawnRejected,
+        importedNavmeshOffMeshEnterEvents: imported.offMeshEnterEvents,
+        importedNavmeshOffMeshTraverseEvents: imported.offMeshTraverseEvents,
+        importedNavmeshOffMeshExitEvents: imported.offMeshExitEvents,
+        importedNavmeshOffMeshCompleteEvents: imported.offMeshCompleteEvents,
+        importedNavmeshOffMeshCommandIdStable: imported.offMeshCommandIdStable,
+        importedNavmeshOffMeshTraversalFrames: imported.offMeshTraversalFrames,
+        importedNavmeshPointPathFound: imported.pointPathFound,
+        importedNavmeshPointPathHash: imported.pointPathHash,
+        importedNavmeshRollbackEquivalent: imported.rollbackEquivalent,
+        layeredNavmeshHash: layered.cookedHash,
+        layeredNavmeshPermutedHash: layered.permutedHash,
+        layeredNavmeshCookOrderStable: layered.cookOrderStable,
+        layeredNavmeshLowerLookupId: layered.lowerLookupId,
+        layeredNavmeshUpperLookupId: layered.upperLookupId,
+        layeredNavmeshLowerPathHash: layered.lowerPathHash,
+        layeredNavmeshUpperPathHash: layered.upperPathHash,
+        layeredNavmeshVerticalOffMeshTraversals: layered.verticalOffMeshTraversals,
+        layeredNavmeshUpperAgentZ: layered.upperAgentZ,
+        layeredNavmeshRollbackEquivalent: layered.rollbackEquivalent,
+        velocityObstacleChecksum: velocityObstacle.checksum,
+        velocityObstacleRestoredChecksum: velocityObstacle.restoredChecksum,
+        velocityObstacleRollbackEquivalent: velocityObstacle.rollbackEquivalent,
+        velocityObstacleSpeedReduction: velocityObstacle.movingObstacleSpeedReduction,
+        velocityObstacleFuturePrediction: velocityObstacle.predictedFuturePositionAvoided,
+        velocityObstacleAuthoredSpeedRestored: velocityObstacle.authoredSpeedRestored,
+        velocityObstacleOrderStable: velocityObstacle.obstacleOrderStable,
+        velocityObstacleValidationRejected: velocityObstacle.obstacleValidationRejected,
+        velocityObstacleFixtureCorrections: velocityObstacle.velocityObstacleAvoidanceCorrections,
+        velocityObstacleFixtureSpeedReductions: velocityObstacle.avoidanceSpeedReductions,
+    }, requestedFrames, metrics.frames));
+}
+function botCategory(players, requestedFrames, executedFrames) {
+    const metrics = runDeterministicBotDocumentFixture(players, executedFrames);
+    return categoryReport('bot-documents', metrics.checksum, {
+        compiledAssetExists: metrics.compiledAssetHash.length > 0,
+        botReplacementSlotsPresent: metrics.botReplacementSlots >= Math.floor(players / 2),
+        debugTracePresent: metrics.debugTraceCount > 0,
+        executedRequestedFrames: metrics.frames === requestedFrames,
+        behaviorDecoratorsCovered: metrics.behaviorDecoratorTicks > 0,
+        behaviorRunningCovered: metrics.behaviorRunningTicks > 0,
+        behaviorResumeCovered: metrics.behaviorResumeTicks > 0,
+        behaviorServicesCovered: metrics.behaviorServiceTicks > 0,
+        utilityCurvesCovered: metrics.utilityCurveSelections > 0,
+        utilityNestedCovered: metrics.utilityNestedSelections > 0,
+        utilityMomentumCovered: metrics.utilityMomentumSelections > 0,
+        utilityCooldownCovered: metrics.utilityCooldownSuppressions > 0,
+    }, withFrameMetrics(metrics, requestedFrames, metrics.frames));
+}
+function animationCategory(requestedFrames, executedFrames) {
+    const metrics = runDeterministicAnimationFixture(executedFrames);
+    return categoryReport('animation', metrics.checksum, {
+        rollbackEquivalent: metrics.rollbackEquivalent,
+        animationEventsEmitted: metrics.emittedEvents > 0,
+        cookedAssetExists: metrics.cookedAssetHash.length > 0,
+        executedRequestedFrames: executedFrames === requestedFrames,
+        exitFramesCovered: metrics.exitFrameTransitions > 0,
+        transitionBlendCovered: metrics.transitionBlendFrames > 0,
+        triggerLatchCovered: metrics.triggerLatchCount > 0,
+        normalizedClipTimeCovered: metrics.normalizedTimeHash.length > 0,
+        sampledPoseCovered: metrics.poseHash.length > 0,
+        blendWeightCovered: metrics.blendWeightHash.length > 0,
+        blendTreeCovered: metrics.blendTreeFrames > 0,
+        animationLayersCovered: metrics.layerPoseFrames > 0,
+        rootMotionCovered: metrics.rootMotionFrames > 0,
+        eventReconstructionCovered: metrics.reconstructedEvents > 0 && metrics.reconstructedEventHash.length > 0,
+    }, withFrameMetrics({ ...metrics, frames: executedFrames }, requestedFrames, executedFrames));
+}
+function configCategory() {
+    const metrics = runDeterministicConfigBundleFixture();
+    return categoryReport('config-bundle', metrics.configHash, {
+        verifies: metrics.result === 'pass',
+        prototypesMaterialize: metrics.materializedEntityCount > 0,
+        migrationsCovered: metrics.migrationResult === 'migrated',
+    }, withFrameMetrics({
+        assetDbHash: metrics.assetDbHash,
+        prototypeCount: metrics.prototypeCount,
+        materializedEntityCount: metrics.materializedEntityCount,
+        migrationResult: metrics.migrationResult,
+    }, 1, 1));
+}
+function authorityCategory(players, requestedFrames, executedFrames, seed) {
+    const metrics = runDeterministicLocalAuthorityFixture(players, executedFrames, seed);
+    const wire = runDeterministicLocalAuthorityWireFixture(players, Math.min(executedFrames, 512), seed + 31);
+    const multiclient = runDeterministicMulticlientAuthorityFixture(players, Math.min(executedFrames, 5_000), seed + 47);
+    const policy = runDeterministicLocalAuthorityRuntimePolicyFixture();
+    const offlineUpgrade = runDeterministicOfflineToAuthorityUpgradeFixture(players, Math.min(executedFrames, 5_000), seed + 59);
+    const replayMinimizer = runDeterministicLocalAuthorityReplayMinimizerFixture(players, Math.min(executedFrames, 1_000), seed + 67);
+    return categoryReport('local-authority', defaultChecksum({
+        authority: metrics.authorityChecksum,
+        wire: wire.checksum,
+        multiclient: multiclient.checksum,
+        policy: policy.checksum,
+        offlineUpgrade: offlineUpgrade.checksum,
+        replayMinimizer: replayMinimizer.checksum,
+    }), {
+        convergence: metrics.convergence,
+        projectedChecksumsMatch: metrics.authorityProjectionChecksum === metrics.clientProjectionChecksum,
+        reconnectsCovered: metrics.reconnects > 0,
+        lateJoinReconstructionCovered: metrics.lateJoins > 0 && metrics.lateJoinReconstructions === metrics.lateJoins && metrics.absentBeforeJoinInputs > 0,
+        spectatorReconstructionCovered: metrics.spectators > 0 && metrics.spectatorReconstructions === metrics.spectators,
+        hostileMessagesRejected: metrics.rejectedMessages > 0,
+        migrationCovered: metrics.migrationFrame > 0,
+        migrationPersistenceCovered: metrics.migrationPersistedSections >= 5 && metrics.migrationQueueRestored && metrics.migrationCommandTimelineRestored && metrics.slotReservationsRestored,
+        typedWireProtocolCovered: wire.encodedEnvelopes > 0 && wire.decodedEnvelopes === wire.encodedEnvelopes,
+        wireAckCorrectionSnapshotCovered: wire.ackEnvelopes > 0 && wire.correctionEnvelopes > 0 && wire.snapshotEnvelopes > 0 && wire.correctionsApplied > 0 && wire.snapshotsApplied > 0,
+        wireCommandBundleCovered: wire.commandEnvelopes > 0 && wire.acceptedCommands > 0,
+        wireCommandBundleRejectedHostile: wire.rejectedCommands > 0,
+        wireSnapshotNegotiationCovered: wire.snapshotRequestEnvelopes > 0
+            && wire.snapshotOfferEnvelopes > 0
+            && wire.snapshotChunkEnvelopes > 0
+            && wire.snapshotCompleteEnvelopes > 0
+            && wire.snapshotNegotiationCompletesApplied > 0,
+        wireSnapshotNegotiationRejectedHostile: wire.snapshotDescriptorMismatchRejected > 0
+            && wire.snapshotChunkChecksumRejected > 0
+            && wire.snapshotMissingChunkRejected > 0
+            && wire.staleSnapshotOfferRejected > 0,
+        wireHostileRejectionCovered: wire.malformedRejected >= 3 && wire.forgedSlotRejected > 0 && wire.staleFrameRejected > 0 && wire.futureFrameRejected > 0 && wire.oversizedRejected > 0 && wire.invalidInputIdRejected > 0,
+        wireDuplicateReplayRejected: wire.duplicateInputRejected > 0,
+        wireSequenceStatefulRejectionCovered: wire.reorderedSequenceAccepted > 0 && wire.duplicateSequenceRejected > 0 && wire.replayedEnvelopeRejected > 0,
+        wireStaleControlRejectionCovered: wire.staleAckRejected > 0 && wire.staleCorrectionRejected > 0 && wire.staleSnapshotRejected > 0,
+        wireSenderAuthCovered: wire.wireAuthSignedEnvelopes > 0,
+        wireSenderAuthRejectedHostile: wire.wireAuthMissingRejected > 0
+            && wire.wireAuthSenderMismatchRejected > 0
+            && wire.wireAuthSignatureRejected > 0,
+        wireSenderAuthHmacSha256Covered: wire.wireAuthHmacSha256Covered,
+        wireAuthorityAuthRejectedHostile: wire.forgedAuthorityCorrectionRejected > 0 && wire.forgedAuthoritySnapshotRejected > 0,
+        wireSnapshotIdentityRequired: wire.snapshotIdentityRequiredRejected > 0,
+        multiclientPredictedRunnersCovered: multiclient.predictedClientRunners === players,
+        multiclientAuthoritySnapshotsCovered: multiclient.authoritySnapshotsDelivered >= players * multiclient.frames,
+        multiclientCorrectionsCovered: multiclient.correctionsApplied > 0 && multiclient.predictionMismatches > 0,
+        multiclientRollbackResimulationCovered: multiclient.resimulatedFrames > 0 && multiclient.rollbackDepthP95 > 0,
+        multiclientConvergenceCovered: multiclient.convergence && multiclient.allClientsReachedFinalAuthorityFrame,
+        multiclientRuntimeBackedClientsCovered: multiclient.runtimeBackedClients === players,
+        multiclientRuntimeBackedReplayVerified: multiclient.runtimeBackedReplayVerifiedClients === players && multiclient.runtimeBackedConvergence,
+        multiclientRuntimeBackedCorrectionsCovered: multiclient.runtimeBackedCorrectionsApplied > 0 && multiclient.runtimeBackedPredictionMismatches > 0,
+        multiclientRuntimeBackedResimulationCovered: multiclient.runtimeBackedResimulatedFrames > 0,
+        rollbackWindowLateInputAccepted: policy.lateWithinRollbackWindowAccepted,
+        rollbackWindowExpiredInputRejected: policy.expiredLateInputRejected,
+        strictStaleInputRejected: policy.strictStaleInputRejected,
+        structuredAuthorityInputDataPreserved: policy.structuredInputDataPreserved,
+        malformedStructuredAuthorityInputRejected: policy.malformedStructuredInputRejected,
+        authorityPolicyRollbackEquivalent: policy.rollbackEquivalent,
+        nonCommutativeLateInputResimulated: policy.nonCommutativeLateInputResimulated,
+        nonCommutativeAppendOnlyDiverged: policy.nonCommutativeAppendOnlyDiverged,
+        offlineSessionUpgradeStateMatch: offlineUpgrade.stateMatch,
+        offlineSessionUpgradeReplayVerified: offlineUpgrade.replayVerified,
+        offlineSessionUpgradeRestoreVerified: offlineUpgrade.restoreVerified,
+        offlineSessionUpgradeAuthorityConverged: offlineUpgrade.authorityConvergence,
+        offlineSessionUpgradeInputTranscriptCovered: offlineUpgrade.inputRows === offlineUpgrade.players * offlineUpgrade.frames,
+        authorityReplayBundleVerified: replayMinimizer.validReplayVerified,
+        authorityReplayDesyncDetected: replayMinimizer.corruptedReplayFailed && replayMinimizer.mismatchFrame > 0,
+        authorityReplayMinimizedArtifactVerified: replayMinimizer.minimizedReplayFailed
+            && replayMinimizer.minimizedMismatchFrame === replayMinimizer.mismatchFrame,
+        authorityReplayMinimizedArtifactReduced: replayMinimizer.minimizedReplayBytes < replayMinimizer.originalReplayBytes,
+        authorityReplayMinimizedArtifactPruned: replayMinimizer.removedInputFrames > 0
+            && replayMinimizer.removedSnapshots > 0
+            && replayMinimizer.removedChecksumFrames > 0,
+    }, withFrameMetrics({
+        authorityChecksum: metrics.authorityChecksum,
+        clientChecksum: metrics.clientChecksum,
+        authorityProjectionChecksum: metrics.authorityProjectionChecksum,
+        clientProjectionChecksum: metrics.clientProjectionChecksum,
+        convergence: metrics.convergence,
+        players: metrics.players,
+        frames: metrics.frames,
+        reconnects: metrics.reconnects,
+        lateJoins: metrics.lateJoins,
+        spectators: metrics.spectators,
+        absentBeforeJoinInputs: metrics.absentBeforeJoinInputs,
+        lateJoinReconstructions: metrics.lateJoinReconstructions,
+        spectatorReconstructions: metrics.spectatorReconstructions,
+        rejectedMessages: metrics.rejectedMessages,
+        migrationFrame: metrics.migrationFrame,
+        migrationPersistedSections: metrics.migrationPersistedSections,
+        migrationQueueRestored: metrics.migrationQueueRestored,
+        migrationCommandTimelineRestored: metrics.migrationCommandTimelineRestored,
+        slotReservationsRestored: metrics.slotReservationsRestored,
+        inputDelayP95: metrics.inputDelayP95,
+        rollbackDepthP95: metrics.rollbackDepthP95,
+        clockDriftP95: metrics.clockDriftP95,
+        p95FrameCost: metrics.p95FrameCost,
+        p99FrameCost: metrics.p99FrameCost,
+        wireChecksum: wire.checksum,
+        wireFrames: wire.frames,
+        wireEncodedEnvelopes: wire.encodedEnvelopes,
+        wireDecodedEnvelopes: wire.decodedEnvelopes,
+        wireAcceptedInputs: wire.acceptedInputs,
+        wireRejectedInputs: wire.rejectedInputs,
+        wireCommandEnvelopes: wire.commandEnvelopes,
+        wireAcceptedCommands: wire.acceptedCommands,
+        wireRejectedCommands: wire.rejectedCommands,
+        wireSnapshotRequestEnvelopes: wire.snapshotRequestEnvelopes,
+        wireSnapshotOfferEnvelopes: wire.snapshotOfferEnvelopes,
+        wireSnapshotChunkEnvelopes: wire.snapshotChunkEnvelopes,
+        wireSnapshotCompleteEnvelopes: wire.snapshotCompleteEnvelopes,
+        wireSnapshotNegotiationCompletesApplied: wire.snapshotNegotiationCompletesApplied,
+        wireSnapshotNegotiationRejected: wire.snapshotNegotiationRejected,
+        wireSnapshotDescriptorMismatchRejected: wire.snapshotDescriptorMismatchRejected,
+        wireSnapshotChunkChecksumRejected: wire.snapshotChunkChecksumRejected,
+        wireSnapshotMissingChunkRejected: wire.snapshotMissingChunkRejected,
+        wireStaleSnapshotOfferRejected: wire.staleSnapshotOfferRejected,
+        wireMalformedRejected: wire.malformedRejected,
+        wireForgedSlotRejected: wire.forgedSlotRejected,
+        wireStaleFrameRejected: wire.staleFrameRejected,
+        wireFutureFrameRejected: wire.futureFrameRejected,
+        wireOversizedRejected: wire.oversizedRejected,
+        wireDuplicateInputRejected: wire.duplicateInputRejected,
+        wireInvalidInputIdRejected: wire.invalidInputIdRejected,
+        wireAckEnvelopes: wire.ackEnvelopes,
+        wireCorrectionEnvelopes: wire.correctionEnvelopes,
+        wireSnapshotEnvelopes: wire.snapshotEnvelopes,
+        wireReorderedSequenceAccepted: wire.reorderedSequenceAccepted,
+        wireDuplicateSequenceRejected: wire.duplicateSequenceRejected,
+        wireReplayedEnvelopeRejected: wire.replayedEnvelopeRejected,
+        wireStaleAckRejected: wire.staleAckRejected,
+        wireStaleCorrectionRejected: wire.staleCorrectionRejected,
+        wireStaleSnapshotRejected: wire.staleSnapshotRejected,
+        wireAuthSignedEnvelopes: wire.wireAuthSignedEnvelopes,
+        wireAuthMissingRejected: wire.wireAuthMissingRejected,
+        wireAuthSenderMismatchRejected: wire.wireAuthSenderMismatchRejected,
+        wireAuthSignatureRejected: wire.wireAuthSignatureRejected,
+        wireAuthHmacSha256Covered: wire.wireAuthHmacSha256Covered,
+        wireForgedAuthorityCorrectionRejected: wire.forgedAuthorityCorrectionRejected,
+        wireForgedAuthoritySnapshotRejected: wire.forgedAuthoritySnapshotRejected,
+        wireSnapshotIdentityRequiredRejected: wire.snapshotIdentityRequiredRejected,
+        wireCorrectionsApplied: wire.correctionsApplied,
+        wireSnapshotsApplied: wire.snapshotsApplied,
+        multiclientChecksum: multiclient.checksum,
+        multiclientFrames: multiclient.frames,
+        multiclientPredictedClientRunners: multiclient.predictedClientRunners,
+        multiclientAuthoritySnapshotsDelivered: multiclient.authoritySnapshotsDelivered,
+        multiclientPredictionMismatches: multiclient.predictionMismatches,
+        multiclientCorrectionsApplied: multiclient.correctionsApplied,
+        multiclientResimulatedFrames: multiclient.resimulatedFrames,
+        multiclientConvergedSnapshots: multiclient.convergedSnapshots,
+        multiclientRollbackDepthP95: multiclient.rollbackDepthP95,
+        multiclientRollbackDepthMax: multiclient.rollbackDepthMax,
+        multiclientConvergence: multiclient.convergence,
+        multiclientAllClientsReachedFinalAuthorityFrame: multiclient.allClientsReachedFinalAuthorityFrame,
+        multiclientP95FrameCost: multiclient.p95FrameCost,
+        multiclientP99FrameCost: multiclient.p99FrameCost,
+        multiclientRuntimeBackedClients: multiclient.runtimeBackedClients,
+        multiclientRuntimeBackedFrames: multiclient.runtimeBackedFrames,
+        multiclientRuntimeBackedAuthoritySnapshots: multiclient.runtimeBackedAuthoritySnapshots,
+        multiclientRuntimeBackedPredictionMismatches: multiclient.runtimeBackedPredictionMismatches,
+        multiclientRuntimeBackedCorrectionsApplied: multiclient.runtimeBackedCorrectionsApplied,
+        multiclientRuntimeBackedResimulatedFrames: multiclient.runtimeBackedResimulatedFrames,
+        multiclientRuntimeBackedReplayVerifiedClients: multiclient.runtimeBackedReplayVerifiedClients,
+        multiclientRuntimeBackedAuthorityChecksum: multiclient.runtimeBackedAuthorityChecksum,
+        multiclientRuntimeBackedClientChecksum: multiclient.runtimeBackedClientChecksum,
+        multiclientRuntimeBackedConvergence: multiclient.runtimeBackedConvergence,
+        authorityPolicyChecksum: policy.checksum,
+        authorityPolicyRestoredChecksum: policy.restoredChecksum,
+        authorityPolicyRollbackEquivalent: policy.rollbackEquivalent,
+        authorityPolicyRollbackWindowFrames: policy.rollbackWindowFrames,
+        authorityPolicyStructuredInputChecksum: policy.structuredInputChecksum,
+        authorityPolicyValueAfterLateInput: policy.authorityValueAfterLateInput,
+        authorityPolicyClientProjectionValueAfterLateInput: policy.clientProjectionValueAfterLateInput,
+        nonCommutativeRuntimeChecksum: policy.nonCommutativeRuntimeChecksum,
+        nonCommutativeFullReplayChecksum: policy.nonCommutativeFullReplayChecksum,
+        nonCommutativeAppendOnlyChecksum: policy.nonCommutativeAppendOnlyChecksum,
+        nonCommutativeResimulatedFrames: policy.nonCommutativeResimulatedFrames,
+        offlineUpgradeChecksum: offlineUpgrade.checksum,
+        offlineUpgradePlayers: offlineUpgrade.players,
+        offlineUpgradeFrames: offlineUpgrade.frames,
+        offlineUpgradeOfflineFrame: offlineUpgrade.offlineFrame,
+        offlineUpgradeAuthorityFrame: offlineUpgrade.authorityFrame,
+        offlineUpgradeOfflineChecksum: offlineUpgrade.offlineChecksum,
+        offlineUpgradeAuthorityChecksum: offlineUpgrade.authorityChecksum,
+        offlineUpgradeAuthorityRestoredChecksum: offlineUpgrade.authorityRestoredChecksum,
+        offlineUpgradeReplayChecksum: offlineUpgrade.replayChecksum,
+        offlineUpgradeStateMatch: offlineUpgrade.stateMatch,
+        offlineUpgradeReplayVerified: offlineUpgrade.replayVerified,
+        offlineUpgradeRestoreVerified: offlineUpgrade.restoreVerified,
+        offlineUpgradeAuthorityConvergence: offlineUpgrade.authorityConvergence,
+        offlineUpgradeInputRows: offlineUpgrade.inputRows,
+        offlineUpgradeSnapshotFrame: offlineUpgrade.snapshotFrame,
+        authorityReplayMinimizerChecksum: replayMinimizer.checksum,
+        authorityReplayMinimizerPlayers: replayMinimizer.players,
+        authorityReplayMinimizerFrames: replayMinimizer.frames,
+        authorityReplayValidVerified: replayMinimizer.validReplayVerified,
+        authorityReplayCorruptedFailed: replayMinimizer.corruptedReplayFailed,
+        authorityReplayMinimizedFailed: replayMinimizer.minimizedReplayFailed,
+        authorityReplayMismatchFrame: replayMinimizer.mismatchFrame,
+        authorityReplayMinimizedMismatchFrame: replayMinimizer.minimizedMismatchFrame,
+        authorityReplayOriginalBytes: replayMinimizer.originalReplayBytes,
+        authorityReplayMinimizedBytes: replayMinimizer.minimizedReplayBytes,
+        authorityReplayRemovedInputFrames: replayMinimizer.removedInputFrames,
+        authorityReplayRemovedSnapshots: replayMinimizer.removedSnapshots,
+        authorityReplayRemovedChecksumFrames: replayMinimizer.removedChecksumFrames,
+        authorityReplayDebugEvents: replayMinimizer.debugEvents,
+    }, requestedFrames, metrics.frames));
+}
+function deterministicSessionCategory(players, requestedFrames, executedFrames, seed) {
+    const metrics = runDeterministicSessionCoreFixture(players, executedFrames, seed);
+    const structured = runDeterministicStructuredSessionInputFixture();
+    const authority = runDeterministicSessionAuthorityFixture(players, Math.min(executedFrames, 5_000), seed + 11);
+    const rollbackHistory = runDeterministicRollbackHistoryFixture(Math.min(executedFrames, 5_000), 64, seed);
+    const lifecycleProtocol = runDeterministicSessionLifecycleProtocolFixture();
+    return categoryReport('deterministic-session', defaultChecksum({
+        core: metrics.checksum,
+        structured: structured.checksum,
+        authority: authority.checksum,
+        rollbackHistory: rollbackHistory.checksum,
+        lifecycleProtocol: lifecycleProtocol.checksum,
+    }), {
+        verifiedPredictedFrameRingCovered: metrics.frameRingExposed && metrics.predictedPreviousAvailable,
+        partialConfirmationDoesNotAdvanceVerified: metrics.partialConfirmationHeldVerifiedFrame,
+        inputFlagsCovered: metrics.repeatableInputs > 0
+            && metrics.playerNotPresentInputs > 0
+            && metrics.serverReplacedInputs > 0
+            && metrics.commandFlagInputs > 0,
+        playerLifecycleCovered: metrics.addPlayerAccepted > 0
+            && metrics.removePlayerAccepted > 0
+            && metrics.duplicateAddRejected > 0
+            && metrics.removedSlotInputRejected > 0,
+        correctionSemanticsCovered: metrics.correctionCount > 0 && metrics.staleCorrectionsRejected > 0,
+        replacementInputsCovered: metrics.replacementInputs > 0,
+        fullRuntimeReplayVerified: metrics.fullRuntimeReplayExecuted && metrics.replayVerified,
+        firstClassCommandsCovered: metrics.predictedCommands > 0
+            && metrics.confirmedCommands > 0
+            && metrics.commandSystemPolls > 0,
+        commandReplayVerified: metrics.commandReplayVerified,
+        structuredInputReplayVerified: structured.replayVerified,
+        structuredInputPredictionPreserved: structured.predictedFallbackPreservedData,
+        structuredInputPayloadRejected: structured.rejectedNondeterministicPayload,
+        structuredInputSchemaRejected: structured.rejectedSchemaPayloads >= 3,
+        sessionAuthorityRuntimeBacked: authority.authorityFrame === authority.frames
+            && authority.predictedFrame === authority.frames
+            && authority.convergence
+            && authority.replayVerified,
+        sessionAuthorityLifecycleCovered: authority.reconnects > 0
+            && authority.lateJoins > 0
+            && authority.spectators > 0
+            && authority.lateJoinReconstructed
+            && authority.spectatorReconstructed,
+        sessionAuthorityPredictionCovered: authority.predictedInputs > 0
+            && authority.confirmedInputs > 0
+            && authority.replacementInputs > 0
+            && authority.correctionApplied,
+        sessionAuthorityCommandsCovered: authority.predictedCommands > 0 && authority.confirmedCommands > 0,
+        lifecycleProtocolStarted: lifecycleProtocol.startRequests > 0 && lifecycleProtocol.simulationStarts > 0,
+        lifecycleProtocolAddPlayerCovered: lifecycleProtocol.spectatorJoinsAccepted > 0
+            && lifecycleProtocol.addPlayerAccepted > 0
+            && lifecycleProtocol.addPlayerFailed > 0
+            && lifecycleProtocol.duplicateAddRejected > 0,
+        lifecycleProtocolSpectatorRejected: lifecycleProtocol.spectatorInputRejected > 0
+            && lifecycleProtocol.spectatorCommandRejected > 0,
+        lifecycleProtocolReconnectTtlCovered: lifecycleProtocol.sameActorReconnectAccepted > 0
+            && lifecycleProtocol.differentActorReconnectRejected > 0
+            && lifecycleProtocol.expiredReconnectRejected > 0,
+        lifecycleProtocolReplayVerified: lifecycleProtocol.replayVerified,
+        boundedRollbackHistoryCovered: rollbackHistory.convergence
+            && rollbackHistory.rollbackDepthBounded
+            && rollbackHistory.resimulatedFrames > 0,
+        boundedRollbackEvictionRejected: rollbackHistory.evictedRestoreRejected,
+        boundedRollbackMalformedSnapshotRejected: rollbackHistory.malformedRestoreRejected,
+        boundedRollbackDuplicateRejected: rollbackHistory.duplicateRejected,
+        boundedRollbackOrderStable: rollbackHistory.orderStable,
+        playersCovered: metrics.players === players,
+        executedRequestedFrames: metrics.frames === executedFrames,
+    }, withFrameMetrics({
+        players: metrics.players,
+        frames: metrics.frames,
+        verifiedFrame: metrics.verifiedFrame,
+        predictedFrame: metrics.predictedFrame,
+        verifiedChecksum: metrics.verifiedChecksum,
+        predictedChecksum: metrics.predictedChecksum,
+        replayChecksum: metrics.replayChecksum,
+        replayVerified: metrics.replayVerified,
+        correctionCount: metrics.correctionCount,
+        staleCorrectionsRejected: metrics.staleCorrectionsRejected,
+        replacementInputs: metrics.replacementInputs,
+        repeatableInputs: metrics.repeatableInputs,
+        playerNotPresentInputs: metrics.playerNotPresentInputs,
+        serverReplacedInputs: metrics.serverReplacedInputs,
+        commandFlagInputs: metrics.commandFlagInputs,
+        predictedCommands: metrics.predictedCommands,
+        confirmedCommands: metrics.confirmedCommands,
+        rejectedCommands: metrics.rejectedCommands,
+        commandReplayVerified: metrics.commandReplayVerified,
+        commandSystemPolls: metrics.commandSystemPolls,
+        lifecycleEvents: metrics.lifecycleEvents,
+        addPlayerAccepted: metrics.addPlayerAccepted,
+        removePlayerAccepted: metrics.removePlayerAccepted,
+        duplicateAddRejected: metrics.duplicateAddRejected,
+        removedSlotInputRejected: metrics.removedSlotInputRejected,
+        fullRuntimeReplayExecuted: metrics.fullRuntimeReplayExecuted,
+        structuredInputChecksum: structured.checksum,
+        structuredInputReplayVerified: structured.replayVerified,
+        structuredInputPredictionPreserved: structured.predictedFallbackPreservedData,
+        structuredInputPayloadRejected: structured.rejectedNondeterministicPayload,
+        structuredInputSchemaRejected: structured.rejectedSchemaPayloads,
+        structuredInputs: structured.structuredInputs,
+        structuredAxisTotal: structured.axisTotal,
+        structuredFireTotal: structured.fireTotal,
+        sessionAuthorityChecksum: authority.checksum,
+        sessionAuthorityFrame: authority.authorityFrame,
+        sessionAuthorityPredictedFrame: authority.predictedFrame,
+        sessionAuthorityConvergence: authority.convergence,
+        sessionAuthorityReplayVerified: authority.replayVerified,
+        sessionAuthorityPredictedInputs: authority.predictedInputs,
+        sessionAuthorityConfirmedInputs: authority.confirmedInputs,
+        sessionAuthorityReplacementInputs: authority.replacementInputs,
+        sessionAuthorityPredictedCommands: authority.predictedCommands,
+        sessionAuthorityConfirmedCommands: authority.confirmedCommands,
+        sessionAuthorityReconnects: authority.reconnects,
+        sessionAuthorityLateJoins: authority.lateJoins,
+        sessionAuthoritySpectators: authority.spectators,
+        sessionAuthorityRejectedMessages: authority.rejectedMessages,
+        sessionAuthorityCorrectionApplied: authority.correctionApplied,
+        sessionAuthorityLateJoinReconstructed: authority.lateJoinReconstructed,
+        sessionAuthoritySpectatorReconstructed: authority.spectatorReconstructed,
+        sessionAuthorityInputDelayP95: authority.inputDelayP95,
+        sessionAuthorityRollbackDepthP95: authority.rollbackDepthP95,
+        lifecycleProtocolChecksum: lifecycleProtocol.checksum,
+        lifecycleProtocolStartRequests: lifecycleProtocol.startRequests,
+        lifecycleProtocolSimulationStarts: lifecycleProtocol.simulationStarts,
+        lifecycleProtocolSpectatorJoinsAccepted: lifecycleProtocol.spectatorJoinsAccepted,
+        lifecycleProtocolAddPlayerAccepted: lifecycleProtocol.addPlayerAccepted,
+        lifecycleProtocolAddPlayerFailed: lifecycleProtocol.addPlayerFailed,
+        lifecycleProtocolDuplicateAddRejected: lifecycleProtocol.duplicateAddRejected,
+        lifecycleProtocolSpectatorInputRejected: lifecycleProtocol.spectatorInputRejected,
+        lifecycleProtocolSpectatorCommandRejected: lifecycleProtocol.spectatorCommandRejected,
+        lifecycleProtocolSameActorReconnectAccepted: lifecycleProtocol.sameActorReconnectAccepted,
+        lifecycleProtocolDifferentActorReconnectRejected: lifecycleProtocol.differentActorReconnectRejected,
+        lifecycleProtocolExpiredReconnectRejected: lifecycleProtocol.expiredReconnectRejected,
+        lifecycleProtocolRemovePlayerAccepted: lifecycleProtocol.removePlayerAccepted,
+        lifecycleProtocolReplayVerified: lifecycleProtocol.replayVerified,
+        lifecycleProtocolVerifiedFrame: lifecycleProtocol.verifiedFrame,
+        rollbackHistoryChecksum: rollbackHistory.checksum,
+        rollbackHistoryBaselineChecksum: rollbackHistory.baselineChecksum,
+        rollbackHistoryPredictedChecksumBeforeCorrection: rollbackHistory.predictedChecksumBeforeCorrection,
+        rollbackHistoryResimulatedChecksum: rollbackHistory.resimulatedChecksum,
+        rollbackHistoryRestoredHistoryChecksum: rollbackHistory.restoredHistoryChecksum,
+        rollbackHistoryCapacity: rollbackHistory.capacity,
+        rollbackHistoryRecordedFrames: rollbackHistory.recordedFrames,
+        rollbackHistoryEvictedFrames: rollbackHistory.evictedFrames,
+        rollbackHistoryRestoredFrame: rollbackHistory.restoredFrame,
+        rollbackHistoryPredictedToFrame: rollbackHistory.predictedToFrame,
+        rollbackHistoryResimulatedFrames: rollbackHistory.resimulatedFrames,
+        rollbackHistoryConvergence: rollbackHistory.convergence,
+        rollbackHistoryDuplicateRejected: rollbackHistory.duplicateRejected,
+        rollbackHistoryEvictedRestoreRejected: rollbackHistory.evictedRestoreRejected,
+        rollbackHistoryMalformedRestoreRejected: rollbackHistory.malformedRestoreRejected,
+        rollbackHistoryDepthBounded: rollbackHistory.rollbackDepthBounded,
+        rollbackHistoryOrderStable: rollbackHistory.orderStable,
+    }, requestedFrames, metrics.frames));
+}
+function withFrameMetrics(metrics, requestedFrames, executedFrames) {
+    return {
+        ...metrics,
+        requestedFrames,
+        executedFrames,
+        capped: executedFrames < requestedFrames,
+    };
+}
+function updateSimulationHashValue(hash, value) {
+    const mixed = hash ^ (value + 0x9e3779b9);
+    return Math.imul(mixed, 16777619) >>> 0;
+}
+function categoryReport(category, checksum, invariants, metrics) {
+    const failures = stableKeys(invariants)
+        .filter((key) => invariants[key] === false);
+    const { executionProofHash: _ignoredExecutionProofHash, ...baseMetrics } = metrics;
+    const metricsWithIdentity = {
+        ...baseMetrics,
+        proofContract: `${category}@1`,
+        subsystemChecksum: checksum,
+    };
+    const body = {
+        category,
+        result: failures.length === 0 ? 'pass' : 'fail',
+        invariants,
+        metrics: {
+            ...metricsWithIdentity,
+            executionProofHash: engineCompleteExecutionProofHash(category, checksum, metricsWithIdentity),
+        },
+        failures,
+    };
+    return {
+        ...body,
+        checksum: defaultChecksum(body),
+    };
+}
+function subsystemChecksumOf(report) {
+    return String(report.metrics.subsystemChecksum);
+}
+export function engineCompleteExecutionProofHash(category, subsystemChecksum, metrics) {
+    const { executionProofHash: _ignoredExecutionProofHash, wallClockElapsedMs: _elapsed, wallClockMeanFrameMs: _mean, ...stableMetrics } = metrics;
+    return defaultChecksum({
+        category,
+        subsystemChecksum,
+        requestedFrames: stableMetrics.requestedFrames,
+        executedFrames: stableMetrics.executedFrames,
+        capped: stableMetrics.capped,
+        proofContract: stableMetrics.proofContract,
+        metrics: stableMetrics,
+    });
+}
+function stableKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort();
+}
+function engineCompleteNowMs() {
+    return globalThis.performance.now();
+}
+function percentileNumber(values, percentile) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((percentile / 100) * sorted.length) - 1));
+    return sorted[index];
+}
+function roundMetric(value, places) {
+    const scale = 10 ** places;
+    return Math.round(value * scale) / scale;
+}