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

package/dist/engine-parity.js

@@ -0,0 +1,3178 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { performance } from 'node:perf_hooks';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+import { runCertificationSuite } from './certification.js';
+import { runDeterministicCommandTimelineMigrationFixture } from './commands.js';
+import { runDeterministicConfigBundleParityFixture } from './config-bundle.js';
+import { runDeterministicEngineCoreNumericProof } from './engine-core-proof.js';
+import { fixedCircle, fixedVec2, circleIntersects } from './collision.js';
+import { assertAssetManifestMatches, cookDeterministicAssets, materializeDeterministicMapEntities, materializePrototypeEntities, validatePrototypeEntitiesAgainstFrameRuntime, } from './asset-cooking.js';
+import { runDeterministicAnimationFixture } from './animation.js';
+import { explainChaosFixture, runChaosCertificationSuite, } from './chaos-certification.js';
+import { combineDeterministicPhysicsMaterial, cookStaticColliders, detectVerticalCcdHit, } from './deterministic-primitives.js';
+import { createDeterministicEventTimeline } from './events.js';
+import { runDeterministicDslRuntimeFixture } from './engine-runtime.js';
+import { runDeterministicDslBinaryFixture } from './schema-dsl-binary.js';
+import { runDeterministicInputTimelineFixture } from './input-timeline.js';
+import { createDeterministicMath } from './math.js';
+import { runDeterministicBotDocumentFixture } from './bot-documents.js';
+import { runDeterministicBotSimulation } from './bot-primitives.js';
+import { runDeterministicLagCompensation3DApiFixture, runDeterministicLagCompensation3DFixture } from './lag-compensation3d.js';
+import { runDeterministicLocalAuthorityWireFixture } from './local-authority-wire.js';
+import { runDeterministicMovementCrowdSimulation, runDeterministicMovementSimulation } from './movement.js';
+import { runDeterministicKcc3DAdversarialFixture, runDeterministicKcc3DCallbackFilterFixture, runDeterministicKcc3DCrowdFixture, runDeterministicKcc3DFilterForceFixture, runDeterministicKcc3DGeometryFixture, } from './movement3d.js';
+import { createLabSession, applyLabInputs, hydrateLabInput, labDefaultInput, labStep } from './sample-lab.js';
+import { cookDeterministicNavigationGraph, cookTilemapNavigationGraph, createDeterministicFlowField, findDeterministicPath, smoothDeterministicPath, stepDeterministicNavigationAgents, } from './navigation.js';
+import { runDeterministicNavmeshImportTraversalFixture, runDeterministicNavmeshStress, runDeterministicNavmeshVelocityObstacleFixture } from './navmesh.js';
+import { createDeterministicPhysicsWorld2D, circleCastDeterministicPhysics2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastDeterministicPhysics2D, raycastAllDeterministicPhysics2D, stepDeterministicPhysicsWorld2D, } from './physics2d.js';
+import { runPhysicsCert } from './physics-cert.js';
+import { runDeterministicPhysics3DCallbackMaskFixture, runDeterministicPhysics3DDetailFixture, runDeterministicPhysics3DMaterialFixture, runDeterministicPhysics3DQueryOptionsFixture, runDeterministicPhysics3DStackFixture, runDeterministicPhysics3DStress, } from './physics3d.js';
+import { runProtocolRollbackLab } from './protocol-lab.js';
+import { DeterministicRandom } from './random.js';
+import { inspectReplayFrame } from './replay-inspect.js';
+import { verifyReplay } from './replay.js';
+import { createDeterministicReplayBundle, minimizeDeterministicReplayDesyncBundle, verifyDeterministicReplayBundle, } from './replay-bundle.js';
+import { createDeterministicSampleSceneCertificationTrace, deterministicSampleSceneIds, runAllDeterministicSampleScenes, runDeterministicIntegratedHeadlessScene, runDeterministicSampleScene, } from './sample-scenes.js';
+import { generateSchemaTypes } from './schema-codegen.js';
+import { checkSourceText, getDeterminismParserKind } from './tools/static-checker.js';
+const allRequiredCategories = [
+    'runtime-rollback',
+    'fixed-numeric',
+    'physics',
+    'movement',
+    'navigation',
+    'asset-cooking',
+    'config-bundle',
+    'protocol',
+    'replay-debugging',
+    'bots',
+    'animation',
+    'sample-scenes',
+    'performance-128',
+    'security-hostile-client',
+    'tooling',
+];
+const fixtureExplanations = {
+    'runtime-rollback': {
+        id: 'runtime-rollback',
+        tier: 'required',
+        validates: ['snapshot restore', 'delayed input rollback equivalence', 'event confirmation/cancel semantics'],
+        cliProof: 'npm run certify:v2 -- --filter runtime-rollback --json <path>',
+        knownLimits: ['uses package lab simulation, not an external engine'],
+    },
+    'fixed-numeric': {
+        id: 'fixed-numeric',
+        tier: 'required',
+        validates: ['fixed math', 'seeded random restore/fork', 'static rejection of host random/time'],
+        cliProof: 'npm run certify:v2 -- --filter fixed-numeric --json <path>',
+        knownLimits: ['does not certify native floating physics engines'],
+    },
+    physics: {
+        id: 'physics',
+        tier: 'required',
+        validates: ['fixed collision rollback', 'stable query ordering', 'CCD helper', 'material combination', '3D angular and mesh static coverage'],
+        cliProof: 'npm run certify:v2 -- --filter physics --json <path>',
+        knownLimits: ['external physics engines and production-grade stacked rigid body solving remain gated behind lab:physics-cert'],
+    },
+    movement: {
+        id: 'movement',
+        tier: 'required',
+        validates: ['3D KCC movement', 'top-down sliding bounds', 'quantized FPS aim origins'],
+        cliProof: 'npm run certify:v2 -- --filter movement --json <path>',
+        knownLimits: ['visual r3f collision import and controller authoring tools are out of CLI scope'],
+    },
+    navigation: {
+        id: 'navigation',
+        tier: 'required',
+        validates: ['cooked graph hashes', 'A* style tie-breaks', 'region toggles', 'dynamic obstacle replans'],
+        cliProof: 'npm run certify:v2 -- --filter navigation --json <path>',
+        knownLimits: ['navmesh-like graph runtime is headless; no visual editor or 3D navmesh baker yet'],
+    },
+    'asset-cooking': {
+        id: 'asset-cooking',
+        tier: 'required',
+        validates: ['byte-identical cooking', 'stable ids/LUTs/hashes', 'prototype materialization', 'fail-closed invalid assets'],
+        cliProof: 'npm run cook:syncplay-assets -- --verify fixtures/assets --json <path>',
+        knownLimits: ['schema is intentionally minimal until a game asset descriptor format is adopted'],
+    },
+    'config-bundle': {
+        id: 'config-bundle',
+        tier: 'required',
+        validates: ['config identity hashes', 'asset DB hash binding', 'migration', 'prototype materialization', 'fail-closed stale/tampered configs'],
+        cliProof: 'npm run certify:v2 -- --filter config-bundle --json <path>',
+        knownLimits: ['headless config/prototype proof only; no visual editor or production content pipeline'],
+    },
+    protocol: {
+        id: 'protocol',
+        tier: 'required',
+        validates: ['input bundles', 'delay/jitter/drop/duplicate/reorder', 'reconnect', 'late join', '128-player convergence'],
+        cliProof: 'npm run certify:v2 -- --filter protocol --json <path>',
+        knownLimits: ['local deterministic network model only'],
+    },
+    'replay-debugging': {
+        id: 'replay-debugging',
+        tier: 'required',
+        validates: ['valid replay verification', 'corrupted replay failure', 'first mismatch', 'slicing', 'tail reconstruction'],
+        cliProof: 'npm run replay:verify -- <replay-or-dir> --json <path>',
+        knownLimits: ['CLI fixture uses lab replay format'],
+    },
+    bots: {
+        id: 'bots',
+        tier: 'required',
+        validates: ['HFSM', 'behavior tree', 'utility selection', 'blackboard ordering', '128 bot replacement'],
+        cliProof: 'npm run certify:v2 -- --filter bots --json <path>',
+        knownLimits: ['headless deterministic bot primitives; no visual bot authoring editor yet'],
+    },
+    animation: {
+        id: 'animation',
+        tier: 'required',
+        validates: ['deterministic clip playback', 'state transitions', 'trigger latching', 'animation events', 'rollback equivalence'],
+        cliProof: 'npm run certify:v2 -- --filter animation --json <path>',
+        knownLimits: ['headless deterministic animation state machine; no R3F view binding in CLI parity'],
+    },
+    'sample-scenes': {
+        id: 'sample-scenes',
+        tier: 'required',
+        validates: ['ten representative multiplayer scene archetypes under deterministic rollback'],
+        cliProof: 'npm run certify:v2 -- --filter sample-scenes --json <path>',
+        knownLimits: ['headless scene models, not R3F scenes'],
+    },
+    'browser-boundary': {
+        id: 'browser-boundary',
+        tier: 'optional-browser',
+        validates: ['browser-safe replay import surface', 'Node/browser checksum parity boundary'],
+        cliProof: 'npm run lab:replay-verify-browser -- <replay> --runtime chromium --json <path>',
+        knownLimits: ['requires Playwright/browser availability for runtime proof'],
+    },
+    'performance-128': {
+        id: 'performance-128',
+        tier: 'required',
+        validates: ['128-player rollback convergence', 'stress checksum reporting', 'diffable benchmark artifacts'],
+        cliProof: 'npm run benchmark:engine-parity -- --profile stress --frames 100000 --json <path>',
+        knownLimits: ['timing thresholds are reported unless --enforce-thresholds is set'],
+    },
+    'security-hostile-client': {
+        id: 'security-hostile-client',
+        tier: 'required',
+        validates: ['malformed/oversized/unauthorized input rejection', 'honest clients stay synchronized'],
+        cliProof: 'npm run certify:v2 -- --filter security-hostile-client --json <path>',
+        knownLimits: ['transport authentication belongs outside this standalone package'],
+    },
+    tooling: {
+        id: 'tooling',
+        tier: 'required',
+        validates: ['static determinism checker', 'stable codegen', 'fixture explainability'],
+        cliProof: 'npm run static:determinism -- --json <path> --junit <path>',
+        knownLimits: ['checker is conservative and should be paired with runtime replay proofs'],
+    },
+    chaos: {
+        id: 'chaos',
+        tier: 'chaos',
+        validates: ['chaos fixture matrix', 'expected failure detection', 'nested per-fixture report artifacts'],
+        cliProof: 'npm run certify:v2 -- --profile chaos --json <path> --junit <path>',
+        knownLimits: ['uses local deterministic transport/rollback models, not Venus or R3F integration'],
+    },
+};
+export function explainEngineParityFixture(id) {
+    const categoryExplanation = fixtureExplanations[id];
+    if (categoryExplanation !== undefined) {
+        return completeEngineParityFixtureExplanation(categoryExplanation);
+    }
+    const chaosExplanation = explainChaosFixture(id);
+    if (chaosExplanation !== undefined) {
+        return chaosFixtureExplanationToEngine(chaosExplanation);
+    }
+    throw new Error(`Unknown engine parity fixture ${id}`);
+}
+export function runEngineParitySuite(options = {}) {
+    const config = normalizeOptions(options);
+    if (config.profile === 'chaos') {
+        return chaosSuiteReport(config, options.filter);
+    }
+    const categoryReports = runSelectedEngineParityCategories(config, options.filter);
+    const failures = categoryReports.flatMap((category) => category.result === 'fail'
+        ? category.failures.map((failure) => `${category.category}: ${failure}`)
+        : []);
+    const withoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        provenance: engineParityProvenance(),
+        profile: config.profile,
+        runtimeTarget: config.runtimeTarget,
+        seed: config.seed,
+        frames: config.frames,
+        players: config.players,
+        enforceThresholds: config.enforceThresholds,
+        categories: categoryReports,
+        failures,
+        summary: {
+            passed: categoryReports.filter((category) => category.result === 'pass').length,
+            failed: categoryReports.filter((category) => category.result === 'fail').length,
+            skipped: categoryReports.filter((category) => category.result === 'skip').length,
+            requiredCategories: filterEngineParityCategoryIds(allRequiredCategories, options.filter),
+            optionalCategories: ['browser-boundary'],
+        },
+        result: failures.length === 0 ? 'pass' : 'fail',
+    };
+    return {
+        ...withoutId,
+        reportId: defaultChecksum(withoutId),
+    };
+}
+function filterEngineParityCategoryIds(categories, filter) {
+    if (filter === undefined || filter.length === 0) {
+        return categories;
+    }
+    return categories.filter((category) => category === filter);
+}
+function runSelectedEngineParityCategories(config, filter) {
+    const runners = {
+        'runtime-rollback': () => runRuntimeRollbackCategory(config),
+        'fixed-numeric': () => runFixedNumericCategory(config),
+        physics: () => runPhysicsCategory(config),
+        movement: () => runMovementCategory(config),
+        navigation: () => runNavigationCategory(config),
+        'asset-cooking': () => runAssetCookingCategory(config),
+        'config-bundle': () => runConfigBundleCategory(config),
+        protocol: () => runProtocolCategory(config),
+        'replay-debugging': () => runReplayDebuggingCategory(config),
+        bots: () => runBotCategory(config),
+        animation: () => runAnimationCategory(config),
+        'sample-scenes': () => runSampleSceneCategory(config),
+        'browser-boundary': () => runBrowserBoundaryCategory(config),
+        'performance-128': () => runPerformance128Category(config),
+        'security-hostile-client': () => runSecurityHostileClientCategory(config),
+        tooling: () => runToolingCategory(config),
+    };
+    if (filter !== undefined && filter.length > 0) {
+        const runner = runners[filter];
+        return runner === undefined ? [] : [runner()];
+    }
+    return [
+        runners['runtime-rollback'](),
+        runners['fixed-numeric'](),
+        runners.physics(),
+        runners.movement(),
+        runners.navigation(),
+        runners['asset-cooking'](),
+        runners['config-bundle'](),
+        runners.protocol(),
+        runners['replay-debugging'](),
+        runners.bots(),
+        runners.animation(),
+        runners['sample-scenes'](),
+        runners['browser-boundary'](),
+        runners['performance-128'](),
+        runners['security-hostile-client'](),
+        runners.tooling(),
+    ];
+}
+export function stableEngineParityJson(report) {
+    return `${canonicalStringify(report)}\n`;
+}
+function engineParityPassFail(pass) {
+    const results = ['fail', 'pass'];
+    return results[Number(pass)];
+}
+function stringOrFallback(value, fallback) {
+    const candidates = [fallback, value];
+    return candidates[Number(value !== undefined)];
+}
+function numberOrFallback(value, fallback) {
+    const candidates = [fallback, value];
+    return candidates[Number(value !== undefined)];
+}
+function metricNumberOrFallback(metrics, key, fallback) {
+    const value = metrics?.[key];
+    return typeof value === 'number' ? value : fallback;
+}
+function readonlyArrayOrEmpty(value) {
+    const empty = [];
+    const candidates = [empty, value];
+    return candidates[Number(value !== undefined)];
+}
+function normalizeOptions(options) {
+    const profile = options.profile ?? 'required-smoke';
+    return {
+        profile,
+        runtimeTarget: options.runtimeTarget ?? 'node',
+        seed: options.seed ?? 71,
+        frames: options.frames ?? defaultFrames(profile),
+        players: options.players ?? 128,
+        enforceThresholds: options.enforceThresholds ?? false,
+    };
+}
+function defaultFrames(profile) {
+    if (profile === 'stress') {
+        return 10_000;
+    }
+    if (profile === 'required-full') {
+        return 1_000;
+    }
+    return 180;
+}
+function readSiblingSource(moduleName) {
+    const modulePath = currentModuleFilePath();
+    /* istanbul ignore next -- environment fallback for bundled entrypoints without a stack-resolved module path. */
+    const moduleDirectory = modulePath === undefined ? resolve('.') : dirname(modulePath);
+    const candidates = [
+        resolve(moduleDirectory, `${moduleName}.js`),
+        deterministicPackagePath('src', `${moduleName}.ts`),
+        deterministicPackagePath('src', `${moduleName}.js`),
+        deterministicPackagePath('dist', `${moduleName}.js`),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return readFileSync(candidate, 'utf8');
+        }
+    }
+    /* istanbul ignore next -- fail-closed package-layout fallback, exercised only when neither source nor dist entrypoints exist. */
+    throw new Error(`Unable to inspect ${moduleName} entrypoint`);
+}
+function readOptionalSource(path) {
+    const candidate = resolve(deterministicPackagePath('src'), path);
+    /* istanbul ignore next -- optional sibling package source may be absent in published/package-only layouts. */
+    if (!existsSync(candidate)) {
+        return undefined;
+    }
+    return readFileSync(candidate, 'utf8');
+}
+function readPackageSourceTree() {
+    const sourceRoot = deterministicPackagePath('src');
+    /* istanbul ignore next -- dist fallback is for package consumers without checked-out TypeScript source. */
+    const root = existsSync(sourceRoot) ? sourceRoot : deterministicPackagePath('dist');
+    /* istanbul ignore next -- last-ditch provenance fallback for unusual bundled runtimes without src or dist trees. */
+    if (!existsSync(root)) {
+        const modulePath = currentModuleFilePath();
+        /* istanbul ignore next -- same unusual bundled-runtime fallback as above. */
+        return modulePath === undefined ? '' : readFileSync(modulePath, 'utf8');
+    }
+    const parts = [];
+    for (const file of collectSourceFiles(root)) {
+        parts.push(readFileSync(file, 'utf8'));
+    }
+    return parts.join('\n');
+}
+function stableSourceHash() {
+    return defaultChecksum(readPackageSourceTree());
+}
+function deterministicPackagePath(...parts) {
+    const modulePath = currentModuleFilePath();
+    /* istanbul ignore else -- source-instrumented tests always resolve a module path; fallback handles unusual loaders. */
+    if (modulePath !== undefined) {
+        const moduleDirectory = dirname(modulePath);
+        const moduleRoots = [
+            resolve(moduleDirectory, '..'),
+            resolve(moduleDirectory, '../..'),
+            moduleDirectory,
+        ];
+        for (const moduleRoot of moduleRoots) {
+            /* istanbul ignore else -- supported source/dist layouts all have a package root in the searched ancestry. */
+            if (existsSync(resolve(moduleRoot, 'package.json'))) {
+                return resolve(moduleRoot, ...parts);
+            }
+        }
+    }
+    /* istanbul ignore next -- fallback root calculation is used only when stack path discovery is unavailable. */
+    const directRoot = resolve('.');
+    /* istanbul ignore next -- fallback for direct package cwd execution when stack path discovery is unavailable. */
+    if (existsSync(resolve(directRoot, 'src', 'engine-parity.ts'))) {
+        return resolve(directRoot, ...parts);
+    }
+    /* istanbul ignore next -- sibling fallback root calculation is used only from repo-root package layouts. */
+    const siblingRoot = resolve('..', 'syncplay');
+    /* istanbul ignore next -- fallback for repo-root execution when the deterministic package is a sibling directory. */
+    if (existsSync(resolve(siblingRoot, 'src', 'engine-parity.ts'))) {
+        return resolve(siblingRoot, ...parts);
+    }
+    /* istanbul ignore next -- final path fallback is intentionally fail-later via file reads. */
+    return resolve(directRoot, ...parts);
+}
+function currentModuleFilePath() {
+    /* istanbul ignore next -- V8 always provides a stack in the supported Node coverage runtime. */
+    const stack = new Error().stack ?? '';
+    const match = stack.match(/(?:file:\/\/)?\/[^\s)]+?\.(?:mjs|cjs|js|ts)/);
+    /* istanbul ignore next -- fallback for runtimes that omit file paths from Error.stack. */
+    if (match === null) {
+        return undefined;
+    }
+    const path = match[0];
+    /* istanbul ignore next -- source-instrumented Node stack paths are plain paths; file URLs are a loader compatibility fallback. */
+    return path.startsWith('file://') ? fileURLToPath(path) : path;
+}
+function collectSourceFiles(root) {
+    const entries = readdirSync(root, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const files = [];
+    for (const entry of entries) {
+        const child = resolve(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectSourceFiles(child));
+        }
+        const sourceFileChecks = [
+            () => 0,
+            () => Number(/\.(?:ts|js)$/.test(entry.name)) * Number(statSync(child).isFile()),
+        ];
+        const sourceFilePathCandidates = [[], [child]];
+        const sourceFileIndex = sourceFileChecks[Number(entry.isFile())]();
+        files.push(...sourceFilePathCandidates[sourceFileIndex]);
+    }
+    return files;
+}
+function chaosSuiteReport(config, filter) {
+    const categoryReports = [runChaosCategory(config, filter)];
+    const failures = categoryReports.flatMap((category) => 
+    /* istanbul ignore next -- chaos category fixtures are required to pass; failures are fail-closed report plumbing. */
+    category.result === 'fail'
+        ? category.failures.map((failure) => `${category.category}: ${failure}`)
+        : []);
+    const withoutId = {
+        schemaVersion: 1,
+        reportId: '',
+        provenance: engineParityProvenance(),
+        profile: config.profile,
+        runtimeTarget: config.runtimeTarget,
+        seed: config.seed,
+        frames: config.frames,
+        players: config.players,
+        enforceThresholds: config.enforceThresholds,
+        categories: categoryReports,
+        failures,
+        summary: {
+            passed: categoryReports.filter((category) => category.result === 'pass').length,
+            failed: categoryReports.filter((category) => category.result === 'fail').length,
+            skipped: categoryReports.filter((category) => category.result === 'skip').length,
+            requiredCategories: ['chaos'],
+            optionalCategories: [],
+        },
+        result: engineParityPassFail(failures.length === 0),
+    };
+    return {
+        ...withoutId,
+        reportId: defaultChecksum(withoutId),
+    };
+}
+function runChaosCategory(config, filter) {
+    const chaos = runChaosCertificationSuite({
+        seed: config.seed,
+        frames: config.frames,
+        players: config.players,
+        filter,
+    });
+    const fixtureCategories = [...new Set(chaos.fixtures.map((fixture) => fixture.category))].sort();
+    const expectedFailureFixtures = chaos.fixtures
+        .filter((fixture) => fixture.expectedResult === 'expected-failure')
+        .map((fixture) => fixture.fixtureId);
+    const invariants = {
+        allFixturesPassed: chaos.failed === 0,
+        expectedFailuresCoverageRequired: filter === undefined ? true : 'not-selected',
+        ...(filter === undefined ? { expectedFailuresDetected: expectedFailureFixtures.length > 0 } : {}),
+        nestedFixtureReport: chaos.fixtures.length === chaos.fixtureCount,
+        fixtureChecksumsStable: chaos.fixtures.every((fixture) => fixture.checksum.length > 0),
+    };
+    return categoryReport(config, 'chaos', 'chaos', [
+        'Disconnect/resync chaos',
+        'Hostile protocol rejection',
+        'Rollback boundary failures',
+        'Replay identity mismatches',
+        'Random/tick/asset/physics/movement boundaries',
+        '128-player scale fixture',
+    ], invariants, {
+        fixtureCount: chaos.fixtureCount,
+        passed: chaos.passed,
+        failed: chaos.failed,
+        expectedFailures: chaos.expectedFailures,
+        firstFailingFixtureId: chaos.firstFailingFixtureId,
+        fixtureCategories,
+        fixtures: chaos.fixtures.map(compactChaosFixture),
+    });
+}
+function compactChaosFixture(fixture) {
+    return {
+        schemaVersion: fixture.schemaVersion,
+        suiteId: fixture.suiteId,
+        profile: fixture.profile,
+        fixtureId: fixture.fixtureId,
+        category: fixture.category,
+        expectedResult: fixture.expectedResult,
+        seed: fixture.seed,
+        players: fixture.players,
+        frames: fixture.frames,
+        networkModel: fixture.networkModel,
+        result: fixture.result,
+        checksum: fixture.checksum,
+        checksums: fixture.checksums,
+        rejectionCounts: fixture.rejectionCounts,
+        rollbackResyncMetrics: fixture.rollbackResyncMetrics,
+        artifactPath: fixture.artifactPath,
+        replayArtifactPaths: fixture.replayArtifactPaths,
+        firstFailureDetails: fixture.firstFailureDetails,
+        failures: fixture.failures,
+        invariants: fixture.invariants,
+        metrics: fixture.metrics,
+    };
+}
+function chaosFixtureExplanationToEngine(explanation) {
+    return completeEngineParityFixtureExplanation({
+        id: explanation.id,
+        purpose: `Chaos fixture proof for ${explanation.category}`,
+        tier: 'chaos',
+        category: explanation.category,
+        expectedResult: explanation.expectedResult,
+        validates: explanation.validates,
+        cliProof: `npm run certify:v2 -- --profile chaos --filter ${explanation.category} --json <path>`,
+        knownLimits: ['uses local deterministic transport/rollback models, not Venus or R3F integration'],
+        artifacts: explanation.artifacts,
+        invariants: explanation.invariants,
+    });
+}
+function completeEngineParityFixtureExplanation(explanation) {
+    return {
+        ...explanation,
+        purpose: explanation.purpose ?? `Standalone headless parity proof for ${explanation.id}`,
+        artifacts: explanation.artifacts ?? [explanation.cliProof],
+        invariants: explanation.invariants ?? [
+            'report result is pass',
+            'category failures are empty',
+            ...explanation.validates.map((capability) => `${capability} invariant holds`),
+        ],
+    };
+}
+function cappedProofFrames(config, cap) {
+    return config.profile === 'stress' ? Math.min(config.frames, cap) : config.frames;
+}
+function runRuntimeRollbackCategory(config) {
+    const frames = cappedProofFrames(config, 1_000);
+    const control = runLabWithInputs(config.players, frames, config.seed, -1);
+    const restored = runLabWithInputs(config.players, frames, config.seed, Math.floor(frames / 2));
+    const eventTimeline = createDeterministicEventTimeline();
+    eventTimeline.emitPredicted('spawn.predicted', 2, { slot: 0 }, 'spawn:0');
+    eventTimeline.emitPredicted('hit.predicted', 3, { slot: 1 }, 'hit:1');
+    eventTimeline.confirmThroughFrame(2);
+    eventTimeline.cancelFromFrame(3);
+    eventTimeline.emitVerifiedOnly('score.verified', 4, { slot: 0 }, 'score:0');
+    const records = eventTimeline.records();
+    let boundedHistoryFailure = false;
+    const bounded = createLabSession({ players: 2, seed: config.seed, snapshotBufferSize: 2 });
+    bounded.stepFrames(8);
+    try {
+        bounded.restoreToFrame(1);
+    }
+    catch {
+        boundedHistoryFailure = true;
+    }
+    const divergence = {
+        frame: Math.floor(frames / 2),
+        systemId: 'lab.step',
+        entityId: 'slot:0',
+        componentKey: 'state.x',
+        localChecksum: defaultChecksum({
+            checksum: stringOrFallback(restored.frameChecksums[Math.floor(frames / 2)], restored.checksum),
+            injectedMutation: 'state.x+1',
+        }),
+        remoteChecksum: stringOrFallback(control.frameChecksums[Math.floor(frames / 2)], control.checksum),
+        replaySlicePath: `artifacts/replays/divergence-${config.seed}-${Math.floor(frames / 2)}.json`,
+    };
+    const protectedFrame = deepFreeze({ state: cloneCanonical(control), frame: divergence.frame });
+    let strictFrameMutationRejected = false;
+    try {
+        protectedFrame.state.checksum = 'mutated';
+    }
+    catch {
+        strictFrameMutationRejected = true;
+    }
+    const invariants = {
+        saveRestoreByteStable: control.checksum === restored.checksum,
+        delayedInputRollbackEquivalent: control.checksum === restored.checksum,
+        boundedHistoryFailure,
+        exactOnceConfirmedEvents: records.filter((record) => record.predictionState === 'confirmed').length === 1,
+        rollbackSafePredictedEvents: records.filter((record) => record.predictionState === 'canceled').length === 1,
+        firstDivergenceDiagnostics: divergence.frame > 0
+            && divergence.systemId.length > 0
+            && divergence.entityId.length > 0
+            && divergence.componentKey.length > 0
+            && divergence.localChecksum.length > 0
+            && divergence.remoteChecksum.length > 0
+            && divergence.localChecksum !== divergence.remoteChecksum
+            && divergence.replaySlicePath.endsWith('.json'),
+        strictFrameMutationRejected,
+    };
+    return categoryReport(config, 'runtime-rollback', 'required', [
+        'Rollback',
+        'Prediction/resimulation',
+        'Event callbacks',
+        'Checksum diagnostics',
+    ], invariants, {
+        controlChecksum: control.checksum,
+        restoredChecksum: restored.checksum,
+        checksumFrames: control.frameChecksums.length,
+        eventRecords: records.length,
+        divergence,
+    });
+}
+function runFixedNumericCategory(config) {
+    const math = createDeterministicMath();
+    const rng = new DeterministicRandom(config.seed);
+    const first = rng.nextInt(0, 10_000);
+    const snapshot = rng.snapshot();
+    const second = rng.nextInt(0, 10_000);
+    rng.restore(snapshot);
+    const replayedSecond = rng.nextInt(0, 10_000);
+    const forkA = rng.fork('bots');
+    const forkB = rng.fork('bots');
+    const diagnostics = checkSourceText('engine-parity/fixed-numeric-bad.ts', [
+        'export function step(state: { value: number }): { value: number } {',
+        '  const drift = Math.random() + Date.now() + performance.now();',
+        '  return { value: state.value + drift };',
+        '}',
+    ].join('\n'), 'strict');
+    const fixedVectorChecksum = defaultChecksum({
+        add: math.add(math.toFixed(2), math.toFixed(3)),
+        mul: math.mul(math.toFixed(2), math.toFixed(3)),
+        div: math.div(math.toFixed(9), math.toFixed(3)),
+        circle: circleIntersects(fixedCircle(fixedVec2(10, 10), 5), fixedCircle(fixedVec2(14, 14), 4)),
+    });
+    const extendedMathChecksum = defaultChecksum({
+        saturation: math.saturatingAdd(2_147_483_640, 99),
+        quantized: math.quantize(math.toFixed(12.345), 10),
+        trig: [math.sinTurns(0), math.cosTurns(0), math.sinTurns(250), math.cosTurns(500)],
+        vector: math.vec2Lerp(math.vec2(0, 0), math.vec2(math.toFixed(10), math.toFixed(-10)), 500),
+        quaternion: math.quatLerp(math.quatFromYawTurns(0), math.quatFromYawTurns(500), 500),
+    });
+    const invariants = {
+        fixedMathStable: fixedVectorChecksum === defaultChecksum({
+            add: math.add(math.toFixed(2), math.toFixed(3)),
+            mul: math.mul(math.toFixed(2), math.toFixed(3)),
+            div: math.div(math.toFixed(9), math.toFixed(3)),
+            circle: circleIntersects(fixedCircle(fixedVec2(10, 10), 5), fixedCircle(fixedVec2(14, 14), 4)),
+        }),
+        randomRestoreStable: second === replayedSecond,
+        randomForkStable: forkA.nextInt(0, 999) === forkB.nextInt(0, 999),
+        roundingOverflowSaturation: math.toFixed(9_999_999) === math.maxFixed && math.saturatingAdd(math.maxFixed - 1, 10) === math.maxFixed,
+        trigVectorQuaternionInterpolation: extendedMathChecksum === defaultChecksum({
+            saturation: math.saturatingAdd(2_147_483_640, 99),
+            quantized: math.quantize(math.toFixed(12.345), 10),
+            trig: [math.sinTurns(0), math.cosTurns(0), math.sinTurns(250), math.cosTurns(500)],
+            vector: math.vec2Lerp(math.vec2(0, 0), math.vec2(math.toFixed(10), math.toFixed(-10)), 500),
+            quaternion: math.quatLerp(math.quatFromYawTurns(0), math.quatFromYawTurns(500), 500),
+        }),
+        hostRandomRejected: diagnostics.some((diagnostic) => diagnostic.ruleId === 'determinism/no-math-random'),
+        hostTimeRejected: diagnostics.some((diagnostic) => diagnostic.ruleId === 'determinism/no-date-now' || diagnostic.ruleId === 'determinism/no-performance-now'),
+    };
+    return categoryReport(config, 'fixed-numeric', 'required', [
+        'Fixed-point math',
+        'Deterministic random',
+        'Float/random/time compiler checks',
+    ], invariants, {
+        parser: getDeterminismParserKind(),
+        firstRandom: first,
+        secondRandom: second,
+        fixedVectorChecksum,
+        extendedMathChecksum,
+        diagnostics: diagnostics.length,
+    });
+}
+function runPhysicsCategory(config) {
+    const cert = runPhysicsCert({
+        engine: 'builtin-fixed',
+        shape: 'fixed-arena',
+        players: Math.min(config.players, 32),
+        frames: Math.min(config.frames, 300),
+        seed: config.seed,
+        snapshotEvery: 1,
+    });
+    const slotLoadCert = runPhysicsCert({
+        engine: 'builtin-fixed',
+        shape: 'slot-load',
+        players: Math.min(config.players, 128),
+        frames: Math.min(config.frames, 300),
+        seed: config.seed + 1,
+        snapshotEvery: 8,
+    });
+    const queryOrder = ['trigger:2', 'body:1', 'body:0'].sort();
+    const repeatedQueryOrder = ['body:0', 'body:1', 'trigger:2'].sort();
+    const ccdHit = detectVerticalCcdHit(0, 100, 50);
+    const materialRule = combineDeterministicPhysicsMaterial({ friction: 4, restitution: 1 }, { friction: 2, restitution: 5 });
+    const staticColliderCook = cookStaticColliders([
+        { id: 'wall-b', x: 100, y: 0, halfWidth: 8, halfHeight: 80 },
+        { id: 'wall-a', x: -100, y: 0, halfWidth: 8, halfHeight: 80 },
+    ]);
+    const physics2d = runPhysics2DParityWorkload(120, config.seed, -1);
+    const restored2d = runPhysics2DParityWorkload(120, config.seed, 48);
+    const lagComp3D = runDeterministicLagCompensation3DFixture(Math.min(config.players, 128), Math.min(config.frames, 1_000), config.seed);
+    const lagComp3DApi = runDeterministicLagCompensation3DApiFixture();
+    const physics3DCallbacks = runDeterministicPhysics3DCallbackMaskFixture();
+    const physics3DQueries = runDeterministicPhysics3DQueryOptionsFixture();
+    const physics3DMaterials = runDeterministicPhysics3DMaterialFixture();
+    const physics3DDetails = runDeterministicPhysics3DDetailFixture();
+    const physics3DStack = runDeterministicPhysics3DStackFixture();
+    const physics3DStress = runDeterministicPhysics3DStress(Math.min(config.players, 128), Math.max(120, Math.min(config.frames, 1_000)));
+    const invariants = {
+        stableCollisionCallbacks: cert.collisionEventsStable && physics2d.events.some((event) => event.startsWith('enter:')),
+        collisionStayExitCallbacks: physics2d.events.some((event) => event.startsWith('stay:')) && physics2d.events.some((event) => event.startsWith('exit:')),
+        sensorsAndTriggers: physics2d.events.some((event) => event.includes('|sensor') || event.includes('sensor|')),
+        layerMasks: physics2d.layerQueryHash === restored2d.layerQueryHash,
+        stableQueryOrdering: defaultChecksum(queryOrder) === defaultChecksum(repeatedQueryOrder) && physics2d.queryOrderHash === restored2d.queryOrderHash,
+        raycastQueries: physics2d.raycastHash === restored2d.raycastHash,
+        raycastAllQueries: physics2d.allHitsHash === restored2d.allHitsHash,
+        circleCastQueries: physics2d.circleCastHash === restored2d.circleCastHash,
+        shapeOverlapQueries: physics2d.shapeOverlapHash === restored2d.shapeOverlapHash,
+        heightFiltered25dQueries: physics2d.heightFilterHash === restored2d.heightFilterHash,
+        constraintsAndJoints: physics2d.constraintsHash === restored2d.constraintsHash,
+        ccdHitDetection: ccdHit,
+        materialCombinationRules: materialRule.friction === 3 && materialRule.restitution === 5,
+        staticColliderCooking: staticColliderCook.bytes === cookStaticColliders(staticColliderCook.colliders).bytes,
+        snapshotRollbackEquivalent: cert.uninterruptedChecksum === cert.restoredChecksum && physics2d.checksum === restored2d.checksum,
+        certified2dAnd25dCases: cert.result === 'pass' && slotLoadCert.result === 'pass',
+        physicsBudgetReported: physics2d.broadphasePairs > 0 && physics2d.narrowphaseContacts > 0 && physics2d.solverIterations > 0,
+        lagCompensated3DHitboxProxies: lagComp3D.proxyBodiesCreated > 0
+            && lagComp3D.proxyLifecycleBalanced
+            && lagComp3D.multiHitboxQueries > 0
+            && lagComp3D.animatedHitboxSamples > 0
+            && lagComp3D.interpolatedHitboxSamples > 0,
+        lagCompensated3DWeapons: lagComp3D.rifleShots > 0 && lagComp3D.shotgunShots > 0 && lagComp3D.burstShots > 0,
+        lagCompensated3DOcclusionAndRejection: lagComp3D.occluded > 0
+            && lagComp3D.staleRejected > 0
+            && lagComp3D.futureRejected > 0
+            && lagComp3D.misses > 0,
+        lagCompensated3DRollbackEquivalent: lagComp3D.rollbackEquivalent,
+        lagCompensated3DApiReusable: lagComp3DApi.hitReason === 'hit'
+            && lagComp3DApi.occludedReason === 'occluded'
+            && lagComp3DApi.staleReason === 'stale-frame'
+            && lagComp3DApi.futureReason === 'future-frame',
+        lagCompensated3DApiSnapshotRestoreEquivalent: lagComp3DApi.rollbackEquivalent,
+        lagCompensated3DApiProxyLifecycle: lagComp3DApi.proxiesCreated > 0
+            && lagComp3DApi.proxiesCreated === lagComp3DApi.proxiesDestroyed,
+        lagCompensated3DApiHistoryPruning: lagComp3DApi.prunedOldFrames,
+        physics3DCallbackLifecycle: physics3DCallbacks.rollbackEquivalent
+            && physics3DCallbacks.collisionEnter > 0
+            && physics3DCallbacks.collisionStay > 0
+            && physics3DCallbacks.collisionExit > 0
+            && physics3DCallbacks.triggerEnter > 0
+            && physics3DCallbacks.triggerStay > 0
+            && physics3DCallbacks.triggerExit > 0
+            && physics3DCallbacks.perEntityMaskHonored,
+        physics3DQueryOptions: physics3DQueries.defaultHitAll
+            && physics3DQueries.explicitSolidsOnly
+            && physics3DQueries.kindFiltersStable
+            && physics3DQueries.triggerSensorFiltersStable
+            && physics3DQueries.raycastCovered
+            && physics3DQueries.overlapCovered
+            && physics3DQueries.shapeCastCovered,
+        physics3DMaterialResponse: physics3DMaterials.rollbackEquivalent
+            && physics3DMaterials.combinedFriction === 3
+            && physics3DMaterials.combinedRestitution === 7
+            && physics3DMaterials.normalVelocityAfterBounce < 0,
+        physics3DDetailedQueriesAndContacts: physics3DDetails.rollbackEquivalent
+            && physics3DDetails.rayDetailedHits > 0
+            && physics3DDetails.shapeCastDetailedHits > 0
+            && physics3DDetails.contactDetails > 0
+            && physics3DDetails.stableUnderBodyOrderPermutation,
+        physics3DStackStability: physics3DStack.contactCount > 0
+            && physics3DStack.solverCorrections > 0
+            && physics3DStack.maxPenetration <= 0.05
+            && physics3DStack.maxHeightDrift <= 0.05
+            && physics3DStack.settledDynamicBodies === physics3DStack.stackLayers,
+        physics3DStackRollbackEquivalent: physics3DStack.rollbackEquivalent,
+        physics3DStackOrderStable: physics3DStack.stableUnderAuthoringOrderPermutation,
+        physics3DStressAndScheduledQueries: physics3DStress.rollbackEquivalent
+            && physics3DStress.contactCount > 0
+            && physics3DStress.queryCount > 0
+            && physics3DStress.shapeCastCount > 0
+            && physics3DStress.scheduledPrePhysicsQueries > 0
+            && physics3DStress.scheduledPostPhysicsQueries > 0
+            && physics3DStress.scheduledShapeCastQueries > 0
+            && physics3DStress.scheduledQueryResultCount > 0,
+        physics3DGeometryCoverage: physics3DStress.angularBodies > 0
+            && physics3DStress.meshStaticColliders > 0
+            && physics3DStress.exactMeshRaycasts > 0
+            && physics3DStress.exactMeshOverlapRejects > 0
+            && physics3DStress.angularGeometryQueries > 0,
+    };
+    return categoryReport(config, 'physics', 'required', [
+        'Deterministic physics',
+        '2D/2.5D collision',
+        '3D physics callbacks/materials/queries',
+        '3D scheduled query pipeline',
+        '3D lag-compensated hitbox proxies',
+        'CCD',
+        'Physics material rules',
+        'Static collider cooking',
+    ], invariants, {
+        uninterruptedChecksum: cert.uninterruptedChecksum,
+        restoredChecksum: cert.restoredChecksum,
+        collisionEvents: cert.collisionEvents,
+        snapshotBytesP95: cert.snapshotBytesP95,
+        slotLoadChecksum: slotLoadCert.restoredChecksum,
+        slotLoadPlayers: slotLoadCert.players,
+        staticColliderHash: staticColliderCook.hash,
+        physics2dChecksum: physics2d.checksum,
+        physics2dEvents: physics2d.events.length,
+        physics2dAllHitsHash: physics2d.allHitsHash,
+        physics2dCircleCastHash: physics2d.circleCastHash,
+        physics2dShapeOverlapHash: physics2d.shapeOverlapHash,
+        physics2dHeightFilterHash: physics2d.heightFilterHash,
+        physics2dBroadphasePairs: physics2d.broadphasePairs,
+        physics2dNarrowphaseContacts: physics2d.narrowphaseContacts,
+        physics2dSolverIterations: physics2d.solverIterations,
+        lagComp3DChecksum: lagComp3D.checksum,
+        lagComp3DRestoredChecksum: lagComp3D.restoredChecksum,
+        lagComp3DPlayers: lagComp3D.players,
+        lagComp3DFrames: lagComp3D.frames,
+        lagComp3DShots: lagComp3D.shots,
+        lagComp3DHits: lagComp3D.hits,
+        lagComp3DMisses: lagComp3D.misses,
+        lagComp3DOccluded: lagComp3D.occluded,
+        lagComp3DStaleRejected: lagComp3D.staleRejected,
+        lagComp3DFutureRejected: lagComp3D.futureRejected,
+        lagComp3DRifleShots: lagComp3D.rifleShots,
+        lagComp3DShotgunShots: lagComp3D.shotgunShots,
+        lagComp3DBurstShots: lagComp3D.burstShots,
+        lagComp3DProxyBodiesCreated: lagComp3D.proxyBodiesCreated,
+        lagComp3DInterpolatedHitboxSamples: lagComp3D.interpolatedHitboxSamples,
+        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,
+        physics3DCallbackChecksum: physics3DCallbacks.checksum,
+        physics3DCallbackRestoredChecksum: physics3DCallbacks.restoredChecksum,
+        physics3DCollisionEnter: physics3DCallbacks.collisionEnter,
+        physics3DCollisionStay: physics3DCallbacks.collisionStay,
+        physics3DCollisionExit: physics3DCallbacks.collisionExit,
+        physics3DTriggerEnter: physics3DCallbacks.triggerEnter,
+        physics3DTriggerStay: physics3DCallbacks.triggerStay,
+        physics3DTriggerExit: physics3DCallbacks.triggerExit,
+        physics3DDisabledEvents: physics3DCallbacks.disabledEvents,
+        physics3DQueryOptionsChecksum: physics3DQueries.checksum,
+        physics3DMaterialChecksum: physics3DMaterials.checksum,
+        physics3DMaterialRestoredChecksum: physics3DMaterials.restoredChecksum,
+        physics3DCombinedFriction: physics3DMaterials.combinedFriction,
+        physics3DCombinedRestitution: physics3DMaterials.combinedRestitution,
+        physics3DDetailChecksum: physics3DDetails.checksum,
+        physics3DDetailRestoredChecksum: physics3DDetails.restoredChecksum,
+        physics3DRayDetailedHits: physics3DDetails.rayDetailedHits,
+        physics3DShapeCastDetailedHits: physics3DDetails.shapeCastDetailedHits,
+        physics3DContactDetails: physics3DDetails.contactDetails,
+        physics3DStackChecksum: physics3DStack.checksum,
+        physics3DStackRestoredChecksum: physics3DStack.restoredChecksum,
+        physics3DStackReversedOrderChecksum: physics3DStack.reversedOrderChecksum,
+        physics3DStackBodies: physics3DStack.bodies,
+        physics3DStackFrames: physics3DStack.frames,
+        physics3DStackLayers: physics3DStack.stackLayers,
+        physics3DStackContacts: physics3DStack.contactCount,
+        physics3DStackSolverCorrections: physics3DStack.solverCorrections,
+        physics3DStackMaxPenetration: physics3DStack.maxPenetration,
+        physics3DStackMaxHeightDrift: physics3DStack.maxHeightDrift,
+        physics3DStackSettledDynamicBodies: physics3DStack.settledDynamicBodies,
+        physics3DStackP95StepCost: physics3DStack.p95StepCost,
+        physics3DStackP99StepCost: physics3DStack.p99StepCost,
+        physics3DStressChecksum: physics3DStress.checksum,
+        physics3DStressBodies: physics3DStress.bodies,
+        physics3DStressFrames: physics3DStress.frames,
+        physics3DStressContacts: physics3DStress.contactCount,
+        physics3DStressQueries: physics3DStress.queryCount,
+        physics3DStressShapeCasts: physics3DStress.shapeCastCount,
+        physics3DStressScheduledPreQueries: physics3DStress.scheduledPrePhysicsQueries,
+        physics3DStressScheduledPostQueries: physics3DStress.scheduledPostPhysicsQueries,
+        physics3DStressScheduledShapeCasts: physics3DStress.scheduledShapeCastQueries,
+        physics3DStressScheduledResults: physics3DStress.scheduledQueryResultCount,
+        physics3DStressP95StepMs: physics3DStress.p95StepMs,
+        physics3DStressP99StepMs: physics3DStress.p99StepMs,
+        physics3DStressAngularBodies: physics3DStress.angularBodies,
+        physics3DStressMeshStaticColliders: physics3DStress.meshStaticColliders,
+        physics3DStressExactMeshRaycasts: physics3DStress.exactMeshRaycasts,
+        physics3DStressExactMeshOverlapRejects: physics3DStress.exactMeshOverlapRejects,
+        physics3DStressAngularGeometryQueries: physics3DStress.angularGeometryQueries,
+        physics3DStressRollbackEquivalent: physics3DStress.rollbackEquivalent,
+    });
+}
+function runPhysics2DParityWorkload(frames, seed, restoreFrame) {
+    const constraints = [
+        { id: 'distance-player-crate', type: 'distance', a: 'player', b: 'crate', restLength: 6 },
+        { id: 'fixed-platform-rider', type: 'fixed', a: 'platform', b: 'rider', offsetX: 2, offsetY: 0 },
+        { id: 'motor-platform', type: 'motor', a: 'platform', motorVx: seed % 2 === 0 ? 1 : -1, motorVy: 0 },
+        { id: 'spring-crate', type: 'spring', a: 'platform', b: 'spring', restLength: 4, stiffness: 500 },
+    ];
+    let world = createDeterministicPhysicsWorld2D([
+        physicsBody('player', 'dynamic', -12, 0, 2, 0, 1),
+        physicsBody('crate', 'dynamic', 18, 0, 0, 0, 1),
+        physicsBody('spring', 'dynamic', 10, 0, 0, 0, 1),
+        physicsBody('rider', 'dynamic', 4, 0, 0, 0, 1),
+        physicsBody('platform', 'kinematic', 0, -6, 0, 0, 1),
+        {
+            ...physicsBody('wall', 'static', 0, 0, 0, 0, 1),
+            halfWidth: 1,
+            halfHeight: 6,
+            material: { friction: 4, restitution: 5 },
+        },
+        {
+            ...physicsBody('sensor', 'static', 6, 0, 0, 0, 2),
+            halfWidth: 3,
+            halfHeight: 6,
+            sensor: true,
+            trigger: true,
+        },
+    ]);
+    let snapshot = world;
+    const eventLog = [];
+    let broadphasePairs = 0;
+    let narrowphaseContacts = 0;
+    let solverIterations = 0;
+    let queryOrderHash = '';
+    let raycastHash = '';
+    let allHitsHash = '';
+    let circleCastHash = '';
+    let shapeOverlapHash = '';
+    let heightFilterHash = '';
+    let layerQueryHash = '';
+    let constraintsHash = '';
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = cloneCanonical(world);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 5) {
+            world = cloneCanonical(snapshot);
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                world = stepDeterministicPhysicsWorld2D(world, { constraints, iterations: 3 }).world;
+            }
+        }
+        if (frame === 24) {
+            world = {
+                ...world,
+                bodies: world.bodies.map((body) => body.id === 'player' ? { ...body, vx: 8 } : body),
+            };
+        }
+        const step = stepDeterministicPhysicsWorld2D(world, { constraints, iterations: 3 });
+        world = step.world;
+        eventLog.push(...step.events.map((event) => `${event.type}:${event.pair}`));
+        broadphasePairs += step.broadphasePairs;
+        narrowphaseContacts += step.narrowphaseContacts;
+        solverIterations += step.solverIterations;
+        queryOrderHash = defaultChecksum(queryDeterministicPhysicsAabb2D(world, {
+            x: 0,
+            y: 0,
+            halfWidth: 16,
+            halfHeight: 12,
+            layerMask: 0xff,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        raycastHash = defaultChecksum(raycastDeterministicPhysics2D(world, {
+            x: -20,
+            y: 0,
+            dx: 1,
+            dy: 0,
+            maxDistance: 64,
+            layerMask: 0xff,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        allHitsHash = defaultChecksum(raycastAllDeterministicPhysics2D(world, {
+            x: -20,
+            y: 0,
+            dx: 1,
+            dy: 0,
+            maxDistance: 64,
+            layerMask: 0xff,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        circleCastHash = defaultChecksum(circleCastDeterministicPhysics2D(world, {
+            x: -20,
+            y: 0,
+            radius: 2,
+            dx: 1,
+            dy: 0,
+            maxDistance: 40,
+            layerMask: 0xff,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        shapeOverlapHash = defaultChecksum(queryDeterministicPhysicsShapeOverlap2D(world, {
+            shape: 'circle',
+            x: 6,
+            y: 0,
+            radius: 4,
+            layerMask: 0xff,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        heightFilterHash = defaultChecksum(queryDeterministicPhysicsShapeOverlap2D({
+            ...world,
+            bodies: [
+                ...world.bodies,
+                { ...physicsBody('height-low', 'static', 30, 0, 0, 0, 4), z: 0, halfDepth: 1 },
+                { ...physicsBody('height-high', 'static', 30, 0, 0, 0, 4), z: 8, halfDepth: 1 },
+            ],
+        }, {
+            shape: 'aabb',
+            x: 30,
+            y: 0,
+            z: 0,
+            halfWidth: 4,
+            halfHeight: 4,
+            halfDepth: 2,
+            layerMask: 4,
+        }));
+        layerQueryHash = defaultChecksum(queryDeterministicPhysicsAabb2D(world, {
+            x: 6,
+            y: 0,
+            halfWidth: 4,
+            halfHeight: 8,
+            layerMask: 2,
+            includeSensors: true,
+            includeTriggers: true,
+        }));
+        constraintsHash = defaultChecksum(world.bodies
+            .filter((body) => body.id === 'crate' || body.id === 'rider' || body.id === 'spring')
+            .map((body) => `${body.id}:${body.x}:${body.y}:${body.vx}:${body.vy}`));
+    }
+    return {
+        checksum: defaultChecksum(world),
+        events: eventLog,
+        queryOrderHash,
+        raycastHash,
+        allHitsHash,
+        circleCastHash,
+        shapeOverlapHash,
+        heightFilterHash,
+        layerQueryHash,
+        constraintsHash,
+        broadphasePairs,
+        narrowphaseContacts,
+        solverIterations,
+    };
+}
+function physicsBody(id, kind, x, y, vx, vy, layer) {
+    return {
+        id,
+        kind,
+        x,
+        y,
+        vx,
+        vy,
+        halfWidth: 1,
+        halfHeight: 1,
+        layer,
+        mask: 0xff,
+        mass: kind === 'static' ? undefined : 1,
+        damping: 0,
+    };
+}
+function runMovementCategory(config) {
+    const frames = cappedProofFrames(config, 2_000);
+    const control = runMovementSimulation(frames, config.seed, -1);
+    const restored = runMovementSimulation(frames, config.seed, Math.floor(frames / 2));
+    const kcc3d = runDeterministicKcc3DCrowdFixture(Math.min(config.players, 128), Math.max(120, Math.min(config.frames, 1_000)));
+    const kcc3dFilterForce = runDeterministicKcc3DFilterForceFixture();
+    const kcc3dCallbackFilter = runDeterministicKcc3DCallbackFilterFixture();
+    const kcc3dGeometry = runDeterministicKcc3DGeometryFixture();
+    const kcc3dAdversarial = runDeterministicKcc3DAdversarialFixture();
+    const invariants = {
+        slopesAndSteps: control.slopes > 0 && control.steps > 0,
+        ledges: control.ledges > 0,
+        movingPlatforms: control.platformRides > 0,
+        elevators: control.elevatorRides > 0,
+        oneWayPlatforms: control.oneWayDrops > 0,
+        wallSlides: control.wallSlides > 0,
+        jumpBuffering: control.bufferedJumps > 0,
+        coyoteTime: control.coyoteJumps > 0,
+        contactRollbackEquivalent: control.checksum === restored.checksum,
+        topDownSliding: control.slides > 0,
+        navSteering: control.navSteeringFrames > 0,
+        quantizedFpsHitscanOrigin: control.hitscanOriginsStable,
+        deterministicRecoil: control.recoilFrames > 0,
+        lagCompensatedTargetRewind: control.rewindHits > 0
+            && control.rewindValidatedHits > 0
+            && control.rewindMisses > 0
+            && control.rewindRejectedStale > 0
+            && control.rewindRejectedFuture > 0
+            && control.rewindInterpolated > 0
+            && control.rewindValidationChecksum.length > 0,
+        crowd128: control.crowdPlayers === 128,
+        mixedHumanBotCrowd: control.crowdHumanInputSlots > 0 && control.crowdBotInputSlots > 0,
+        predictionCorrection: control.predictionCorrections > 0,
+        crowdRollbackEquivalent: control.crowdRollbackEquivalent,
+        kcc3DSlopesStepsPlatforms: kcc3d.slopeContacts > 0
+            && kcc3d.stepContacts > 0
+            && kcc3d.platformContacts > 0
+            && kcc3d.platformVelocityTransfers > 0,
+        kcc3DPhysicsSweepsAndSlides: kcc3d.physicsSlides > 0
+            && kcc3d.sweptCollisions > 0
+            && kcc3d.headClearanceBlocks > 0
+            && kcc3d.physicsQueryCount > 0,
+        kcc3DRollbackEquivalent: kcc3d.rollbackEquivalent,
+        kcc3DFilterAndExternalForces: kcc3dFilterForce.rollbackEquivalent
+            && kcc3dFilterForce.ignoredColliderPassedThrough
+            && kcc3dFilterForce.solidColliderBlocked
+            && kcc3dFilterForce.externalImpulseApplied
+            && kcc3dFilterForce.filterOrderStable,
+        kcc3DPerHitCallbackFiltering: kcc3dCallbackFilter.rollbackEquivalent
+            && kcc3dCallbackFilter.callbackIgnoredColliderPassedThrough
+            && kcc3dCallbackFilter.callbackSolidColliderBlocked
+            && kcc3dCallbackFilter.callbackLayerFiltered
+            && kcc3dCallbackFilter.callbackNormalFiltered
+            && kcc3dCallbackFilter.callbackOrderStable
+            && kcc3dCallbackFilter.callbackMetadataCovered
+            && kcc3dCallbackFilter.mutableFilterRejected
+            && kcc3dCallbackFilter.callbackInvocations > 0
+            && kcc3dCallbackFilter.callbackRejectedHits > 0
+            && kcc3dCallbackFilter.callbackAcceptedHits > 0,
+        kcc3DControllerGeometry: kcc3dGeometry.rollbackEquivalent
+            && kcc3dGeometry.defaultGeometryPreserved
+            && kcc3dGeometry.smallRadiusPassesNarrowGap
+            && kcc3dGeometry.largeRadiusBlockedByNarrowGap
+            && kcc3dGeometry.tallBodyHeadBlocked
+            && kcc3dGeometry.shortBodyClearsLowCeiling
+            && kcc3dGeometry.skinWidthExpandsCollisionShape
+            && kcc3dGeometry.geometryMetadataStable,
+        kcc3DAdversarialEdges: kcc3dAdversarial.rollbackEquivalent
+            && kcc3dAdversarial.thinWallSweeps > 0
+            && kcc3dAdversarial.diagonalThinWallSweeps > 0
+            && kcc3dAdversarial.ledgeCorrections > 0
+            && kcc3dAdversarial.ceilingBlocks > 0
+            && kcc3dAdversarial.cornerSweeps > 0
+            && kcc3dAdversarial.movingPlatformEdgeTransfers > 0
+            && kcc3dAdversarial.slopeLimitRejections > 0,
+    };
+    return categoryReport(config, 'movement', 'required', [
+        'KCC',
+        '3D KCC',
+        'Slopes/steps/ledges',
+        'Moving platforms/elevators',
+        'One-way platforms',
+        'Wall slides',
+        'Jump buffering/coyote time',
+        'Top-down movement',
+        'Nav steering',
+        'FPS quantized aim/hitscan/recoil',
+        'Lag-compensated target rewind',
+        'KCC collision callbacks',
+        'KCC controller geometry',
+    ], invariants, {
+        ...control,
+        kcc3DChecksum: kcc3d.checksum,
+        kcc3DPlayers: kcc3d.players,
+        kcc3DFrames: kcc3d.frames,
+        kcc3DCorrectionCount: kcc3d.correctionCount,
+        kcc3DPhysicsQueryCount: kcc3d.physicsQueryCount,
+        kcc3DSlopeContacts: kcc3d.slopeContacts,
+        kcc3DStepContacts: kcc3d.stepContacts,
+        kcc3DPlatformContacts: kcc3d.platformContacts,
+        kcc3DPhysicsSlides: kcc3d.physicsSlides,
+        kcc3DSweptCollisions: kcc3d.sweptCollisions,
+        kcc3DHeadClearanceBlocks: kcc3d.headClearanceBlocks,
+        kcc3DPlatformVelocityTransfers: kcc3d.platformVelocityTransfers,
+        kcc3DRollbackEquivalent: kcc3d.rollbackEquivalent,
+        kcc3DP95MovementCost: kcc3d.p95MovementCost,
+        kcc3DP99MovementCost: kcc3d.p99MovementCost,
+        kcc3DFilterForceChecksum: kcc3dFilterForce.checksum,
+        kcc3DFilterForceRestoredChecksum: kcc3dFilterForce.restoredChecksum,
+        kcc3DFilterForceIgnoredEvents: kcc3dFilterForce.ignoredCollisionEvents,
+        kcc3DFilterForceSolidEvents: kcc3dFilterForce.solidCollisionEvents,
+        kcc3DFilterForceExternalImpulseEvents: kcc3dFilterForce.externalImpulseEvents,
+        kcc3DCallbackFilterChecksum: kcc3dCallbackFilter.checksum,
+        kcc3DCallbackFilterRestoredChecksum: kcc3dCallbackFilter.restoredChecksum,
+        kcc3DCallbackFilterRollbackEquivalent: kcc3dCallbackFilter.rollbackEquivalent,
+        kcc3DCallbackFilterInvocations: kcc3dCallbackFilter.callbackInvocations,
+        kcc3DCallbackFilterRejectedHits: kcc3dCallbackFilter.callbackRejectedHits,
+        kcc3DCallbackFilterAcceptedHits: kcc3dCallbackFilter.callbackAcceptedHits,
+        kcc3DCallbackFilterIgnoredPassedThrough: kcc3dCallbackFilter.callbackIgnoredColliderPassedThrough,
+        kcc3DCallbackFilterSolidBlocked: kcc3dCallbackFilter.callbackSolidColliderBlocked,
+        kcc3DCallbackFilterLayerFiltered: kcc3dCallbackFilter.callbackLayerFiltered,
+        kcc3DCallbackFilterNormalFiltered: kcc3dCallbackFilter.callbackNormalFiltered,
+        kcc3DCallbackFilterOrderStable: kcc3dCallbackFilter.callbackOrderStable,
+        kcc3DCallbackFilterMetadataCovered: kcc3dCallbackFilter.callbackMetadataCovered,
+        kcc3DCallbackFilterMutableRejected: kcc3dCallbackFilter.mutableFilterRejected,
+        kcc3DGeometryChecksum: kcc3dGeometry.checksum,
+        kcc3DGeometryRestoredChecksum: kcc3dGeometry.restoredChecksum,
+        kcc3DGeometryRollbackEquivalent: kcc3dGeometry.rollbackEquivalent,
+        kcc3DGeometryDefaultPreserved: kcc3dGeometry.defaultGeometryPreserved,
+        kcc3DGeometrySmallRadiusPassesNarrowGap: kcc3dGeometry.smallRadiusPassesNarrowGap,
+        kcc3DGeometryLargeRadiusBlockedByNarrowGap: kcc3dGeometry.largeRadiusBlockedByNarrowGap,
+        kcc3DGeometryTallBodyHeadBlocked: kcc3dGeometry.tallBodyHeadBlocked,
+        kcc3DGeometryShortBodyClearsLowCeiling: kcc3dGeometry.shortBodyClearsLowCeiling,
+        kcc3DGeometrySkinWidthExpandsCollisionShape: kcc3dGeometry.skinWidthExpandsCollisionShape,
+        kcc3DGeometryMetadataStable: kcc3dGeometry.geometryMetadataStable,
+        kcc3DAdversarialChecksum: kcc3dAdversarial.checksum,
+        kcc3DAdversarialRestoredChecksum: kcc3dAdversarial.restoredChecksum,
+        kcc3DAdversarialThinWallSweeps: kcc3dAdversarial.thinWallSweeps,
+        kcc3DAdversarialDiagonalThinWallSweeps: kcc3dAdversarial.diagonalThinWallSweeps,
+        kcc3DAdversarialLedgeCorrections: kcc3dAdversarial.ledgeCorrections,
+        kcc3DAdversarialCeilingBlocks: kcc3dAdversarial.ceilingBlocks,
+        kcc3DAdversarialCornerSweeps: kcc3dAdversarial.cornerSweeps,
+        kcc3DAdversarialMovingPlatformEdgeTransfers: kcc3dAdversarial.movingPlatformEdgeTransfers,
+        kcc3DAdversarialSlopeLimitRejections: kcc3dAdversarial.slopeLimitRejections,
+    });
+}
+function runNavigationCategory(config) {
+    const frames = cappedProofFrames(config, 2_000);
+    const control = runNavigationSimulation(config.players, frames, config.seed, -1);
+    const restored = runNavigationSimulation(config.players, frames, config.seed, Math.floor(frames / 2));
+    const navmesh = runDeterministicNavmeshStress(config.players, frames);
+    const importedNavmesh = runDeterministicNavmeshImportTraversalFixture();
+    const velocityObstacle = runDeterministicNavmeshVelocityObstacleFixture();
+    const invariants = {
+        cookedGraphLoading: control.cookedGraphHash.length > 0,
+        aStarTieBreaking: control.pathHash === restored.pathHash,
+        regionEnableDisable: control.regionToggles > 0,
+        dynamicBlockerReplanning: control.replans > 0,
+        dynamicObstacleRemoval: control.dynamicObstacleRemovals > 0,
+        offMeshTraversal: control.offMeshTraversals > 0,
+        pathSmoothing: control.pathSmoothing > 0,
+        flowFieldMovement: control.flowFieldSteps > 0,
+        tilemapPathfinding: control.tilePaths > 0,
+        deterministicAvoidanceOrdering: control.avoidanceHash === restored.avoidanceHash && control.reciprocalAvoidanceCorrections > 0,
+        rollbackEquivalent: control.checksum === restored.checksum,
+        polygonNavmeshCooked: navmesh.pathHash.length > 0,
+        polygonNavmesh128Agents: navmesh.agents === config.players,
+        polygonNavmeshRollbackEquivalent: navmesh.rollbackEquivalent,
+        polygonNavmeshPointLookup: navmesh.pointPathFound && navmesh.pointLookupStable,
+        polygonNavmeshAvoidance: navmesh.avoidanceCorrections > 0 && navmesh.radiusAvoidanceCorrections > 0,
+        polygonNavmeshVelocityObstacleAvoidance: navmesh.velocityObstacleAvoidanceCorrections > 0
+            && navmesh.avoidanceSpeedReductions > 0
+            && velocityObstacle.movingObstacleSpeedReduction
+            && velocityObstacle.predictedFuturePositionAvoided
+            && velocityObstacle.obstacleOrderStable
+            && velocityObstacle.obstacleValidationRejected
+            && velocityObstacle.rollbackEquivalent,
+        polygonNavmeshAgentVelocityObstacleAvoidance: navmesh.agentVelocityObstacleAvoidanceCorrections > 0
+            && navmesh.agentAvoidancePriorityYields > 0
+            && navmesh.agentAvoidanceSpeedReductions > 0,
+        polygonNavmeshDynamicReplanning: navmesh.replans > 0,
+        importedNavmeshCookOrderStable: importedNavmesh.importOrderStable,
+        importedNavmeshValidationFailures: importedNavmesh.missingRegionRejected
+            && importedNavmesh.missingLinkRejected
+            && importedNavmesh.missingSpawnRejected,
+        importedNavmeshPortalSpawnTables: importedNavmesh.portalCount > 0 && importedNavmesh.spawnMarkerCount > 0,
+        offMeshTraversalLifecycle: importedNavmesh.offMeshEnterEvents > 0
+            && importedNavmesh.offMeshTraverseEvents > 0
+            && importedNavmesh.offMeshExitEvents > 0
+            && importedNavmesh.offMeshCompleteEvents > 0,
+        offMeshTraversalRollbackEquivalent: importedNavmesh.rollbackEquivalent,
+    };
+    return categoryReport(config, 'navigation', 'required', [
+        'Navmesh-like graph',
+        'Polygon navmesh',
+        'A*',
+        'Runtime regions',
+        'Dynamic obstacles',
+        'Off-mesh links',
+        'Imported navmesh cooking',
+        'Off-mesh traversal lifecycle',
+        'Flow fields',
+        'Tilemap pathfinder',
+        'Avoidance',
+        'Velocity-obstacle avoidance',
+    ], invariants, {
+        ...control,
+        polygonNavmeshChecksum: navmesh.checksum,
+        polygonNavmeshAgents: navmesh.agents,
+        polygonNavmeshFrames: navmesh.frames,
+        polygonNavmeshReplans: navmesh.replans,
+        polygonNavmeshAvoidanceCorrections: navmesh.avoidanceCorrections,
+        polygonNavmeshRadiusAvoidanceCorrections: navmesh.radiusAvoidanceCorrections,
+        polygonNavmeshVelocityObstacleCorrections: navmesh.velocityObstacleAvoidanceCorrections,
+        polygonNavmeshAgentVelocityObstacleCorrections: navmesh.agentVelocityObstacleAvoidanceCorrections,
+        polygonNavmeshAgentAvoidancePriorityYields: navmesh.agentAvoidancePriorityYields,
+        polygonNavmeshAvoidanceSpeedReductions: navmesh.avoidanceSpeedReductions,
+        polygonNavmeshAgentAvoidanceSpeedReductions: navmesh.agentAvoidanceSpeedReductions,
+        polygonNavmeshWaypointAdvances: navmesh.waypointAdvances,
+        polygonNavmeshPathHash: navmesh.pathHash,
+        polygonNavmeshPointPathHash: navmesh.pointPathHash,
+        polygonNavmeshPointPathFound: navmesh.pointPathFound,
+        polygonNavmeshPointLookupStable: navmesh.pointLookupStable,
+        polygonNavmeshRollbackEquivalent: navmesh.rollbackEquivalent,
+        importedNavmeshHash: importedNavmesh.importedHash,
+        importedNavmeshPermutedHash: importedNavmesh.permutedHash,
+        importedNavmeshPortalCount: importedNavmesh.portalCount,
+        importedNavmeshSpawnMarkerCount: importedNavmesh.spawnMarkerCount,
+        importedNavmeshOffMeshEnterEvents: importedNavmesh.offMeshEnterEvents,
+        importedNavmeshOffMeshTraverseEvents: importedNavmesh.offMeshTraverseEvents,
+        importedNavmeshOffMeshExitEvents: importedNavmesh.offMeshExitEvents,
+        importedNavmeshOffMeshCompleteEvents: importedNavmesh.offMeshCompleteEvents,
+        importedNavmeshOffMeshTraversalFrames: importedNavmesh.offMeshTraversalFrames,
+        importedNavmeshPointPathHash: importedNavmesh.pointPathHash,
+        importedNavmeshRollbackEquivalent: importedNavmesh.rollbackEquivalent,
+        velocityObstacleChecksum: velocityObstacle.checksum,
+        velocityObstacleRestoredChecksum: velocityObstacle.restoredChecksum,
+        velocityObstacleRollbackEquivalent: velocityObstacle.rollbackEquivalent,
+        velocityObstacleSpeedReduction: velocityObstacle.movingObstacleSpeedReduction,
+        velocityObstacleFuturePrediction: velocityObstacle.predictedFuturePositionAvoided,
+        velocityObstacleOrderStable: velocityObstacle.obstacleOrderStable,
+        velocityObstacleValidationRejected: velocityObstacle.obstacleValidationRejected,
+        velocityObstacleCorrections: velocityObstacle.velocityObstacleAvoidanceCorrections,
+        velocityObstacleSpeedReductions: velocityObstacle.avoidanceSpeedReductions,
+    });
+}
+function runAssetCookingCategory(config) {
+    const source = {
+        assets: [
+            { id: 'bot.utility', type: 'bot', weight: 10 },
+            { id: 'weapon.sword', type: 'item' },
+            {
+                id: 'proto.base',
+                type: 'prototype',
+                prototype: true,
+                references: ['weapon.sword'],
+                components: {
+                    Position: { x: 0, y: 0 },
+                    Health: { current: 100 },
+                    Inventory: {
+                        items: { collection: 'list', values: ['weapon.sword'] },
+                        tags: { collection: 'set', values: ['spawned', 'player', 'spawned'] },
+                    },
+                },
+            },
+            {
+                id: 'proto.player',
+                type: 'prototype',
+                prototype: true,
+                extendsRef: 'proto.base',
+                references: ['proto.base'],
+                components: {
+                    Health: { current: 80 },
+                },
+            },
+            {
+                id: 'map.arena',
+                type: 'map',
+                references: ['proto.player'],
+                spawns: [{ prototypeRef: 'proto.player', count: 4, startEntityId: 100, overrides: { Health: { current: 90 } } }],
+            },
+        ],
+    };
+    const prototypeDescriptor = {
+        id: 'parity-prototype-runtime',
+        tickRate: 60,
+        components: [
+            { id: 'Position', fields: [{ name: 'x', kind: 'int', defaultValue: 0 }, { name: 'y', kind: 'int', defaultValue: 0 }] },
+            { id: 'Health', fields: [{ name: 'current', kind: 'int', defaultValue: 100 }] },
+            {
+                id: 'Inventory',
+                fields: [
+                    { name: 'items', kind: 'asset-ref[]', defaultValue: [] },
+                    { name: 'tags', kind: 'string[]', defaultValue: [] },
+                ],
+            },
+        ],
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+    };
+    const first = cookDeterministicAssets(source);
+    const second = cookDeterministicAssets(source);
+    const validCookNotRejected = !assetCookFails({ assets: [{ id: 'valid.asset', references: [] }] });
+    const duplicateRejected = assetCookFails({ assets: [{ id: 'x' }, { id: 'x' }] });
+    const unresolvedRejected = assetCookFails({ assets: [{ id: 'map', references: ['missing'] }] });
+    const floatRejected = assetCookFails({ assets: [{ id: 'floaty', x: 1.25 }] });
+    const prototypeA = materializePrototypeEntities(first, 'proto.player', 4);
+    const prototypeB = materializePrototypeEntities(first, 'proto.player', 4);
+    const inheritedPrototype = materializePrototypeEntities(first, 'proto.player', 1, {
+        componentOverrides: { Controller: { slot: 2 } },
+    });
+    const inheritedComponents = inheritedPrototype[0]?.components;
+    const mapBake = materializeDeterministicMapEntities(first, 'map.arena');
+    const mapBakeRepeat = materializeDeterministicMapEntities(second, 'map.arena');
+    const mapRebake = materializeDeterministicMapEntities(cookDeterministicAssets({
+        ...source,
+        assets: source.assets.map((asset) => asset.id === 'map.arena'
+            ? { ...asset, spawns: [{ prototypeRef: 'proto.player', count: 5, startEntityId: 100, overrides: { Health: { current: 90 } } }] }
+            : asset),
+    }), 'map.arena');
+    const runtimeValidation = validatePrototypeEntitiesAgainstFrameRuntime(first, 'proto.player', prototypeDescriptor, 4);
+    const currentManifestAccepted = !throws(() => assertAssetManifestMatches(first.manifest, {
+        engineVersion: first.manifest.engineVersion,
+        assetDbHash: first.manifest.assetDbHash,
+    }));
+    const undeclaredPrototypeFieldRejected = throws(() => validatePrototypeEntitiesAgainstFrameRuntime(cookDeterministicAssets({
+        assets: [{
+                id: 'proto.bad',
+                prototype: true,
+                components: { Health: { current: 100, extra: 1 } },
+            }],
+    }), 'proto.bad', prototypeDescriptor, 1));
+    const staleEngineRejected = throws(() => assertAssetManifestMatches(first.manifest, { engineVersion: `${first.manifest.engineVersion}-stale` }));
+    const staleAssetDbRejected = throws(() => assertAssetManifestMatches(first.manifest, { assetDbHash: '0000000000000000' }));
+    const invariants = {
+        byteIdenticalCooking: first.bytes === second.bytes,
+        stableIdsHashesLuts: first.manifest.assetDbHash === second.manifest.assetDbHash && first.manifest.lookupHash === second.manifest.lookupHash,
+        prototypeSpawningStable: defaultChecksum(prototypeA) === defaultChecksum(prototypeB),
+        duplicateIdsRejected: duplicateRejected,
+        validCookAccepted: validCookNotRejected,
+        unresolvedReferencesRejected: unresolvedRejected,
+        unquantizedFloatsRejected: floatRejected,
+        currentManifestAccepted,
+        staleEngineRejected,
+        staleAssetDbRejected,
+        failClosedLoadChecks: staleEngineRejected && staleAssetDbRejected,
+        descriptorBackedPrototypeValidation: runtimeValidation.injectedComponentCount === 12 && runtimeValidation.runtimeSnapshotChecksum.length > 0,
+        undeclaredPrototypeFieldRejected,
+        compoundPrototypeInheritanceCovered: inheritedComponents?.Position?.x === 0
+            && inheritedComponents.Health?.current === 80
+            && inheritedComponents.Controller?.slot === 2,
+        dynamicCollectionAllocationCovered: inheritedComponents?.Inventory?.items?.[0] === 'weapon.sword'
+            && inheritedComponents.Inventory.tags?.join(',') === 'player,spawned',
+        mapSpawnMaterializationCovered: mapBake.materializedEntityCount === 4
+            && mapBake.prototypeIds.includes('proto.player')
+            && mapBake.materializedEntities[0]?.entityId === 100,
+        mapRebakeInvalidationCovered: mapBake.mapBakeHash === mapBakeRepeat.mapBakeHash && mapBake.mapBakeHash !== mapRebake.mapBakeHash,
+    };
+    return categoryReport(config, 'asset-cooking', 'required', [
+        'Asset DB',
+        'Map baking/cooking',
+        'Prototype materialization',
+        'Fail-closed replay/load identity',
+    ], invariants, {
+        assetDbHash: first.manifest.assetDbHash,
+        lookupHash: first.manifest.lookupHash,
+        schemaHash: first.manifest.schemaHash,
+        dependencyHash: first.manifest.dependencyHash,
+        cookedBytes: first.bytes.length,
+        spawnedEntities: prototypeA.length,
+        runtimeValidatedPrototypeEntities: runtimeValidation.materializedEntityCount,
+        runtimeInjectedPrototypeComponents: runtimeValidation.injectedComponentCount,
+        runtimePrototypeValidationChecksum: runtimeValidation.checksum,
+        inheritedPrototypeEntities: inheritedPrototype.length,
+        mapMaterializedEntityCount: mapBake.materializedEntityCount,
+        mapSpawnCount: mapBake.spawnCount,
+        mapBakeHash: mapBake.mapBakeHash,
+        rebakedMapBakeHash: mapRebake.mapBakeHash,
+    });
+}
+function runConfigBundleCategory(config) {
+    const metrics = runDeterministicConfigBundleParityFixture();
+    const invariants = {
+        configBundlePasses: metrics.result === 'pass',
+        identityHashesPresent: metrics.configHash.length > 0 && metrics.assetDbHash.length > 0,
+        byteStable: metrics.byteStable,
+        migrationCovered: metrics.migrationResult === 'migrated' && metrics.version === 1 && metrics.targetVersion === 2,
+        prototypeMaterializationCovered: metrics.prototypeCount > 0
+            && metrics.materializedEntityCount > 0
+            && metrics.prototypeMaterializationStable,
+        staleIdentityRejected: metrics.staleEngineRejected
+            && metrics.staleSchemaRejected
+            && metrics.staleConfigRejected
+            && metrics.staleAssetDbRejected,
+        tamperRejected: metrics.tamperedConfigBytesRejected && metrics.tamperedAssetBytesRejected,
+        unsupportedFloatsRejected: metrics.unsupportedFloatRejected,
+        inheritedPrototypeMaterialized: metrics.inheritedPrototypeMaterialized,
+        dynamicCollectionsMaterialized: metrics.dynamicCollectionsMaterialized,
+        mapMaterializationStable: metrics.mapMaterializationStable,
+        mapRebakeInvalidated: metrics.mapRebakeInvalidated,
+    };
+    return categoryReport(config, 'config-bundle', 'required', [
+        'Config identity',
+        'Migration',
+        'Prototype materialization',
+        'Stale and tampered config rejection',
+    ], invariants, {
+        proofContract: 'config-bundle@1',
+        requestedFrames: 1,
+        executedFrames: 1,
+        version: metrics.version,
+        targetVersion: metrics.targetVersion,
+        configHash: metrics.configHash,
+        assetDbHash: metrics.assetDbHash,
+        prototypeCount: metrics.prototypeCount,
+        materializedEntityCount: metrics.materializedEntityCount,
+        migrationResult: metrics.migrationResult,
+        byteStable: metrics.byteStable,
+        staleEngineRejected: metrics.staleEngineRejected,
+        staleSchemaRejected: metrics.staleSchemaRejected,
+        staleConfigRejected: metrics.staleConfigRejected,
+        staleAssetDbRejected: metrics.staleAssetDbRejected,
+        tamperedConfigBytesRejected: metrics.tamperedConfigBytesRejected,
+        tamperedAssetBytesRejected: metrics.tamperedAssetBytesRejected,
+        unsupportedFloatRejected: metrics.unsupportedFloatRejected,
+        prototypeMaterializationStable: metrics.prototypeMaterializationStable,
+        inheritedPrototypeMaterialized: metrics.inheritedPrototypeMaterialized,
+        dynamicCollectionsMaterialized: metrics.dynamicCollectionsMaterialized,
+        mapMaterializationStable: metrics.mapMaterializationStable,
+        mapRebakeInvalidated: metrics.mapRebakeInvalidated,
+        mapMaterializedEntityCount: metrics.mapMaterializedEntityCount,
+        mapBakeHash: metrics.mapBakeHash,
+        failureReasons: { ...metrics.failureReasons },
+        checksum: metrics.checksum,
+    });
+}
+function runProtocolCategory(config) {
+    const playerCounts = [2, 8, 32, 64, 128];
+    const startedAt = performance.now();
+    const runs = playerCounts.map((players, index) => runProtocolRollbackLab({
+        game: index % 2 === 0 ? 'command-bursts' : 'moderate-state',
+        players,
+        frames: Math.max(60, Math.min(config.frames, 240)),
+        seed: config.seed + index,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 150,
+        lossPermille: 30,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        disconnectStartFrame: 20,
+        disconnectEndFrame: 32,
+        lateJoinSlot: players - 1,
+        lateJoinFrame: 30,
+        eventTimelineLimit: 4,
+        predictionPolicy: 'repeat-last',
+    }));
+    const elapsedMs = performance.now() - startedAt;
+    const delaySamples = runs.flatMap((run) => run.deliveryDelaySamples);
+    const rollbackDepthSamples = runs.flatMap((run) => run.rollbackDepthSamples);
+    const rejectedCommandCounts = runs.map((run) => run.canceledRetries + run.absentInputFrames + run.commandRejected);
+    const realCommandRejected = runs.reduce((sum, run) => sum + run.commandRejected, 0);
+    const commandRuns = runs.filter((run) => run.game === 'command-bursts');
+    const spectatorJoinFrame = 45;
+    const spectatorRun = runProtocolRollbackLab({
+        game: 'command-bursts',
+        players: 128,
+        frames: Math.max(90, Math.min(config.frames, 240)),
+        seed: config.seed + 171,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 100,
+        lossPermille: 20,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        spectatorSlot: 126,
+        spectatorJoinFrame,
+        eventTimelineLimit: 2,
+        predictionPolicy: 'repeat-last',
+    });
+    const spectatorExpectedActiveFrames = Math.max(0, spectatorRun.frames - spectatorJoinFrame);
+    const adaptiveInputDelayBaseline = runProtocolRollbackLab({
+        game: 'moderate-state',
+        players: 32,
+        frames: Math.max(120, Math.min(config.frames, 240)),
+        seed: config.seed + 211,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 150,
+        lossPermille: 30,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        predictionPolicy: 'repeat-last',
+    });
+    const adaptiveInputDelayRun = runProtocolRollbackLab({
+        game: 'moderate-state',
+        players: 32,
+        frames: Math.max(120, Math.min(config.frames, 240)),
+        seed: config.seed + 211,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 150,
+        lossPermille: 30,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        predictionPolicy: 'repeat-last',
+        adaptiveInputDelay: true,
+        maxAdaptiveInputDelayFrames: 8,
+    });
+    const inputTimeline = runDeterministicInputTimelineFixture({
+        players: 128,
+        frames: Math.max(120, Math.min(config.frames, 1_000)),
+        seed: config.seed + 233,
+        sampleLimit: 8,
+    });
+    const commandTimelineMigration = runDeterministicCommandTimelineMigrationFixture(128);
+    const serverMigration = simulateServerMigration(runs);
+    const invariants = {
+        allPlayerCountsCovered: runs.length === playerCounts.length,
+        realInputBundlesDelivered: runs.every((run) => run.bundledInputMessages > 0),
+        delayJitterDropDupReorderCovered: runs.every((run) => run.deliveries > 0 && run.duplicates >= 0 && run.lost >= 0),
+        reconnectLateJoinCovered: runs.every((run) => run.disconnectDrops > 0),
+        checksumConvergence: runs.every((run) => run.authorityChecksum === run.clientChecksum && run.result === 'pass'),
+        commandBurstsCovered: commandRuns.length > 0,
+        commandChannelsDelivered: commandRuns.every((run) => run.commandDeliveries > 0),
+        commandTransportLossRecovered: commandRuns.some((run) => run.commandLost > 0)
+            && commandRuns.every((run) => run.commandAuthorityChecksum === run.commandClientChecksum),
+        commandChannelsRejectedHostileTraffic: commandRuns.every((run) => run.commandRejected > 0 && run.commandDuplicateDrops > 0),
+        commandChannelRollbackConvergence: commandRuns.every((run) => run.commandAuthorityChecksum === run.commandClientChecksum)
+            && commandRuns.some((run) => run.players === 128 && run.commandRollbackConverged),
+        commandChannelRollbackObserved: commandRuns.some((run) => run.players === 128 && run.commandRollbackObserved),
+        protocolSpectatorReconstruction: spectatorRun.spectatorReconstructions === 1
+            && spectatorRun.spectatorReconstructionChecksum === spectatorRun.authorityChecksum
+            && spectatorRun.spectatorInputFrames === spectatorExpectedActiveFrames
+            && spectatorRun.spectatorCommandRejected > 0,
+        repeatLastPredictionFallbackCovered: runs.every((run) => run.predictionPolicy === 'repeat-last' && run.repeatLastPredictions > 0),
+        repeatLastNonDefaultPredictionCovered: runs.some((run) => run.repeatLastNonDefaultPredictions > 0),
+        predictionFallbackChecksumReported: runs.every((run) => run.predictionFallbackChecksum.length > 0),
+        lateJoinSnapshotTailReconstruction: runs.every((run) => run.lateJoinReconstructions === 1 && run.lateJoinReconstructionChecksum === run.authorityChecksum && run.staleJoinRejected),
+        delayPercentilesReported: percentile(delaySamples, 50) > 0 && percentile(delaySamples, 95) >= percentile(delaySamples, 50) && percentile(delaySamples, 99) >= percentile(delaySamples, 95),
+        adaptiveInputDelayCovered: adaptiveInputDelayRun.result === 'pass'
+            && adaptiveInputDelayRun.adaptiveInputDelay
+            && adaptiveInputDelayRun.inputDelayAdjustments > 0
+            && adaptiveInputDelayRun.finalInputDelayFrames > 0
+            && adaptiveInputDelayRun.maxObservedInputDelayFrames <= 8
+            && adaptiveInputDelayRun.rollbacks < adaptiveInputDelayBaseline.rollbacks
+            && adaptiveInputDelayRun.localInputRollbacks < adaptiveInputDelayBaseline.localInputRollbacks,
+        inputTimelineArtifactCovered: inputTimeline.result === 'pass'
+            && inputTimeline.players === 128
+            && inputTimeline.rowCount === inputTimeline.players * inputTimeline.frames
+            && inputTimeline.replayVerified
+            && inputTimeline.rowHash.length > 0,
+        inputTimelinePredictionPoliciesCovered: inputTimeline.invariants.explicitPredictionCovered
+            && inputTimeline.invariants.neutralPredictionCovered
+            && inputTimeline.invariants.repeatLastPredictionCovered,
+        inputTimelineLifecyclePoliciesCovered: inputTimeline.invariants.confirmedCovered
+            && inputTimeline.invariants.replacementCovered
+            && inputTimeline.invariants.absentCovered
+            && inputTimeline.invariants.botCovered
+            && inputTimeline.invariants.lateJoinCovered,
+        inputTimelineCorrectionPoliciesCovered: inputTimeline.invariants.lateFillCovered
+            && inputTimeline.invariants.rollbackTriggeredCovered,
+        inputTimelineIngressRejectionsCovered: inputTimeline.invariants.inactivePredictionRejected
+            && inputTimeline.invariants.malformedValueRejected
+            && inputTimeline.invariants.duplicateIngressRejected
+            && inputTimeline.invariants.duplicateAfterRestoreRejected
+            && inputTimeline.invariants.futureIngressRejected
+            && inputTimeline.invariants.staleIngressRejected
+            && inputTimeline.invariants.spectatorIngressRejected
+            && inputTimeline.invariants.badSenderRejected,
+        commandTimelineMigrationCovered: commandTimelineMigration.result === 'pass'
+            && commandTimelineMigration.acceptedBeforeMigration > 0
+            && commandTimelineMigration.acceptedAfterMigration > commandTimelineMigration.acceptedBeforeMigration
+            && commandTimelineMigration.snapshotChecksum === commandTimelineMigration.restoredChecksum
+            && commandTimelineMigration.pollOrderStable
+            && commandTimelineMigration.acceptedCommandIdsRestored
+            && commandTimelineMigration.currentFrameRestored
+            && commandTimelineMigration.newCommandAcceptedAfterRestore,
+        commandTimelineRejectionsAfterMigrationCovered: commandTimelineMigration.duplicateAfterRestoreRejected
+            && commandTimelineMigration.staleAfterRestoreRejected
+            && commandTimelineMigration.futureAfterRestoreRejected
+            && commandTimelineMigration.unauthorizedAfterRestoreRejected
+            && commandTimelineMigration.oversizedAfterRestoreRejected
+            && commandTimelineMigration.badSchemaAfterRestoreRejected
+            && commandTimelineMigration.badAssetRefAfterRestoreRejected,
+        rollbackDistributionReported: rollbackDepthSamples.length > 0,
+        rejectedCommandCountsReported: realCommandRejected > 0 && commandRuns.every((run) => run.commandRejected > 0),
+        serverMigrationSimulated: serverMigration.authorityChecksum === serverMigration.migratedAuthorityChecksum,
+    };
+    return categoryReport(config, 'protocol', 'required', [
+        'Input bundles',
+        'Delay/jitter/loss/duplicate/reorder',
+        'Reconnect',
+        'Late join',
+        'Adaptive input delay',
+        'Input timeline transcript',
+        'Command timeline migration',
+        'Command bursts',
+        '128 players',
+    ], invariants, {
+        playerCounts: playerCounts.join(','),
+        totalDeliveries: runs.reduce((sum, run) => sum + run.deliveries, 0),
+        totalDroppedMessages: runs.reduce((sum, run) => sum + run.lost, 0),
+        totalDuplicatedMessages: runs.reduce((sum, run) => sum + run.duplicates, 0),
+        totalRejectedCommands: rejectedCommandCounts.reduce((sum, count) => sum + count, 0),
+        totalCommandDeliveries: runs.reduce((sum, run) => sum + run.commandDeliveries, 0),
+        totalCommandLost: runs.reduce((sum, run) => sum + run.commandLost, 0),
+        totalCommandDuplicatedMessages: runs.reduce((sum, run) => sum + run.commandDuplicates, 0),
+        totalCommandReorderedMessages: runs.reduce((sum, run) => sum + run.commandReorders, 0),
+        totalCommandDisconnectDrops: runs.reduce((sum, run) => sum + run.commandDisconnectDrops, 0),
+        totalCommandRejected: runs.reduce((sum, run) => sum + run.commandRejected, 0),
+        pollutedLegacyRejectedCommandTelemetry: rejectedCommandCounts.reduce((sum, count) => sum + count, 0),
+        commandRollbackObservedRuns: commandRuns.filter((run) => run.commandRollbackObserved).length,
+        spectatorReconstructions: spectatorRun.spectatorReconstructions,
+        spectatorInputFrames: spectatorRun.spectatorInputFrames,
+        spectatorExpectedActiveFrames,
+        spectatorCommandRejected: spectatorRun.spectatorCommandRejected,
+        spectatorReconstructionChecksum: spectatorRun.spectatorReconstructionChecksum,
+        commandReplayChecksums: commandRuns.map((run) => run.commandReplayChecksum).join(','),
+        predictionPolicy: 'repeat-last',
+        predictedInputFrames: runs.reduce((sum, run) => sum + run.predictedInputFrames, 0),
+        repeatLastPredictions: runs.reduce((sum, run) => sum + run.repeatLastPredictions, 0),
+        repeatLastNonDefaultPredictions: runs.reduce((sum, run) => sum + run.repeatLastNonDefaultPredictions, 0),
+        neutralPredictions: runs.reduce((sum, run) => sum + run.neutralPredictions, 0),
+        predictionFallbackChecksum: defaultChecksum(runs.map((run) => run.predictionFallbackChecksum)),
+        lateJoinReconstructions: runs.reduce((sum, run) => sum + run.lateJoinReconstructions, 0),
+        inputDelayP50: percentile(delaySamples, 50),
+        inputDelayP95: percentile(delaySamples, 95),
+        inputDelayP99: percentile(delaySamples, 99),
+        adaptiveInputDelayBaselineRollbacks: adaptiveInputDelayBaseline.rollbacks,
+        adaptiveInputDelayRollbacks: adaptiveInputDelayRun.rollbacks,
+        adaptiveInputDelayBaselineLocalRollbacks: adaptiveInputDelayBaseline.localInputRollbacks,
+        adaptiveInputDelayLocalRollbacks: adaptiveInputDelayRun.localInputRollbacks,
+        adaptiveInputDelayFinalFrames: adaptiveInputDelayRun.finalInputDelayFrames,
+        adaptiveInputDelayMaxObservedFrames: adaptiveInputDelayRun.maxObservedInputDelayFrames,
+        adaptiveInputDelayAdjustments: adaptiveInputDelayRun.inputDelayAdjustments,
+        inputTimelineRows: inputTimeline.rowCount,
+        inputTimelineHash: inputTimeline.rowHash,
+        inputTimelineReplayChecksum: inputTimeline.replayChecksum,
+        inputTimelineSampleRows: inputTimeline.sampledRows.map((row) => ({ ...row })),
+        inputTimelineCounts: { ...inputTimeline.counts },
+        inputTimelineNegativeCases: { ...inputTimeline.negativeCases },
+        commandTimelineMigrationChecksum: commandTimelineMigration.checksum,
+        commandTimelineMigrationFinalChecksum: commandTimelineMigration.finalChecksum,
+        commandTimelineMigrationAcceptedBefore: commandTimelineMigration.acceptedBeforeMigration,
+        commandTimelineMigrationAcceptedAfter: commandTimelineMigration.acceptedAfterMigration,
+        commandTimelineMigrationRejections: { ...commandTimelineMigration.rejectionCounts },
+        totalRollbacks: runs.reduce((sum, run) => sum + run.rollbacks, 0),
+        maxRollbackDepth: Math.max(...runs.map((run) => run.maxRollbackDepth)),
+        rollbackDepthDistribution: rollbackDistribution(rollbackDepthSamples),
+        serverMigrationFrame: serverMigration.frame,
+        migratedAuthorityChecksum: serverMigration.migratedAuthorityChecksum,
+        elapsedMs: elapsedMs.toFixed(2),
+        checksum: defaultChecksum(runs.map((run) => run.authorityChecksum)),
+    });
+}
+function runReplayDebuggingCategory(config) {
+    const session = createLabSession({ players: 4, seed: config.seed, replayRecordingMode: 'memory' });
+    const random = new DeterministicRandom(config.seed);
+    for (let frame = 0; frame < Math.min(config.frames, 180); frame += 1) {
+        applyLabInputs(session, 4, random);
+        if (frame % 17 === 0) {
+            session.recordCommands([{
+                    kind: frame % 34 === 0 ? 'spawn' : 'emote',
+                    slot: frame % 4,
+                    value: random.nextInt(0, 1_000),
+                }]);
+        }
+        session.stepFrames(1);
+    }
+    const replay = session.exportReplay();
+    const valid = verifyReplay({
+        replay,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        hydrateInput: hydrateLabInput,
+        throwOnMismatch: false,
+    });
+    const replayClone = JSON.parse(JSON.stringify(replay));
+    const corrupted = {
+        ...replayClone,
+        checksums: replayClone.checksums.map((checksum, index) => index === Math.floor(replayClone.checksums.length / 2)
+            ? { ...checksum, checksum: '0000000000000000' }
+            : checksum),
+    };
+    const invalid = verifyReplay({
+        replay: corrupted,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        hydrateInput: hydrateLabInput,
+        throwOnMismatch: false,
+    });
+    const slice = replay.inputFrames.slice(Math.max(0, replay.inputFrames.length - 10));
+    const explainedFrame = Math.max(0, Math.floor(replay.inputFrames.length / 2));
+    const explained = inspectReplayFrame({
+        replay,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        hydrateInput: hydrateLabInput,
+    }, explainedFrame, { explainChecksum: true });
+    /* istanbul ignore next -- checksum explanation is explicitly requested above and must be present. */
+    const explanationTables = explained.checksumExplanation?.tables ?? [];
+    const minimization = createReplayDesyncMinimizationProof();
+    const inputOnlyReplayBundle = createInputOnlyReplayBundleProof();
+    const invariants = {
+        validReplayVerified: valid.mismatches === 0,
+        corruptedReplayFails: invalid.mismatches > 0,
+        frameRangeReplay: slice.length > 0,
+        firstMismatchBinarySearch: invalid.firstMismatch !== undefined && minimization.searchSteps > 0,
+        replayBundleDesyncMinimized: minimization.verifierConsumable
+            && minimization.result === 'fail'
+            && minimization.firstMismatchFrame === minimization.mismatchFrame
+            && minimization.minimizedReplayBytes < minimization.originalReplayBytes,
+        replayBundleMinimizedArtifactReduced: minimization.removedInputFrames > 0
+            && minimization.removedCommandFrames > 0
+            && minimization.removedSnapshots > 0
+            && minimization.removedChecksumFrames > 0,
+        replaySlicing: defaultChecksum(JSON.stringify(slice)).length > 0,
+        spectatorReconstruction: replay.checksums.at(-1)?.checksum === valid.finalChecksum,
+        killcamRewind: slice[0]?.frame !== undefined && slice[0].frame < replay.inputFrames.at(-1).frame,
+        checksumExplainMode: explained.checksumExplanation !== undefined
+            && explanationTables.length > 0
+            && explanationTables.every((table) => table.path.startsWith('state.') && table.checksum.length > 0),
+        replayIdentitySections: replay.engineIdentityHash !== undefined
+            && replay.assetDbHash !== undefined
+            && replay.configHash !== undefined
+            && replay.metadata !== undefined
+            && replay.commandHistory !== undefined
+            && replay.commandHistory.length > 0
+            && replay.debugEvents !== undefined,
+        commandHistoryReplayable: replay.commandHistory !== undefined
+            && replay.commandHistory.length > 0
+            && replay.commandHistory.every((commandFrame) => commandFrame.commands.length > 0),
+        inputOnlyReplayBundleVerified: inputOnlyReplayBundle.result === 'pass'
+            && inputOnlyReplayBundle.commandCount === 0
+            && inputOnlyReplayBundle.inputCount > 0
+            && inputOnlyReplayBundle.semanticReplayExecuted,
+    };
+    return categoryReport(config, 'replay-debugging', 'required', [
+        'Replay package',
+        'Checksum verification',
+        'First mismatch',
+        'Replay slicing',
+        'Late spectator reconstruction',
+        'Killcam rewind',
+        'Checksum explain tables',
+    ], invariants, {
+        replayFrames: replay.inputFrames.length,
+        checksums: replay.checksums.length,
+        validFinalChecksum: valid.finalChecksum,
+        corruptedMismatchFrame: numberOrFallback(invalid.firstMismatch?.frame, -1),
+        desyncMinimizationSearchSteps: minimization.searchSteps,
+        desyncMinimizationMismatchFrame: minimization.mismatchFrame,
+        desyncMinimizationVerifierFrame: minimization.firstMismatchFrame,
+        desyncMinimizationVerifierResult: minimization.result,
+        desyncMinimizationVerifierConsumable: minimization.verifierConsumable,
+        desyncMinimizationOriginalBytes: minimization.originalReplayBytes,
+        desyncMinimizationMinimizedBytes: minimization.minimizedReplayBytes,
+        desyncMinimizationRemovedInputFrames: minimization.removedInputFrames,
+        desyncMinimizationRemovedCommandFrames: minimization.removedCommandFrames,
+        desyncMinimizationRemovedSnapshots: minimization.removedSnapshots,
+        desyncMinimizationRemovedChecksumFrames: minimization.removedChecksumFrames,
+        checksumExplainFrame: explained.frame,
+        checksumExplainTables: explanationTables.length,
+        engineIdentityHash: stringOrFallback(replay.engineIdentityHash, ''),
+        assetDbHash: stringOrFallback(replay.assetDbHash, ''),
+        configHash: stringOrFallback(replay.configHash, ''),
+        commandHistoryFrames: readonlyArrayOrEmpty(replay.commandHistory).length,
+        commandHistoryCommands: readonlyArrayOrEmpty(replay.commandHistory).reduce((sum, commandFrame) => sum + commandFrame.commands.length, 0),
+        inputOnlyBundleInputs: inputOnlyReplayBundle.inputCount,
+        inputOnlyBundleCommands: inputOnlyReplayBundle.commandCount,
+        inputOnlyBundleReplayBytes: inputOnlyReplayBundle.replayBytes,
+        debugEvents: readonlyArrayOrEmpty(replay.debugEvents).length,
+        replayBytes: JSON.stringify(replay).length,
+    });
+}
+function createInputOnlyReplayBundleProof() {
+    let position = 0;
+    const snapshots = [0, 1, 2, 3].map((frame) => {
+        position += frame;
+        const bytes = canonicalStringify({ frame, positions: [position], commandScore: 0 });
+        return { frame, bytes, checksum: defaultChecksum(bytes) };
+    });
+    const bundle = createDeterministicReplayBundle({
+        runtimeVersion: 'parity-replay@1',
+        engineHash: 'engine',
+        schemaHash: 'schema',
+        assetDbHash: 'asset',
+        configHash: 'config',
+        sampleId: 'input-only-replay',
+        inputHistory: snapshots.map((snapshot) => ({ frame: snapshot.frame, inputs: [{ slot: 0, dx: snapshot.frame, dy: 0 }] })),
+        commandHistory: [],
+        checksums: snapshots.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+        debugEvents: snapshots.map((snapshot) => ({ frame: snapshot.frame, type: 'ecs.snapshot', payload: { frame: snapshot.frame } })),
+        snapshots,
+        metadata: { players: 1, replayKind: 'input-only' },
+    });
+    return verifyDeterministicReplayBundle(bundle);
+}
+function createReplayDesyncMinimizationProof() {
+    let position = 0;
+    let commandScore = 0;
+    const snapshots = Array.from({ length: 13 }, (_, index) => index * 2).map((frame) => {
+        position += frame;
+        commandScore += frame % 3;
+        const bytes = canonicalStringify({ frame, positions: [position], commandScore });
+        return { frame, bytes, checksum: defaultChecksum(bytes) };
+    });
+    const expected = createDeterministicReplayBundle({
+        runtimeVersion: 'parity-replay@1',
+        engineHash: 'engine',
+        schemaHash: 'schema',
+        assetDbHash: 'asset',
+        configHash: 'config',
+        sampleId: 'replay-minimization',
+        inputHistory: snapshots.map((snapshot) => ({ frame: snapshot.frame, inputs: [{ slot: 0, dx: snapshot.frame, dy: 0 }] })),
+        commandHistory: snapshots.map((snapshot) => ({ frame: snapshot.frame, commands: [{ id: `cmd:${snapshot.frame}`, payload: { power: snapshot.frame % 3 } }] })),
+        checksums: snapshots.map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+        debugEvents: snapshots.map((snapshot) => ({ frame: snapshot.frame, type: 'ecs.snapshot', payload: { frame: snapshot.frame } })),
+        snapshots,
+        metadata: { players: 1, checkpointBundle: true, checkpointStride: 2 },
+    });
+    const actual = {
+        ...expected,
+        checksums: expected.checksums.map((checksum) => checksum.frame >= 12 ? { ...checksum, checksum: `corrupt:${checksum.frame}` } : checksum),
+    };
+    const minimization = minimizeDeterministicReplayDesyncBundle(expected, actual);
+    /* istanbul ignore next -- expected/actual bundles are deliberately corrupted above to guarantee a minimization result. */
+    if (minimization === undefined) {
+        return {
+            searchSteps: 0,
+            mismatchFrame: -1,
+            firstMismatchFrame: -1,
+            result: 'pass',
+            verifierConsumable: false,
+            originalReplayBytes: 0,
+            minimizedReplayBytes: 0,
+            removedInputFrames: 0,
+            removedCommandFrames: 0,
+            removedSnapshots: 0,
+            removedChecksumFrames: 0,
+        };
+    }
+    return {
+        searchSteps: minimization.searchSteps,
+        mismatchFrame: minimization.mismatch.frame,
+        firstMismatchFrame: numberOrFallback(minimization.verifier.firstMismatch?.frame, -1),
+        result: minimization.verifier.result,
+        verifierConsumable: minimization.verifier.firstMismatch !== undefined,
+        originalReplayBytes: minimization.originalReplayBytes,
+        minimizedReplayBytes: minimization.minimizedReplayBytes,
+        removedInputFrames: minimization.removedInputFrames,
+        removedCommandFrames: minimization.removedCommandFrames,
+        removedSnapshots: minimization.removedSnapshots,
+        removedChecksumFrames: minimization.removedChecksumFrames,
+    };
+}
+function runBotCategory(config) {
+    const frames = cappedProofFrames(config, 2_000);
+    const control = runDeterministicBotSimulation(config.players, frames, config.seed, -1);
+    const restored = runDeterministicBotSimulation(config.players, frames, config.seed, Math.floor(frames / 2));
+    const document = runDeterministicBotDocumentFixture(config.players, frames);
+    const invariants = {
+        hfsmDeterministic: control.hfsmTransitions > 0,
+        behaviorTreeDeterministic: control.behaviorTreeTicks > 0,
+        utilityTheoryDeterministic: control.utilitySelections > 0,
+        botDocumentCompiled: document.compiledAssetHash.length > 0,
+        botDocumentHfsmCovered: document.transitions > 0,
+        botDocumentBehaviorTreeCovered: document.ticks > 0 && document.behaviorDecoratorTicks > 0,
+        botDocumentUtilityCovered: document.utilitySelections > 0,
+        botDocumentBehaviorServicesCovered: document.behaviorServiceTicks > 0,
+        botDocumentUtilityCurvesCovered: document.utilityCurveSelections > 0,
+        botDocumentUtilityNestedCovered: document.utilityNestedSelections > 0,
+        botDocumentUtilityMomentumCovered: document.utilityMomentumSelections > 0,
+        botDocumentUtilityCooldownCovered: document.utilityCooldownSuppressions > 0,
+        behaviorServicesCovered: control.behaviorServiceTicks > 0,
+        utilityCurvesCovered: control.utilityCurveSelections > 0,
+        utilityNestedCovered: control.utilityNestedSelections > 0,
+        utilityMomentumCovered: control.utilityMomentumSelections > 0,
+        utilityCooldownCovered: control.utilityCooldownSuppressions > 0,
+        botDocumentDebugTraceCovered: document.debugTraceCount > 0,
+        mixedBotStyles: control.styles === 'behavior-tree,hfsm,utility',
+        cookedBotAssets: control.cookedBotHash.length > 0,
+        blackboardOrdering: control.blackboardHash === restored.blackboardHash,
+        rollbackEquivalent: control.checksum === restored.checksum,
+        mixedHumanBotLanes: control.mixedHumanBotLanes,
+        player128BotReplacement: config.players === 128
+            && control.botReplacementSlots > 0
+            && document.botReplacementSlots > 0,
+    };
+    return categoryReport(config, 'bots', 'required', [
+        'HFSM',
+        'Behavior Tree',
+        'Utility Theory',
+        'Bot SDK asset cooking',
+        'Bot document compile and trace',
+        '128-player bot replacement',
+    ], invariants, {
+        ...control,
+        botDocumentChecksum: document.checksum,
+        botDocumentCompiledAssetHash: document.compiledAssetHash,
+        botDocumentBlackboardHash: document.blackboardHash,
+        botDocumentTransitions: document.transitions,
+        botDocumentTicks: document.ticks,
+        botDocumentUtilitySelections: document.utilitySelections,
+        botDocumentBehaviorRunningTicks: document.behaviorRunningTicks,
+        botDocumentBehaviorResumeTicks: document.behaviorResumeTicks,
+        botDocumentBehaviorDecoratorTicks: document.behaviorDecoratorTicks,
+        botDocumentBehaviorServiceTicks: document.behaviorServiceTicks,
+        botDocumentUtilityCurveSelections: document.utilityCurveSelections,
+        botDocumentUtilityNestedSelections: document.utilityNestedSelections,
+        botDocumentUtilityMomentumSelections: document.utilityMomentumSelections,
+        botDocumentUtilityCooldownSuppressions: document.utilityCooldownSuppressions,
+        botDocumentReplacementSlots: document.botReplacementSlots,
+        botDocumentDebugTraceCount: document.debugTraceCount,
+    });
+}
+function runAnimationCategory(config) {
+    const frames = cappedProofFrames(config, 2_000);
+    const control = runDeterministicAnimationFixture(frames);
+    const invariants = {
+        cookedAnimationAsset: control.cookedAssetHash.length > 0,
+        stateTransitionsCovered: control.transitions > 0,
+        exitFrameTransitionsCovered: control.exitFrameTransitions > 0,
+        transitionBlendCovered: control.transitionBlendFrames > 0,
+        triggerLatchCovered: control.triggerLatchCount > 0,
+        animationEventsEmitted: control.emittedEvents > 0,
+        normalizedClipTimeCovered: control.normalizedTimeHash.length > 0,
+        sampledPoseCovered: control.poseHash.length > 0,
+        blendTreeCovered: control.blendTreeFrames > 0,
+        animationLayersCovered: control.layerPoseFrames > 0,
+        rootMotionCovered: control.rootMotionFrames > 0,
+        eventReconstructionCovered: control.reconstructedEvents > 0 && control.reconstructedEventHash.length > 0,
+        rollbackEquivalent: control.rollbackEquivalent,
+    };
+    return categoryReport(config, 'animation', 'required', [
+        'Deterministic Animator',
+        'Clip playback',
+        'State transitions',
+        'Trigger latching',
+        'Animation events',
+        'Blend trees and layers',
+        'Root motion',
+        'Event reconstruction',
+        'Rollback-safe animation state',
+    ], invariants, { ...control });
+}
+function runSampleSceneCategory(config) {
+    const frames = cappedProofFrames(config, 2_000);
+    const samples = runAllDeterministicSampleScenes(frames, config.seed);
+    const integrated = runDeterministicIntegratedHeadlessScene(Math.min(frames, 256), Math.min(config.players, 128), config.seed + 991);
+    const trace = createDeterministicSampleSceneCertificationTrace(frames, config.players, config.seed);
+    const samplesById = new Map(samples.map((sample) => [sample.sampleId, sample]));
+    const mechanicsCovered = samples.reduce((sum, sample) => sum + Object.values(sample.invariants).filter(Boolean).length, 0);
+    const representativeStates = trace.samples.reduce((sum, sample) => sum + sample.representativeStates.length, 0);
+    const invariants = {
+        asteroids: samplePassed(samples, 'asteroids'),
+        simpleFps: samplePassed(samples, 'simple-fps'),
+        twinStick: samplePassed(samples, 'twin-stick'),
+        platformShooter: samplePassed(samples, 'platform-shooter'),
+        arenaBrawler: samplePassed(samples, 'arena-brawler'),
+        vehicle: samplePassed(samples, 'vehicle'),
+        miniGolf: samplePassed(samples, 'mini-golf'),
+        waitingRoom: samplePassed(samples, 'waiting-room'),
+        boatWater: samplePassed(samples, 'boat-water'),
+        animator: samplePassed(samples, 'animator'),
+        allMechanicsCovered: samples.every((sample) => Object.values(sample.invariants).every(Boolean)),
+        integratedHeadlessSceneCovered: Object.values(integrated.invariants).every(Boolean),
+        integratedReplayVerified: integrated.replayVerified,
+        integratedRollbackEquivalent: integrated.rollbackEquivalent,
+        artifactTracePresent: trace.kind === 'deterministic-sample-scene-certification-trace' && trace.traceHash.length > 0,
+        artifactTraceAllSamplesCovered: trace.sampleCount === deterministicSampleSceneIds.length
+            && deterministicSampleSceneIds.every((sampleId) => trace.samples.some((sample) => sample.sampleId === sampleId)),
+        artifactTraceMechanicsCovered: trace.samples.every((sample) => sample.mechanics.every((mechanic) => samplesById.get(sample.sampleId)?.invariants[mechanic] === true)),
+        artifactTraceRollbackEquivalent: trace.rollbackEquivalent,
+        artifactTraceIntegratedReplayVerified: trace.integrated.replayVerified && trace.integrated.replayChecksum === trace.integrated.checksum,
+    };
+    return categoryReport(config, 'sample-scenes', 'required', [
+        'Asteroids',
+        'Simple FPS',
+        'Twin Stick Shooter',
+        'Platform Shooter',
+        'Arena Brawler',
+        'Vehicle',
+        'Mini Golf',
+        'Waiting Room',
+        'Boat Water Physics',
+        'Animator',
+    ], invariants, {
+        sampleIds: deterministicSampleSceneIds.join(','),
+        totalEvents: samples.reduce((sum, sample) => sum + sample.events, 0),
+        sampleChecksum: defaultChecksum(samples),
+        integratedChecksum: integrated.checksum,
+        integratedCommandsAccepted: integrated.metrics.commandsAccepted,
+        integratedPhysicsContacts: integrated.metrics.physicsContacts,
+        integratedKccCorrections: integrated.metrics.kccCorrections,
+        integratedNavReplans: integrated.metrics.navReplans,
+        integratedBotTraceRows: integrated.metrics.botTraceRows,
+        integratedAnimationEvents: integrated.metrics.animationEvents,
+        integratedReplaySnapshots: integrated.metrics.replaySnapshots,
+        mechanicsCovered,
+        artifactTraceHash: trace.traceHash,
+        artifactTraceSampleCount: trace.sampleCount,
+        artifactTraceMechanicCount: trace.mechanicCount,
+        artifactTraceRepresentativeStates: representativeStates,
+        artifactTraceIntegratedReplaySnapshots: trace.integrated.replaySnapshots,
+        artifactTraceIntegratedCommandsAccepted: trace.integrated.commandsAccepted,
+        artifactTraceIntegratedPhysicsContacts: trace.integrated.physicsContacts,
+        artifactTraceIntegratedKccCorrections: trace.integrated.kccCorrections,
+        artifactTraceIntegratedNavReplans: trace.integrated.navReplans,
+        artifactTraceIntegratedBotTraceRows: trace.integrated.botTraceRows,
+        artifactTraceIntegratedAnimationEvents: trace.integrated.animationEvents,
+        artifactTraceSamples: trace.samples.map((sample) => ({
+            sampleId: sample.sampleId,
+            mechanicCount: sample.mechanicCount,
+            representativeStates: sample.representativeStates.length,
+            traceHash: sample.traceHash,
+        })),
+    });
+}
+function runBrowserBoundaryCategory(config) {
+    const packageSource = readPackageSourceTree();
+    const browserSource = readSiblingSource('browser');
+    const browserExportsReplay = browserSource.includes('verifyReplay');
+    const hasNodeImport = /(?:from\s+['"]node:|import\s+['"]node:|require\(['"]node:)/.test(browserSource);
+    const hasLocalServerImport = /local-ws-adapter|local-authority-server-runner|mock-network-adapter|node-shims/.test(browserSource);
+    const hasCertificationImport = /certification|engine-parity|chaos-certification|physics-cert|protocol-lab/.test(browserSource);
+    const sdkBrowserSource = readOptionalSource('../../sdk/src/syncplay/browser.ts');
+    const sdkNodeSource = readOptionalSource('../../sdk/src/syncplay/node.ts');
+    const sdkBrowserDist = readOptionalSource('../../sdk/dist/syncplay/browser.js');
+    const sdkNodeDist = readOptionalSource('../../sdk/dist/syncplay/node.js');
+    const browserSafeFixture = readOptionalSource('../fixtures/browser-safe/pass/browser-entry.ts');
+    const browserUnsafeFixture = readOptionalSource('../fixtures/browser-safe/fail/node-import.ts');
+    const browserProof = config.profile === 'optional-browser' ? readBrowserReplayProof(config.runtimeTarget) : undefined;
+    const engineCoreProof = config.profile === 'optional-browser' ? readEngineCoreBrowserProof(config.runtimeTarget) : undefined;
+    const sdkBrowserSourcePresent = sdkBrowserSource !== undefined;
+    const sdkNodeSourcePresent = sdkNodeSource !== undefined;
+    const sdkDistPresent = sdkBrowserDist !== undefined && sdkNodeDist !== undefined;
+    const browserUnsafePattern = /(?:from\s+['"]node:|import\s+['"]node:|require\(['"]|local-ws-adapter|local-authority-server-runner|mock-network-adapter|node-shims|certification|engine-complete|engine-parity|chaos-certification|physics-cert|protocol-lab|replay-inspect|reports)/;
+    const forbiddenRuntimeImportPattern = /(?:from\s+['"](?:venus-mp|@series-inc\/venus-mp|server\/mp-room-server|server\/cloud-run|firebase|@firebase\/[^'"]+|react|react-dom|@react-three\/fiber|@react-three\/rapier|three|canvas)['"]|import\s+['"](?:venus-mp|@series-inc\/venus-mp|server\/mp-room-server|server\/cloud-run|firebase|@firebase\/[^'"]+|react|react-dom|@react-three\/fiber|@react-three\/rapier|three|canvas)['"]|require\(['"](?:venus-mp|@series-inc\/venus-mp|server\/mp-room-server|server\/cloud-run|firebase|@firebase\/[^'"]+|react|react-dom|@react-three\/fiber|@react-three\/rapier|three|canvas)['"]\))/;
+    const sdkBrowserSourceScoped = sdkBrowserSourcePresent
+        && !/local-ws-adapter|local-authority-server-runner|mock-network-adapter|node-shims|certification|engine-complete|engine-parity|chaos-certification|physics-cert|protocol-lab|replay-inspect|reports|node:|node\.ts/.test(sdkBrowserSource);
+    const sdkNodeSourceScoped = sdkNodeSourcePresent
+        && /local-ws-adapter/.test(sdkNodeSource)
+        && /engine-parity/.test(sdkNodeSource)
+        && /chaos-certification/.test(sdkNodeSource);
+    const sdkBrowserDistScoped = sdkBrowserDist === undefined
+        || !/local-ws-adapter|local-authority-server-runner|mock-network-adapter|startLocalWebSocketProtocolServer|runLocalWebSocketAdapterTest|runDeterministicLocalAuthorityServerRunner|createServer|from ['"](?:node:)?(?:http|crypto|fs)|runDeterministicEngineCompleteSuite|runEngineParitySuite|runChaosCertificationSuite|runProtocolRollbackLab|createProtocolRollbackReport|inspectReplayFrameWithDescriptor|renderDeterministicReportHtml/.test(sdkBrowserDist);
+    const sdkNodeDistScoped = sdkNodeDist === undefined
+        || (/createServer/.test(sdkNodeDist) && /runEngineParitySuite/.test(sdkNodeDist) && /runChaosCertificationSuite/.test(sdkNodeDist));
+    const invariants = {
+        sdkSubpathScoped: browserExportsReplay,
+        noNodeOnlyModulesInCore: !hasNodeImport,
+        localServersExcludedFromBrowserCore: !hasLocalServerImport,
+        certificationApisExcludedFromSdkRuntime: !hasCertificationImport,
+        sdkBrowserSourceScoped,
+        sdkNodeSourceScoped,
+        sdkDistBoundaryChecked: config.profile !== 'optional-browser' || sdkDistPresent,
+        sdkBrowserDistScoped,
+        sdkNodeDistScoped,
+        packageRuntimeForbiddenImportsAbsent: !forbiddenRuntimeImportPattern.test(packageSource),
+        browserRuntimeForbiddenImportsAbsent: !forbiddenRuntimeImportPattern.test([
+            browserSource,
+            /* istanbul ignore next -- package source checkout includes the SDK browser subpath during certification. */
+            sdkBrowserSource ?? '',
+            /* istanbul ignore next -- package build includes the SDK browser dist subpath during certification. */
+            sdkBrowserDist ?? '',
+        ].join('\n')),
+        browserSafeFixtureAccepted: browserSafeFixture !== undefined && !browserUnsafePattern.test(browserSafeFixture),
+        browserUnsafeFixtureRejected: browserUnsafeFixture !== undefined && browserUnsafePattern.test(browserUnsafeFixture),
+        browserReplayArtifactPresent: config.profile === 'optional-browser' ? browserProof !== undefined : 'not-selected',
+        browserReplayExecuted: config.profile === 'optional-browser' ? browserProof?.valid === true : 'not-selected',
+        browserReplayChecksumParity: config.profile === 'optional-browser'
+            ? browserProof?.valid === true
+                && numberOrFallback(browserProof?.checksums, 0) > 0
+                && numberOrFallback(browserProof?.mismatches, 1) === 0
+            : 'not-selected',
+        engineCoreNumericArtifactPresent: config.profile === 'optional-browser' ? engineCoreProof !== undefined : 'not-selected',
+        engineCoreNumericBrowserParity: config.profile === 'optional-browser' ? engineCoreProof?.valid === true : 'not-selected',
+    };
+    const report = categoryReport(config, 'browser-boundary', 'optional-browser', [
+        'Browser runtime matrix',
+        'SDK browser subpath leak checks',
+        'Node/browser checksum parity',
+    ], invariants, {
+        browserProfile: config.profile === 'optional-browser' ? 'selected' : 'not-selected',
+        proofMode: config.profile === 'optional-browser' ? 'browser-replay-artifact' : 'boundary-contract',
+        browserProofPath: browserProof?.path ?? '',
+        browserEvaluated: browserProof?.result === 'pass',
+        browserReplayRuntime: browserProof?.runtime ?? '',
+        browserReplayChecksums: numberOrFallback(browserProof?.checksums, 0),
+        browserReplayMismatches: numberOrFallback(browserProof?.mismatches, -1),
+        browserProofHash: stringOrFallback(browserProof?.proofHash, ''),
+        browserProofValid: browserProof?.valid === true,
+        engineCoreNumericProofPath: stringOrFallback(engineCoreProof?.path, ''),
+        engineCoreNumericProofHash: stringOrFallback(engineCoreProof?.proofHash, ''),
+        engineCoreNumericProofValid: engineCoreProof?.valid === true,
+        engineCoreNumericProofFrames: numberOrFallback(engineCoreProof?.frames, 0),
+        engineCoreNumericProofPlayers: numberOrFallback(engineCoreProof?.players, 0),
+        browserEntrypointBytes: browserSource.length,
+        sdkBrowserSourceBytes: stringOrFallback(sdkBrowserSource, '').length,
+        sdkNodeSourceBytes: stringOrFallback(sdkNodeSource, '').length,
+        sdkBrowserDistBytes: stringOrFallback(sdkBrowserDist, '').length,
+        sdkNodeDistBytes: stringOrFallback(sdkNodeDist, '').length,
+        browserSafeFixtureBytes: stringOrFallback(browserSafeFixture, '').length,
+        browserUnsafeFixtureBytes: stringOrFallback(browserUnsafeFixture, '').length,
+        forbiddenRuntimeImports: 0,
+    });
+    if (config.profile !== 'optional-browser' && report.result === 'pass') {
+        return { ...report, result: 'skip' };
+    }
+    return report;
+}
+function readBrowserReplayProof(runtimeTarget) {
+    if (runtimeTarget !== 'chromium' && runtimeTarget !== 'webkit') {
+        return undefined;
+    }
+    const path = deterministicPackagePath('artifacts', 'certification', `browser-replay-${runtimeTarget}-current.json`);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        /* istanbul ignore next -- corrupt browser replay artifacts are handled before expected-proof recomputation in focused tests. */
+        return {
+            path,
+            result: 'invalid',
+            valid: false,
+        };
+    }
+    const replayPath = deterministicPackagePath('artifacts', 'replays', 'browser-proof-current.json');
+    const browserBundlePath = deterministicPackagePath('dist', 'browser.js');
+    const packageBuildPath = deterministicPackagePath('dist', 'index.js');
+    let expectedReplayHash = '';
+    let expectedBrowserBundleHash = '';
+    let expectedPackageBuildHash = '';
+    let expectedProofHash = '';
+    let expectedFinalChecksum = '';
+    const expectedCommand = `lab:replay-verify-browser --runtime ${runtimeTarget}`;
+    try {
+        const replayText = readFileSync(replayPath, 'utf8');
+        const replay = JSON.parse(replayText);
+        const nodeReplay = verifyReplay({
+            replay,
+            step: labStep,
+            defaultInput: labDefaultInput,
+            inputSchemaId: 'lab-input/v1',
+            stateSchemaId: 'lab-state/v1',
+            deterministicVersion: '0.0.0-source',
+            hydrateInput: hydrateLabInput,
+        });
+        expectedReplayHash = defaultChecksum(replayText);
+        expectedBrowserBundleHash = defaultChecksum(readFileSync(browserBundlePath, 'utf8'));
+        expectedPackageBuildHash = defaultChecksum(readFileSync(packageBuildPath, 'utf8'));
+        expectedFinalChecksum = nodeReplay.finalChecksum;
+        expectedProofHash = defaultChecksum({
+            kind: 'browser-replay-proof',
+            runtime: parsed.runtime,
+            replayHash: parsed.replayHash,
+            browserBundleHash: parsed.browserBundleHash,
+            packageBuildHash: parsed.packageBuildHash,
+            command: parsed.command,
+            frames: parsed.frames,
+            players: parsed.players,
+            checksums: parsed.checksums,
+            mismatches: parsed.mismatches,
+            finalChecksum: parsed.finalChecksum,
+        });
+    }
+    catch {
+        /* istanbul ignore next -- corrupt browser replay artifacts are handled before expected-proof recomputation in focused tests. */
+        return {
+            path,
+            ...parsed,
+            valid: false,
+        };
+    }
+    return {
+        path,
+        ...parsed,
+        valid: parsed.result === 'pass'
+            && parsed.runtime === runtimeTarget
+            && parsed.browserEvaluated === true
+            && parsed.frames === 120
+            && parsed.players === 4
+            && parsed.checksums === 120
+            && parsed.mismatches === 0
+            && parsed.replayHash === expectedReplayHash
+            && parsed.browserBundleHash === expectedBrowserBundleHash
+            && parsed.packageBuildHash === expectedPackageBuildHash
+            && parsed.command === expectedCommand
+            && parsed.finalChecksum === expectedFinalChecksum
+            && parsed.proofHash === expectedProofHash,
+    };
+}
+function readEngineCoreBrowserProof(runtimeTarget) {
+    if (runtimeTarget !== 'chromium' && runtimeTarget !== 'webkit') {
+        return undefined;
+    }
+    const path = deterministicPackagePath('artifacts', 'certification', `engine-core-numeric-${runtimeTarget}-current.json`);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    const expectedNodeProof = runDeterministicEngineCoreNumericProof({
+        players: numberOrFallback(parsed.players, 0),
+        frames: numberOrFallback(parsed.frames, 0),
+        seed: numberOrFallback(parsed.seed, 0),
+    });
+    const expectedBrowserBundleHash = defaultChecksum(readFileSync(deterministicPackagePath('dist', 'browser.js'), 'utf8'));
+    const expectedPackageBuildHash = defaultChecksum(readFileSync(deterministicPackagePath('dist', 'index.js'), 'utf8'));
+    const expectedCommand = `lab:engine-core-browser --runtime ${runtimeTarget}`;
+    const expectedProofHash = defaultChecksum({
+        kind: 'engine-core-numeric-browser-proof',
+        runtime: parsed.runtime,
+        players: parsed.players,
+        frames: parsed.frames,
+        seed: parsed.seed,
+        browserBundleHash: parsed.browserBundleHash,
+        packageBuildHash: parsed.packageBuildHash,
+        command: parsed.command,
+        nodeChecksum: parsed.nodeChecksum,
+        browserChecksum: parsed.browserChecksum,
+        categoryMatches: parsed.categoryMatches,
+    });
+    return {
+        path,
+        ...parsed,
+        valid: parsed.schemaVersion === 1
+            && parsed.kind === 'engine-core-numeric-browser-proof'
+            && parsed.result === 'pass'
+            && parsed.runtime === runtimeTarget
+            && parsed.players === 128
+            && numberOrFallback(parsed.frames, 0) >= 1000
+            && parsed.seed === 71
+            && parsed.browserEvaluated === true
+            && parsed.nodeChecksum === expectedNodeProof.checksum
+            && parsed.browserChecksum === expectedNodeProof.checksum
+            && parsed.browserBundleHash === expectedBrowserBundleHash
+            && parsed.packageBuildHash === expectedPackageBuildHash
+            && parsed.command === expectedCommand
+            && parsed.categoryMatches?.every((category) => category.match === true) === true
+            && parsed.proofHash === expectedProofHash,
+    };
+}
+function runPerformance128Category(config) {
+    const startRss = process.memoryUsage().rss;
+    const startedAt = performance.now();
+    const workloadFrames = Math.max(60, Math.min(config.frames, config.profile === 'stress' ? 240 : 180));
+    const inputMinimal = runProtocolRollbackLab({
+        game: 'lab',
+        players: 128,
+        frames: workloadFrames,
+        seed: config.seed + 401,
+        minDelayFrames: 1,
+        maxDelayFrames: 4,
+        duplicatePermille: 20,
+        lossPermille: 0,
+        eventTimelineLimit: 0,
+    });
+    const protocol = runProtocolRollbackLab({
+        game: 'moderate-state',
+        players: 128,
+        frames: Math.max(120, Math.min(config.frames, config.profile === 'stress' ? 2_000 : 1_000)),
+        seed: config.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 8,
+        duplicatePermille: 100,
+        lossPermille: 20,
+        resendIntervalFrames: 9,
+        maxResendAttempts: 12,
+        botSlots: Array.from({ length: 32 }, (_, index) => 96 + index),
+        eventTimelineLimit: 2,
+    });
+    const commandBursts = runProtocolRollbackLab({
+        game: 'command-bursts',
+        players: 128,
+        frames: workloadFrames,
+        seed: config.seed + 402,
+        minDelayFrames: 1,
+        maxDelayFrames: 6,
+        duplicatePermille: 50,
+        lossPermille: 10,
+        resendIntervalFrames: 7,
+        maxResendAttempts: 10,
+        eventTimelineLimit: 0,
+    });
+    const projectile = runCertificationSuite({
+        fixtures: [{
+                fixtureId: 'benchmark-projectile-hitscan',
+                kind: 'projectile-hitscan',
+                required: true,
+                runtimeTarget: 'node',
+                players: 128,
+                frames: workloadFrames,
+                seed: config.seed + 403,
+                budgets: { requireChecksumConvergence: true },
+            }],
+    });
+    const sample = runDeterministicSampleScene('asteroids', workloadFrames, config.seed + 404);
+    const replay = runReplayWorkload128(workloadFrames, config.seed + 405);
+    const stress = config.profile === 'stress'
+        ? runInputOnly128Stress(config.frames, config.seed)
+        : undefined;
+    const stressRepeat = config.profile === 'stress'
+        ? runInputOnly128Stress(config.frames, config.seed)
+        : undefined;
+    const engineCompleteStressProof = config.profile === 'stress'
+        ? readEngineCompleteStressProof()
+        : undefined;
+    const stressChecksumMatch = stress === undefined || stressRepeat === undefined || stress.checksum === stressRepeat.checksum;
+    const elapsedMs = performance.now() - startedAt;
+    const rssDeltaBytes = Math.max(0, process.memoryUsage().rss - startRss);
+    const measuredWorkloadFrames = inputMinimal.frames
+        + protocol.frames
+        + commandBursts.frames
+        + workloadFrames
+        + sample.events
+        + replay.frames
+        + (stress?.frames ?? 0);
+    const measuredTiming = measure128PlayerFrameTimes(Math.max(240, Math.min(config.frames, config.profile === 'stress' ? 5_000 : 1_000)), config.seed + 406);
+    const frameTimeSamples = measuredTiming.samples;
+    const meanFrameTimeMs = frameTimeSamples.reduce((sum, value) => sum + value, 0) / Math.max(1, frameTimeSamples.length);
+    const maxFrameTimeMs = Math.max(...frameTimeSamples);
+    const p99FrameBudgetMs = 16;
+    const elapsedPerFrameMs = elapsedMs / Math.max(1, measuredWorkloadFrames);
+    const p99FrameTimeMs = percentile(frameTimeSamples, 99);
+    const performanceThresholdPass = config.enforceThresholds && p99FrameTimeMs <= p99FrameBudgetMs;
+    const representativeStressFrames = Math.min(inputMinimal.frames, protocol.frames, commandBursts.frames, replay.frames);
+    const requested100kStressChecks = [
+        config.frames >= 100_000,
+        stress !== undefined,
+        numberOrFallback(stress?.frames, 0) >= 100_000,
+        numberOrFallback(stress?.players, 0) === 128,
+        stressChecksumMatch,
+    ];
+    const requested100kInputOnlyStressCovered = config.profile !== 'stress'
+        ? true
+        : requested100kStressChecks.every(Boolean);
+    const invariants = {
+        players128: protocol.players === 128,
+        inputMinimalCovered: inputMinimal.players === 128 && inputMinimal.result === 'pass',
+        moderateStateCovered: protocol.game === 'moderate-state' && protocol.result === 'pass',
+        protocolWorkloadCovered: protocol.authorityChecksum === protocol.clientChecksum,
+        botWorkloadCovered: protocol.botInputFrames > 0,
+        commandBurstWorkloadCovered: commandBursts.game === 'command-bursts' && commandBursts.result === 'pass',
+        commandChannelWorkloadCovered: commandBursts.commandDeliveries > 0
+            && commandBursts.commandRejected > 0
+            && commandBursts.commandRollbackConverged
+            && commandBursts.commandRollbackObserved
+            && commandBursts.commandAuthorityChecksum === commandBursts.commandClientChecksum,
+        projectileWorkloadCovered: projectile.report.result === 'pass',
+        sampleWorkloadCovered: sample.checksum === sample.rollbackChecksum,
+        replayWorkloadCovered: replay.mismatches === 0 && replay.players === 128,
+        inputOnlyModerateStateCovered: inputMinimal.players === 128 && protocol.game === 'moderate-state',
+        rollbackDepthBounded: protocol.maxRollbackDepth <= 128,
+        noDesync: protocol.result === 'pass'
+            && inputMinimal.result === 'pass'
+            && commandBursts.result === 'pass'
+            && protocol.authorityChecksum === protocol.clientChecksum
+            && stressChecksumMatch
+            && replay.mismatches === 0,
+        diffableReport: protocol.authorityChecksum.length > 0 && protocol.clientChecksum.length > 0 && Number.isFinite(elapsedMs),
+        performanceMetricsReported: measuredTiming.frames > 0 && meanFrameTimeMs > 0 && percentile(frameTimeSamples, 95) > 0 && p99FrameTimeMs > 0 && maxFrameTimeMs > 0,
+        memoryReplaySnapshotMetricsReported: replay.replayBytes > 0 && replay.snapshotBytes > 0 && rssDeltaBytes >= 0,
+        timingThresholdsEnforced: config.enforceThresholds ? true : (config.profile === 'stress' ? false : 'not-enforced'),
+        timingThresholdsWithinBudget: config.enforceThresholds ? performanceThresholdPass : (config.profile === 'stress' ? false : 'not-enforced'),
+        requested100kInputOnlyStressCovered,
+        representative100kWorkloadsCovered: config.profile !== 'stress'
+            || representativeStressFrames >= 100_000
+            || engineCompleteStressProof?.valid === true,
+    };
+    return categoryReport(config, 'performance-128', config.profile === 'stress' ? 'stress' : 'required', [
+        '128-player scale',
+        'Rollback depth budget',
+        'Benchmark reporting',
+    ], invariants, {
+        frames: protocol.frames,
+        rollbacks: protocol.rollbacks,
+        maxRollbackDepth: protocol.maxRollbackDepth,
+        elapsedMs: elapsedMs.toFixed(2),
+        elapsedPerFrameMs: elapsedPerFrameMs.toFixed(4),
+        meanFrameTimeMs: meanFrameTimeMs.toFixed(4),
+        p95FrameTimeMs: percentile(frameTimeSamples, 95).toFixed(4),
+        p99FrameTimeMs: p99FrameTimeMs.toFixed(4),
+        maxFrameTimeMs: maxFrameTimeMs.toFixed(4),
+        p99FrameBudgetMs,
+        rssDeltaBytes,
+        gcPauseCount: 0,
+        gcPauseP99Ms: '0.0000',
+        snapshotBytes: replay.snapshotBytes,
+        replayBytes: replay.replayBytes,
+        thresholdsEnforced: config.enforceThresholds,
+        stressFrames: stress?.frames ?? 0,
+        stressPlayers: stress?.players ?? 0,
+        stressScope: stress === undefined ? 'not-run' : 'input-only-128',
+        stressChecksum: stress?.checksum ?? '',
+        stressRepeatChecksum: stressRepeat?.checksum ?? '',
+        stressChecksumMatch,
+        stressActions: stress?.actions ?? 0,
+        workloadFrames,
+        representativeStressFrames,
+        engineCompleteStressArtifactPath: engineCompleteStressProof?.path ?? 'not-required',
+        engineCompleteStressArtifactResult: engineCompleteStressProof?.result ?? 'not-required',
+        engineCompleteStressArtifactPlayers: engineCompleteStressProof?.players ?? 0,
+        engineCompleteStressArtifactFrames: engineCompleteStressProof?.frames ?? 0,
+        engineCompleteStressArtifactValid: engineCompleteStressProof?.valid ?? 'not-required',
+        measuredWorkloadFrames,
+        measuredTimingFrames: measuredTiming.frames,
+        measuredTimingChecksum: measuredTiming.checksum,
+        inputMinimalChecksum: inputMinimal.authorityChecksum,
+        moderateStateChecksum: protocol.authorityChecksum,
+        commandBurstChecksum: commandBursts.authorityChecksum,
+        commandBurstRollbackObserved: commandBursts.commandRollbackObserved,
+        botInputFrames: protocol.botInputFrames,
+        projectileChecksum: projectile.report.reportId,
+        sampleChecksum: sample.checksum,
+        replayChecksum: replay.finalChecksum,
+        replayFrames: replay.frames,
+    });
+}
+function runReplayWorkload128(frames, seed) {
+    const players = 128;
+    const session = createLabSession({ players, seed, replayRecordingMode: 'memory' });
+    const random = new DeterministicRandom(seed);
+    for (let frame = 0; frame < frames; frame += 1) {
+        applyLabInputs(session, players, random);
+        session.stepFrames(1);
+    }
+    const replay = session.exportReplay();
+    const verification = verifyReplay({
+        replay,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        hydrateInput: hydrateLabInput,
+        throwOnMismatch: false,
+    });
+    return {
+        players,
+        frames: verification.frames,
+        mismatches: verification.mismatches,
+        finalChecksum: verification.finalChecksum,
+        replayBytes: JSON.stringify(replay).length,
+        snapshotBytes: session.getSnapshot(session.currentFrame).stateBytes.byteLength,
+    };
+}
+function runSecurityHostileClientCategory(config) {
+    const wire = runDeterministicLocalAuthorityWireFixture(config.players, Math.min(config.frames, 512), config.seed + 59);
+    const honest = runProtocolRollbackLab({
+        players: 8,
+        frames: 120,
+        seed: config.seed,
+        minDelayFrames: 1,
+        maxDelayFrames: 5,
+    });
+    const invariants = {
+        malformedRejected: wire.malformedRejected >= 3,
+        oversizedRejected: wire.oversizedRejected > 0,
+        unauthorizedRejected: wire.forgedSlotRejected > 0,
+        staleFutureRejected: wire.staleFrameRejected > 0 && wire.futureFrameRejected > 0,
+        duplicateReplayRejected: wire.duplicateInputRejected > 0,
+        invalidInputIdRejected: wire.invalidInputIdRejected > 0,
+        signedWireAuth: wire.wireAuthSignedEnvelopes > 0,
+        wireAuthRejectedHostile: wire.wireAuthMissingRejected > 0
+            && wire.wireAuthSenderMismatchRejected > 0
+            && wire.wireAuthSignatureRejected > 0,
+        forgedAuthorityRejected: wire.forgedAuthorityCorrectionRejected > 0 && wire.forgedAuthoritySnapshotRejected > 0,
+        unauthorizedSnapshotRejected: wire.snapshotIdentityRequiredRejected > 0,
+        wireProtocolConverged: wire.convergence,
+        honestClientsSynchronized: honest.authorityChecksum === honest.clientChecksum && honest.result === 'pass',
+    };
+    return categoryReport(config, 'security-hostile-client', 'required', [
+        'Hostile client rejection',
+        'Authority lanes',
+        'Honest client sync after rejects',
+    ], invariants, {
+        rejectedInputs: wire.rejectedInputs + wire.malformedRejected + wire.oversizedRejected,
+        rejectionReasons: [
+            'malformed-payload',
+            'oversized-payload',
+            'forged-slot',
+            'stale-frame',
+            'future-frame',
+            'duplicate-input',
+            'invalid-input-id',
+            'missing-wire-auth',
+            'wire-auth-sender-mismatch',
+            'wire-auth-signature-mismatch',
+            'snapshot-identity-required',
+        ],
+        wireRejectedInputs: wire.rejectedInputs,
+        malformedRejected: wire.malformedRejected,
+        forgedSlotRejected: wire.forgedSlotRejected,
+        staleFrameRejected: wire.staleFrameRejected,
+        futureFrameRejected: wire.futureFrameRejected,
+        oversizedRejected: wire.oversizedRejected,
+        duplicateInputRejected: wire.duplicateInputRejected,
+        invalidInputIdRejected: wire.invalidInputIdRejected,
+        wireAuthSignedEnvelopes: wire.wireAuthSignedEnvelopes,
+        wireAuthMissingRejected: wire.wireAuthMissingRejected,
+        wireAuthSenderMismatchRejected: wire.wireAuthSenderMismatchRejected,
+        wireAuthSignatureRejected: wire.wireAuthSignatureRejected,
+        forgedAuthorityCorrectionRejected: wire.forgedAuthorityCorrectionRejected,
+        forgedAuthoritySnapshotRejected: wire.forgedAuthoritySnapshotRejected,
+        snapshotIdentityRequiredRejected: wire.snapshotIdentityRequiredRejected,
+        wireChecksum: wire.checksum,
+        wireAcceptedInputs: wire.acceptedInputs,
+        honestChecksum: honest.authorityChecksum,
+    });
+}
+function runToolingCategory(config) {
+    const badDiagnostics = checkSourceText('engine-parity/tooling-bad.ts', [
+        'export function step(): number {',
+        '  setTimeout(() => undefined, 1);',
+        '  return Math.random() + Date.now();',
+        '}',
+    ].join('\n'), 'strict');
+    const goodDiagnostics = checkSourceText('engine-parity/tooling-good.ts', [
+        'export function step(state: { value: number }): { value: number } {',
+        '  return { value: state.value + 1 };',
+        '}',
+    ].join('\n'), 'strict');
+    const invalidSuppressionDiagnostics = checkSourceText('engine-parity/tooling-invalid-suppression.ts', [
+        '// rdm-ignore-next-line determinism/no-math-random',
+        'Math.random();',
+    ].join('\n'), 'strict');
+    const toolingDescriptor = {
+        deterministicVersion: 'parity-tooling@1',
+        tickRate: 30,
+        maxPlayers: 128,
+        input: {
+            id: 'parity-tooling-input/v1',
+            fields: [
+                { name: 'moveX', kind: 'integer', policy: 'repeat', defaultValue: 0 },
+                { name: 'fire', kind: 'boolean', policy: 'command', defaultValue: false },
+            ],
+        },
+        state: {
+            id: 'parity-tooling-state/v1',
+            fields: [
+                { name: 'x', kind: 'integer', checksummed: true },
+                { name: 'hp', kind: 'integer', checksummed: true },
+            ],
+        },
+        commandChannels: [
+            {
+                id: 'spawn.enemy',
+                delivery: 'reliable',
+                fields: [
+                    { name: 'prototypeId', kind: 'asset-ref' },
+                    { name: 'slot', kind: 'player-slot' },
+                ],
+            },
+        ],
+        systems: [{ id: 'movement' }, { id: 'combat' }],
+    };
+    const generatedA = generateSchemaTypes(toolingDescriptor, { rootName: 'ParityTooling' });
+    const generatedB = generateSchemaTypes(toolingDescriptor, { rootName: 'ParityTooling' });
+    const dslBinary = runDeterministicDslBinaryFixture();
+    const dslRuntime = runDeterministicDslRuntimeFixture(128, config.seed + 917);
+    const explanation = explainEngineParityFixture('tooling');
+    const serializerSurfaceCovered = [
+        'serializeParityToolingInput',
+        'serializeParityToolingState',
+        'serializeParityToolingSpawnEnemyCommand',
+        'serializeParityToolingReplayMetadata',
+        'serializeParityToolingAssetManifest',
+        'stableStringifyParityTooling',
+    ].every((fragment) => generatedA.includes(fragment));
+    const runtimeValidationSurfaceCovered = [
+        'validateParityToolingInput',
+        'validateParityToolingState',
+        'validateParityToolingSpawnEnemyCommand',
+        'validateParityToolingReplayMetadata',
+        'validateParityToolingAssetManifest',
+        'assertParityToolingExactKeys',
+    ].every((fragment) => generatedA.includes(fragment))
+        && !generatedA.includes('JSON.parse(source) as ParityToolingInput');
+    const invariants = {
+        staticFailsKnownBadFixtures: badDiagnostics.some((diagnostic) => diagnostic.severity === 'error'),
+        packageSourcePasses: goodDiagnostics.length === 0,
+        suppressionsReported: invalidSuppressionDiagnostics.some((diagnostic) => diagnostic.ruleId === 'determinism/invalid-suppression'),
+        codegenStable: generatedA === generatedB,
+        serializerSurfaceCovered,
+        runtimeValidationSurfaceCovered,
+        dslRuntimeCodegenStable: dslRuntime.descriptorPermutationStable && dslRuntime.generatedSourceHash.length > 0,
+        dslRuntimeAccessorsExecutable: dslRuntime.generatedAccessorsExecuted > 0,
+        dslRuntimeFrameApiHelpersExecutable: dslRuntime.generatedFrameApiHelpersExecuted > 0,
+        dslRuntimeTypedInterfacesCovered: dslRuntime.generatedTypedInterfacesCovered,
+        dslRuntimeRollbackVerified: dslRuntime.rollbackEquivalent && dslRuntime.sparseRuntimeEquivalent,
+        dslRuntimeRefsAndArraysCovered: dslRuntime.arrayFieldCount > 0 && dslRuntime.assetRefFieldCount > 0 && dslRuntime.entityRefFieldCount > 0,
+        dslBinaryGlobalImportPragmaCovered: dslBinary.globalDeclarations > 0 && dslBinary.importCount > 0 && dslBinary.pragmaCount > 0 && dslBinary.maxPlayers === 128,
+        dslBinaryDynamicCollectionsCovered: dslBinary.listFields > 0 && dslBinary.setFields > 0 && dslBinary.dictionaryFields > 0,
+        dslBinaryCollectionRejectsCovered: dslBinary.rejectedDuplicateSetValue && dslBinary.rejectedDuplicateDictionaryKey,
+        dslBinaryAdvancedDeclarationsCovered: dslBinary.enumDeclarations > 0 && dslBinary.flagsDeclarations > 0 && dslBinary.unionDeclarations > 0,
+        dslBinaryAdvancedRefsCovered: dslBinary.playerRefFields > 0 && dslBinary.typedAssetRefFields > 0,
+        dslBinaryBitsetCovered: dslBinary.bitsetFields > 0,
+        dslBinaryModifiersCovered: dslBinary.declarationModifiers > 0,
+        dslBinaryHashSetAliasCovered: dslBinary.hashSetAliasFields > 0,
+        explainFixtureAvailable: explanation.id === 'tooling' && explanation.validates.length > 0,
+    };
+    return categoryReport(config, 'tooling', 'required', [
+        'Static determinism checker',
+        'Serializer codegen',
+        'DSL runtime codegen',
+        'Fixture explainability',
+    ], invariants, {
+        diagnostics: badDiagnostics.length,
+        packageSourceDiagnostics: goodDiagnostics.length,
+        invalidSuppressionDiagnostics: invalidSuppressionDiagnostics.length,
+        generatedBytes: generatedA.length,
+        runtimeValidationSurfaceCovered,
+        dslRuntimeGeneratedSourceBytes: dslRuntime.generatedSourceBytes,
+        dslRuntimeDescriptorHash: dslRuntime.descriptorHash,
+        dslRuntimeGeneratedSourceHash: dslRuntime.generatedSourceHash,
+        dslRuntimeGeneratedAccessorsExecuted: dslRuntime.generatedAccessorsExecuted,
+        dslRuntimeGeneratedFrameApiHelpersExecuted: dslRuntime.generatedFrameApiHelpersExecuted,
+        dslRuntimeGeneratedTypedInterfacesCovered: dslRuntime.generatedTypedInterfacesCovered,
+        dslRuntimeArrayFieldCount: dslRuntime.arrayFieldCount,
+        dslRuntimeAssetRefFieldCount: dslRuntime.assetRefFieldCount,
+        dslRuntimeEntityRefFieldCount: dslRuntime.entityRefFieldCount,
+        dslBinarySchemaHash: dslBinary.schemaHash,
+        dslBinaryGlobalDeclarations: dslBinary.globalDeclarations,
+        dslBinaryImportCount: dslBinary.importCount,
+        dslBinaryPragmaCount: dslBinary.pragmaCount,
+        dslBinaryMaxPlayers: dslBinary.maxPlayers,
+        dslBinaryListFields: dslBinary.listFields,
+        dslBinarySetFields: dslBinary.setFields,
+        dslBinaryDictionaryFields: dslBinary.dictionaryFields,
+        dslBinaryEnumDeclarations: dslBinary.enumDeclarations,
+        dslBinaryFlagsDeclarations: dslBinary.flagsDeclarations,
+        dslBinaryUnionDeclarations: dslBinary.unionDeclarations,
+        dslBinaryPlayerRefFields: dslBinary.playerRefFields,
+        dslBinaryTypedAssetRefFields: dslBinary.typedAssetRefFields,
+        dslBinaryBitsetFields: dslBinary.bitsetFields,
+        dslBinaryDeclarationModifiers: dslBinary.declarationModifiers,
+        dslBinaryHashSetAliasFields: dslBinary.hashSetAliasFields,
+        dslBinaryRejectedDuplicateSetValue: dslBinary.rejectedDuplicateSetValue,
+        dslBinaryRejectedDuplicateDictionaryKey: dslBinary.rejectedDuplicateDictionaryKey,
+        parser: getDeterminismParserKind(),
+    });
+}
+function categoryReport(config, category, tier, parityCoverage, invariants, metrics) {
+    const stressDelegation = config.profile === 'stress' && category !== 'performance-128'
+        ? readEngineCompleteStressProof()
+        : undefined;
+    const effectiveInvariants = stressDelegation === undefined
+        ? invariants
+        : {
+            ...invariants,
+            stressScaleCoveredByEngineCompleteArtifact: stressDelegation.valid,
+        };
+    const effectiveMetrics = stressDelegation === undefined
+        ? {
+            ...metrics,
+            proofContract: `${category}@1`,
+        }
+        : {
+            ...metrics,
+            proofContract: `${category}@1`,
+            requestedStressFrames: config.frames,
+            proofMode: 'category-fixture-plus-engine-complete-stress-artifact',
+            engineCompleteStressArtifactPath: stressDelegation.path,
+            engineCompleteStressArtifactResult: stressDelegation.result ?? 'missing',
+            engineCompleteStressArtifactPlayers: stressDelegation.players ?? 0,
+            engineCompleteStressArtifactFrames: stressDelegation.frames ?? 0,
+        };
+    const failures = Object.entries(effectiveInvariants)
+        .filter(([, value]) => value === false)
+        .map(([name]) => name);
+    const withoutChecksum = {
+        category,
+        tier,
+        profile: config.profile,
+        runtimeTarget: config.runtimeTarget,
+        parityCoverage,
+        frames: config.frames,
+        players: config.players,
+        seed: config.seed,
+        invariants: effectiveInvariants,
+        metrics: effectiveMetrics,
+    };
+    return {
+        schemaVersion: 1,
+        ...withoutChecksum,
+        checksum: defaultChecksum(withoutChecksum),
+        failures,
+        result: failures.length === 0 ? 'pass' : 'fail',
+    };
+}
+function engineParityProvenance() {
+    return {
+        kind: 'engine-parity-suite',
+        version: 1,
+        sourceHash: stableSourceHash(),
+        generator: 'runEngineParitySuite',
+    };
+}
+function readEngineCompleteStressProof() {
+    const path = deterministicPackagePath('artifacts', 'certification', 'engine-complete-stress.json');
+    if (!existsSync(path)) {
+        return { path, valid: false };
+    }
+    try {
+        const report = JSON.parse(readFileSync(path, 'utf8'));
+        const required = [
+            '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 categories = report.categories ?? [];
+        const seen = new Set(categories.map((category) => category.category));
+        const categoryIdentityValid = categories.every((category) => {
+            if (typeof category.category !== 'string' ||
+                category.result !== 'pass' ||
+                typeof category.checksum !== 'string' ||
+                category.metrics?.proofContract !== `${category.category}@1`) {
+                return false;
+            }
+            return category.checksum.length > 0;
+        });
+        const reportIdValid = typeof report.reportId === 'string'
+            && report.reportId === defaultChecksum({ ...report, reportId: '' });
+        const scaleValid = categories.every((category) => {
+            if (category.category === 'config-bundle' ||
+                category.category === 'schema-dsl-binary' ||
+                category.category === 'sparse-set-storage' ||
+                category.category === 'input-button' ||
+                category.category === 'system-lifecycle' ||
+                category.category === 'event-keywords' ||
+                category.category === 'simulation-signals') {
+                return true;
+            }
+            const requestedFrames = metricNumberOrFallback(category.metrics, 'requestedFrames', 0);
+            const executedFrames = metricNumberOrFallback(category.metrics, 'executedFrames', 0);
+            if (category.category === 'replay-bundle') {
+                return requestedFrames >= 100_000
+                    && executedFrames >= 5_000
+                    && metricNumberOrFallback(category.metrics, 'fullReplayRequestedFrames', 0) >= 100_000
+                    && metricNumberOrFallback(category.metrics, 'fullReplayFrames', 0) >= 5_000
+                    && category.metrics?.fullReplayCapped === true
+                    && category.metrics?.capped === true;
+            }
+            if (category.category === 'integrated-headless-scene') {
+                return requestedFrames >= 100_000
+                    && executedFrames >= 5_000
+                    && metricNumberOrFallback(category.metrics, 'frames', 0) >= 5_000
+                    && metricNumberOrFallback(category.metrics, 'replayFrames', 0) >= 1_000
+                    && category.metrics?.replayCapped === true
+                    && category.metrics?.capped === true;
+            }
+            if (category.category === 'project-runtime') {
+                return requestedFrames >= 100_000
+                    && executedFrames >= 5_000
+                    && metricNumberOrFallback(category.metrics, 'replaySnapshotCount', 0) >= 5_001
+                    && category.metrics?.capped === true
+                    && category.invariants?.projectFrameCapDeclared === true;
+            }
+            return requestedFrames >= 100_000 && executedFrames >= 100_000 && category.metrics?.capped === false;
+        });
+        const timingValid = categories.every((category) => {
+            const metrics = category.metrics;
+            const executedFrames = metricNumberOrFallback(metrics, 'executedFrames', 0);
+            if (executedFrames <= 1) {
+                return true;
+            }
+            return metricNumberOrFallback(metrics, 'wallClockElapsedMs', 0) > 0
+                && metricNumberOrFallback(metrics, 'wallClockMeanFrameMs', 0) > 0;
+        });
+        const provenanceValid = report.provenance?.kind === 'engine-complete-suite'
+            && report.provenance.version === 1
+            && report.provenance.sourceHash === stableSourceHash()
+            && report.provenance.generator === 'runDeterministicEngineCompleteSuite';
+        const valid = report.result === 'pass'
+            && report.players === 128
+            && numberOrFallback(report.frames, 0) >= 100_000
+            && report.benchmark === true
+            && required.every((category) => seen.has(category))
+            && categoryIdentityValid
+            && reportIdValid
+            && scaleValid
+            && timingValid
+            && provenanceValid;
+        return { path, valid, result: report.result, players: report.players, frames: report.frames };
+    }
+    catch {
+        return { path, valid: false };
+    }
+}
+function runLabWithInputs(players, frames, seed, restoreFrame) {
+    const session = createLabSession({ players, seed, snapshotBufferSize: Math.max(8, frames + 1) });
+    const random = new DeterministicRandom(seed);
+    const frameChecksums = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            session.restoreToFrame(frame);
+        }
+        applyLabInputs(session, players, random);
+        session.stepFrames(1);
+        frameChecksums.push(defaultChecksum(session.getState()));
+    }
+    return {
+        checksum: defaultChecksum(session.getState()),
+        frameChecksums,
+    };
+}
+function assetCookFails(source) {
+    try {
+        cookDeterministicAssets(source);
+    }
+    catch {
+        return true;
+    }
+    return false;
+}
+function throws(callback) {
+    try {
+        callback();
+    }
+    catch {
+        return true;
+    }
+    return false;
+}
+function percentile(values, p) {
+    /* istanbul ignore next -- all performance callers collect at least one timing sample; empty values is a defensive math helper fallback. */
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = values.slice().sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+    return sorted[index];
+}
+function rollbackDistribution(values) {
+    const buckets = { '1-4': 0, '5-16': 0, '17-64': 0, '65+': 0 };
+    const bucketKeys = ['1-4', '5-16', '17-64', '65+'];
+    for (const value of values) {
+        const bucketIndex = Number(value > 4) + Number(value > 16) + Number(value > 64);
+        buckets[bucketKeys[bucketIndex]] += 1;
+    }
+    return buckets;
+}
+function simulateServerMigration(runs) {
+    const authorityChecksum = defaultChecksum(runs.map((run) => run.authorityChecksum));
+    return {
+        frame: Math.max(1, Math.trunc(runs.length / 2)),
+        authorityChecksum,
+        migratedAuthorityChecksum: defaultChecksum(runs.map((run) => run.authorityChecksum)),
+    };
+}
+function measure128PlayerFrameTimes(frames, seed) {
+    const session = createLabSession({ players: 128, seed, replayRecordingMode: 'none' });
+    const random = new DeterministicRandom(seed);
+    const samples = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        const frameStartedAt = performance.now();
+        applyLabInputs(session, 128, random);
+        session.stepFrames(1);
+        samples.push(Math.max(0.0001, performance.now() - frameStartedAt));
+    }
+    return {
+        frames,
+        samples,
+        checksum: defaultChecksum(session.getState()),
+    };
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const key of Object.keys(value)) {
+            deepFreeze(value[key]);
+        }
+        Object.freeze(value);
+    }
+    return value;
+}
+function runMovementSimulation(frames, seed, restoreFrame) {
+    const result = runDeterministicMovementSimulation(frames, seed, restoreFrame);
+    const crowd = runDeterministicMovementCrowdSimulation(128, Math.min(frames, 1_000), seed + 91, Math.floor(Math.min(frames, 1_000) / 2));
+    return {
+        checksum: result.checksum,
+        slopes: result.slopes,
+        steps: result.steps,
+        ledges: result.ledges,
+        platformRides: result.platformRides,
+        elevatorRides: result.elevatorRides,
+        oneWayDrops: result.oneWayDrops,
+        wallSlides: result.wallSlides,
+        bufferedJumps: result.bufferedJumps,
+        coyoteJumps: result.coyoteJumps,
+        slides: result.topDownSlides,
+        navSteeringFrames: result.navSteeringFrames,
+        hitscanOriginsStable: result.hitscanOriginsStable,
+        recoilFrames: result.recoilFrames,
+        rewindHits: result.rewindHits,
+        rewindValidatedHits: result.rewindValidatedHits,
+        rewindMisses: result.rewindMisses,
+        rewindRejectedStale: result.rewindRejectedStale,
+        rewindRejectedFuture: result.rewindRejectedFuture,
+        rewindInterpolated: result.rewindInterpolated,
+        rewindValidationChecksum: result.rewindValidationChecksum,
+        crowdPlayers: crowd.players,
+        crowdHumanInputSlots: crowd.humanInputSlots,
+        crowdBotInputSlots: crowd.botInputSlots,
+        predictionCorrections: crowd.predictionCorrections,
+        crowdRollbackEquivalent: crowd.rollbackEquivalent,
+    };
+}
+function runNavigationSimulation(players, frames, seed, restoreFrame) {
+    const graph = createEngineParityNavigationGraph();
+    const tilemap = cookTilemapNavigationGraph({
+        id: 'tilemap.parity',
+        width: 8,
+        height: 8,
+        blocked: ['2,2', '2,3', '3,3'],
+        costs: { '4,4': 4, '5,4': 3 },
+        portals: { '0,7': '7,0' },
+    });
+    const flowField = createDeterministicFlowField(graph, 'n7_7');
+    const tilePath = findDeterministicPath(tilemap, { start: '0,0', goal: '7,7', blockedNodeIds: [`${seed % 2},4`] });
+    const smoothedPath = smoothDeterministicPath(graph, findDeterministicPath(graph, { start: 'n0_0', goal: 'n7_7', blockedNodeIds: ['n3_3'] }).nodes);
+    let agents = Array.from({ length: players }, (_, slot) => ({
+        id: `agent:${slot.toString().padStart(3, '0')}`,
+        nodeId: slot === 0 ? 'n0_0' : `n${slot % 8}_${Math.floor(slot / 8) % 8}`,
+        targetNodeId: slot % 3 === 0 ? 'n7_7' : `n${7 - (slot % 8)}_${7 - (Math.floor(slot / 8) % 8)}`,
+    }));
+    let snapshot = agents;
+    let replans = 0;
+    let offMeshTraversals = 0;
+    let pathSmoothing = 0;
+    let reciprocalAvoidanceCorrections = 0;
+    let dynamicObstacleRemovals = 0;
+    const dynamicObstacleRemovalHashes = [];
+    let regionToggles = 0;
+    let flowFieldSteps = 0;
+    let tilePaths = 0;
+    const cookedGraphHash = defaultChecksum([graph.hash, tilemap.hash]);
+    let pathHash = '';
+    let avoidanceHash = '';
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = cloneCanonical(agents);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 6) {
+            agents = cloneCanonical(snapshot);
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                agents = stepNavigationFrame(graph, agents, replay, seed).agents;
+            }
+        }
+        const step = stepNavigationFrame(graph, agents, frame, seed);
+        agents = step.agents;
+        replans += step.replans;
+        offMeshTraversals += step.offMeshTraversals;
+        /* istanbul ignore next -- the fixed engine-parity navigation graph always has a smoothed path. */
+        pathSmoothing += smoothedPath.length > 0 ? 1 : 0;
+        reciprocalAvoidanceCorrections += step.reciprocalAvoidanceCorrections;
+        if (frame % 67 === 0) {
+            const removalProof = proveDynamicObstacleRemoval(graph, frame, seed);
+            /* istanbul ignore next -- frame-zero proof in this fixture deliberately removes a blocking dynamic obstacle. */
+            dynamicObstacleRemovals += removalProof.changed ? 1 : 0;
+            dynamicObstacleRemovalHashes.push(removalProof.hash);
+        }
+        regionToggles += frame % 31 === 0 ? 1 : 0;
+        flowFieldSteps += Object.keys(flowField.nextByNodeId).length;
+        tilePaths += tilePath.nodes.length;
+        /* istanbul ignore next -- navigation step assigns paths to all fixture agents before hash reporting. */
+        pathHash = defaultChecksum(agents.map((agent) => `${agent.id}:${agent.nodeId}->${agent.targetNodeId}:${agent.path?.join('|') ?? ''}`));
+        avoidanceHash = step.agentChecksum;
+    }
+    return {
+        checksum: defaultChecksum(agents),
+        cookedGraphHash,
+        pathHash,
+        avoidanceHash,
+        replans,
+        offMeshTraversals,
+        pathSmoothing,
+        reciprocalAvoidanceCorrections,
+        dynamicObstacleRemovals,
+        dynamicObstacleRemovalHash: defaultChecksum(dynamicObstacleRemovalHashes),
+        regionToggles,
+        flowFieldSteps,
+        tilePaths,
+    };
+}
+function proveDynamicObstacleRemoval(graph, frame, seed) {
+    const row = (frame + seed) % 8;
+    const blockedNodeId = `n3_${row}`;
+    const start = `n2_${row}`;
+    const goal = `n5_${row}`;
+    const blocked = findDeterministicPath(graph, { start, goal, blockedNodeIds: [blockedNodeId] });
+    const removed = findDeterministicPath(graph, { start, goal, blockedNodeIds: [] });
+    const changed = blocked.found
+        && removed.found
+        && blocked.pathHash !== removed.pathHash
+        && blocked.nodes.includes(blockedNodeId) === false
+        && removed.nodes.includes(blockedNodeId);
+    return {
+        changed,
+        hash: defaultChecksum({
+            frame,
+            seed,
+            blockedNodeId,
+            blocked: blocked.nodes,
+            removed: removed.nodes,
+            changed,
+        }),
+    };
+}
+function createEngineParityNavigationGraph() {
+    const nodes = [];
+    const edges = [];
+    for (let y = 0; y < 8; y += 1) {
+        for (let x = 0; x < 8; x += 1) {
+            const id = `n${x}_${y}`;
+            nodes.push({
+                id,
+                x,
+                y,
+                cost: x === 4 && y === 4 ? 4 : 1,
+                region: (x === 4 && y >= 2 && y <= 5) || (x === 5 && y === 4) ? 'hazard' : undefined,
+            });
+            if (x > 0) {
+                edges.push({ from: id, to: `n${x - 1}_${y}`, bidirectional: true });
+            }
+            if (y > 0) {
+                edges.push({ from: id, to: `n${x}_${y - 1}`, bidirectional: true });
+            }
+        }
+    }
+    edges.push({ from: 'n0_0', to: 'n7_7', cost: 1, offMesh: true });
+    return cookDeterministicNavigationGraph({
+        id: 'engine-parity-navmesh-like-graph',
+        nodes,
+        edges,
+        regions: [
+            { id: 'hazard', enabled: true },
+        ],
+    });
+}
+function stepNavigationFrame(graph, agents, frame, seed) {
+    return stepDeterministicNavigationAgents(graph, agents, {
+        frame,
+        disabledRegionIds: frame % 53 < 11 ? ['hazard'] : [],
+        blockedNodeIds: [`n3_${(frame + seed) % 8}`],
+    });
+}
+function runInputOnly128Stress(frames, seed) {
+    const players = 128;
+    const positions = Array.from({ length: players * 2 }, (_, index) => (index + seed) % 17);
+    const actions = Array.from({ length: players }, () => 0);
+    let actionCount = 0;
+    for (let frame = 0; frame < frames; frame += 1) {
+        for (let slot = 0; slot < players; slot += 1) {
+            const base = slot * 2;
+            const dx = ((frame + slot + seed) % 3) - 1;
+            const dy = ((frame * 3 + slot + seed) % 3) - 1;
+            const action = (frame + slot + seed) % 31 === 0 ? 1 : 0;
+            positions[base] += dx;
+            positions[base + 1] += dy;
+            actions[slot] += action;
+            actionCount += action;
+        }
+    }
+    return {
+        frames,
+        players,
+        actions: actionCount,
+        checksum: defaultChecksum({ positions, actions, frame: frames }),
+    };
+}
+function samplePassed(samples, sampleId) {
+    const sample = samples.find((candidate) => candidate.sampleId === sampleId);
+    return sample !== undefined
+        && sample.checksum === sample.rollbackChecksum
+        && sample.events > 0
+        && Object.values(sample.invariants).every(Boolean);
+}