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

package/dist/cjs/engine-parity-matrix.js

@@ -0,0 +1,874 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateEngineParityMatrixResult = evaluateEngineParityMatrixResult;
+exports.createEngineParityMatrixReport = createEngineParityMatrixReport;
+exports.stableEngineParityMatrixJson = stableEngineParityMatrixJson;
+const canonical_js_1 = require("./canonical.js");
+function evaluateEngineParityMatrixResult(summary) {
+    return summary.unsupportedRequiredCliGaps > 0
+        ? 'fail'
+        : summary.requiredOpenCliGaps > 0
+            ? 'warn'
+            : 'pass';
+}
+function createEngineParityMatrixReport(evidence = {}) {
+    const entries = applyEngineParityEvidence(engineParityMatrixEntries, evidence);
+    const byStatus = statusCounts(entries);
+    const requiredOpenCliGaps = entries.filter((entry) => entry.requiredForCliParity
+        && entry.status !== 'project-certified'
+        && entry.status !== 'non-goal').length;
+    const unsupportedRequiredCliGaps = entries.filter((entry) => entry.requiredForCliParity
+        && entry.canCloseWithCli
+        && entry.status === 'unsupported').length;
+    const summary = {
+        entries: entries.length,
+        requiredForCliParity: entries.filter((entry) => entry.requiredForCliParity).length,
+        canCloseWithCli: entries.filter((entry) => entry.canCloseWithCli).length,
+        byStatus,
+        requiredOpenCliGaps,
+        unsupportedRequiredCliGaps,
+    };
+    const withoutId = {
+        schemaVersion: 1,
+        kind: 'engine-parity-matrix',
+        reportId: '',
+        summary,
+        entries,
+        result: evaluateEngineParityMatrixResult(summary),
+    };
+    return {
+        ...withoutId,
+        reportId: (0, canonical_js_1.defaultChecksum)(withoutId),
+    };
+}
+function stableEngineParityMatrixJson(report) {
+    return `${(0, canonical_js_1.canonicalStringify)(report)}\n`;
+}
+function applyEngineParityEvidence(entries, evidence) {
+    return entries.map((entry) => {
+        if (entry.id === 'typed-frame-runtime' && typedFrameRuntimeEvidencePasses(evidence.projectRuntime)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:project runtime descriptor and generated runtime source certified at 128 players and 5000 frames',
+                'artifact:project game-state replay runtime, command channel, event channel, and self-contained replay verified',
+            ]);
+        }
+        if (entry.id === 'project-level-certification' && projectRuntimeEvidencePasses(evidence.projectRuntime)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:engine-complete project-runtime passed at 128 players and 5000 frames',
+                'artifact:project runtime replay and self-contained replay both verified',
+            ]);
+        }
+        if (entry.id === 'input-command-protocol' && commandProtocolEvidencePasses(evidence.authority)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:local-authority server accepted, acked, resent, and reordered reliable commands in the live wire session',
+                'artifact:reliable command loss, duplicate rejection, rollback convergence, and command-effect checksums verified',
+            ]);
+        }
+        if (entry.id === 'authority-reconnect-latejoin' && authorityEvidencePasses(evidence.authority)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:local-authority server proof passed at 128 players and 1000 frames',
+                'artifact:migration restore, convergence, hostile rejection, and command effects verified',
+            ]);
+        }
+        if (entry.id === 'replay-debugging' && replayDebuggingEvidencePasses(evidence.replayDebugging)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:chaos resync replay bundles verify from cold start with semantic replay',
+                'artifact:chaos first-divergence minimized desync bundle reports a concrete first mismatch frame',
+            ]);
+        }
+        if (entry.id === 'browser-sdk-boundary' && browserSdkEvidencePasses(evidence.browserSdk)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:static determinism artifact audit passed for browser replay, engine-core browser, and SDK test app proofs',
+                'artifact:Chromium browser replay, 128-player engine-core numeric proof, and SDK rendered canvas proof verified',
+            ]);
+        }
+        if (entry.id === 'lag-compensation' && lagCompAuthorityEvidencePasses(evidence.authority)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:local-authority server accepted lag-compensated shot commands through the live command path',
+                'artifact:lag-compensated command hits, forged timing rejections, and restore/replay checksum equivalence verified',
+            ]);
+        }
+        if (entry.id === 'samples' && sampleEvidencePasses(evidence.samples)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:sample-scene category passed with 128-player integrated trace evidence',
+                'artifact:per-sample representative state traces, rollback checksums, and integrated replay counters certified',
+            ]);
+        }
+        if (entry.id === 'assets-config-prototypes' && assetConfigEvidencePasses(evidence.assetConfig)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:asset/config categories certify inherited prototypes, dynamic collections, map spawn materialization, and rebake invalidation',
+                'artifact:descriptor-backed prototype runtime validation and config identity/tamper rejection pass in required-full parity suite',
+            ]);
+        }
+        if (entry.id === 'animation' && animationEvidencePasses(evidence.animation)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:animation category certifies blend tree sampling, animation layers, root motion, event reconstruction, and rollback equivalence',
+                'artifact:engine-complete animation fixture records layer pose, root motion, reconstructed event, normalized clip-time, and blend-weight hashes',
+            ]);
+        }
+        if (entry.id === 'bots' && botEvidencePasses(evidence.bots)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:bot category certifies 128-player bot replacement, rollback equivalence, BT services, utility curves, nested considerations, momentum, and cooldowns',
+                'artifact:bot document trace records advanced behavior service and utility coverage counters with zero failures',
+            ]);
+        }
+        if (entry.id === 'physics' && physicsEvidencePasses(evidence.physics)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:engine-complete physics3d certifies full-step no-fast proof mode, callback lifecycle, scheduled queries, shape casts, stack stability, and rollback equivalence',
+                'artifact:physics metrics include full-step contact/query timings, mesh static collider coverage, angular geometry coverage, and zero optimized stress frames',
+            ]);
+        }
+        if (entry.id === 'kcc-movement' && kccEvidencePasses(evidence.kcc)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:engine-complete kcc3d certifies full-step no-fast proof mode, 128-player KCC, swept collisions, physics queries, callback filtering, and rollback equivalence',
+                'artifact:KCC adversarial fixture covers thin walls, corners, ledges, moving platform edge transfers, slope-limit rejection, and configurable controller geometry',
+            ]);
+        }
+        if (entry.id === 'navigation' && navigationEvidencePasses(evidence.navigation)) {
+            return closeEntryWithEvidence(entry, [
+                'artifact:engine-complete navmesh certifies 128 agents, imported navmesh order stability, off-mesh traversal lifecycle, layered 3D lookup, dynamic regions, and rollback equivalence',
+                'artifact:navigation metrics include dense avoidance corrections, velocity-obstacle prediction/order validation, portal/spawn validation, and layered vertical off-mesh traversal',
+            ]);
+        }
+        return entry;
+    });
+}
+function closeEntryWithEvidence(entry, evidence) {
+    return {
+        ...entry,
+        status: 'project-certified',
+        currentEvidence: [...entry.currentEvidence, ...evidence],
+        gaps: [],
+        nextCliWork: [],
+    };
+}
+function typedFrameRuntimeEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 5_000
+        && evidence.projectRuntimePassed
+        && evidence.descriptorCertified
+        && evidence.generatedRuntimeSourceCertified
+        && evidence.replayAcceptsGeneratedRuntimeSourceHash
+        && evidence.replayUsesProjectGameStateRuntime
+        && evidence.replayRuntimeVerified
+        && evidence.selfContainedReplayRuntimeVerified
+        && evidence.replayRuntimeCoversProjectCommands
+        && evidence.replayRuntimeCoversProjectEvents
+        && evidence.generatedRuntimeSourceHash.length > 0
+        && evidence.runtimeDescriptorHash.length > 0
+        && evidence.replaySystemId === 'project-game-state-runtime-replay-v1'
+        && evidence.replayRuntimeCommandChannels >= 1
+        && evidence.replayRuntimeEventChannels >= 1;
+}
+function projectRuntimeEvidencePasses(evidence) {
+    return evidence !== undefined
+        && typedFrameRuntimeEvidencePasses(evidence)
+        && evidence.projectRuntimePassed
+        && evidence.assetsConfigCertified
+        && evidence.botNavAnimationCertified;
+}
+function authorityEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 1_000
+        && evidence.serverEvaluated
+        && evidence.migrationRestored
+        && evidence.convergence
+        && evidence.disconnects >= 1
+        && evidence.reconnects >= 1
+        && evidence.lateJoins >= 1
+        && evidence.spectators >= 1
+        && evidence.snapshotMaxAgeFrames > 0
+        && evidence.wireSnapshotRequestEnvelopes >= 2
+        && evidence.wireSnapshotOfferEnvelopes >= 2
+        && evidence.wireSnapshotChunkEnvelopes >= 2
+        && evidence.wireSnapshotCompleteEnvelopes >= 2
+        && evidence.wireSnapshotNegotiationCompletesApplied >= 2
+        && evidence.wireSnapshotsApplied >= 4
+        && evidence.wireAcceptedCommands >= evidence.frames * 2
+        && evidence.wireRejectedCommands >= 2
+        && evidence.wireSpectatorCommandsRejected >= 2
+        && evidence.commandEffectSubmissions >= evidence.frames * 2
+        && evidence.commandEffectValue > 0
+        && evidence.commandEffectChecksum.length > 0
+        && evidence.commandEffectProjectionChecksum.length > 0
+        && evidence.failures.length === 0;
+}
+function commandProtocolEvidencePasses(evidence) {
+    if (!authorityEvidencePasses(evidence) || evidence === undefined) {
+        return false;
+    }
+    return evidence.reliableCommandAcked >= evidence.frames
+        && evidence.reliableCommandResent >= 1
+        && evidence.reliableCommandLossesInjected >= 1
+        && evidence.reliableCommandDuplicatesRejected >= 1
+        && evidence.reliableCommandReordersObserved >= 1
+        && evidence.reliableCommandRollbackConverged;
+}
+function lagCompAuthorityEvidencePasses(evidence) {
+    if (!authorityEvidencePasses(evidence) || evidence === undefined) {
+        return false;
+    }
+    return true
+        && evidence.lagCompCommandSubmissions >= evidence.frames * 2
+        && evidence.lagCompAcceptedShots >= evidence.frames * 2
+        && evidence.lagCompHitCommands >= evidence.frames * 2
+        && evidence.lagCompInvalidShotCommands >= 2
+        && evidence.lagCompForgedTimingRejected >= 2
+        && evidence.lagCompReplayChecksum.length > 0
+        && evidence.lagCompRestoredChecksum === evidence.lagCompReplayChecksum
+        && evidence.lagCompRollbackEquivalent;
+}
+function replayDebuggingEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.verifiedResyncBundles >= 3
+        && evidence.semanticReplayFrames > 0
+        && evidence.minimizedDesyncBundles >= 1
+        && evidence.minimizedDesyncFirstMismatchFrame >= 0
+        && evidence.failures.length === 0;
+}
+function browserSdkEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.staticAuditPassed
+        && evidence.browserReplayVerified
+        && evidence.browserReplayFrames >= 120
+        && evidence.browserReplayPlayers >= 4
+        && evidence.engineCoreBrowserVerified
+        && evidence.engineCorePlayers === 128
+        && evidence.engineCoreFrames >= 1_000
+        && evidence.engineCoreCategoryMatches >= 3
+        && evidence.sdkTestAppVerified
+        && evidence.sdkCanvasRendered
+        && evidence.failures.length === 0;
+}
+function sampleEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 1_000
+        && evidence.sampleCategoryPassed
+        && evidence.allMechanicsCovered
+        && evidence.integratedHeadlessSceneCovered
+        && evidence.integratedReplayVerified
+        && evidence.integratedRollbackEquivalent
+        && evidence.artifactTracePresent
+        && evidence.artifactTraceAllSamplesCovered
+        && evidence.artifactTraceMechanicsCovered
+        && evidence.artifactTraceRollbackEquivalent
+        && evidence.artifactTraceIntegratedReplayVerified
+        && evidence.artifactTraceSampleCount >= 10
+        && evidence.artifactTraceMechanicCount >= 80
+        && evidence.artifactTraceRepresentativeStates >= 30
+        && evidence.artifactTraceIntegratedReplaySnapshots > 0
+        && evidence.artifactTraceHash.length > 0
+        && evidence.failures.length === 0;
+}
+function assetConfigEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 1_000
+        && evidence.assetCategoryPassed
+        && evidence.configCategoryPassed
+        && evidence.descriptorBackedPrototypeValidation
+        && evidence.compoundPrototypeInheritanceCovered
+        && evidence.dynamicCollectionAllocationCovered
+        && evidence.mapSpawnMaterializationCovered
+        && evidence.mapRebakeInvalidationCovered
+        && evidence.configInheritedPrototypeMaterialized
+        && evidence.configDynamicCollectionsMaterialized
+        && evidence.configMapMaterializationStable
+        && evidence.configMapRebakeInvalidated
+        && evidence.runtimeValidatedPrototypeEntities >= 4
+        && evidence.runtimeInjectedPrototypeComponents >= 12
+        && evidence.assetMapMaterializedEntityCount >= 4
+        && evidence.configMapMaterializedEntityCount >= 2
+        && evidence.mapBakeHash.length > 0
+        && evidence.configMapBakeHash.length > 0
+        && evidence.failures.length === 0;
+}
+function animationEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 1_000
+        && evidence.animationCategoryPassed
+        && evidence.stateTransitionsCovered
+        && evidence.exitFrameTransitionsCovered
+        && evidence.transitionBlendCovered
+        && evidence.triggerLatchCovered
+        && evidence.animationEventsEmitted
+        && evidence.normalizedClipTimeCovered
+        && evidence.sampledPoseCovered
+        && evidence.blendTreeCovered
+        && evidence.animationLayersCovered
+        && evidence.rootMotionCovered
+        && evidence.eventReconstructionCovered
+        && evidence.rollbackEquivalent
+        && evidence.blendTreeFrames > 0
+        && evidence.layerPoseFrames > 0
+        && evidence.rootMotionFrames > 0
+        && evidence.reconstructedEvents > 0
+        && evidence.reconstructedEventHash.length > 0
+        && evidence.failures.length === 0;
+}
+function botEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 1_000
+        && evidence.botCategoryPassed
+        && evidence.player128BotReplacement
+        && evidence.rollbackEquivalent
+        && evidence.behaviorServicesCovered
+        && evidence.utilityCurvesCovered
+        && evidence.utilityNestedCovered
+        && evidence.utilityMomentumCovered
+        && evidence.utilityCooldownCovered
+        && evidence.botDocumentBehaviorServicesCovered
+        && evidence.botDocumentUtilityCurvesCovered
+        && evidence.botDocumentUtilityNestedCovered
+        && evidence.botDocumentUtilityMomentumCovered
+        && evidence.botDocumentUtilityCooldownCovered
+        && evidence.behaviorServiceTicks > 0
+        && evidence.utilityCurveSelections > 0
+        && evidence.utilityNestedSelections > 0
+        && evidence.utilityMomentumSelections > 0
+        && evidence.utilityCooldownSuppressions > 0
+        && evidence.botDocumentBehaviorServiceTicks > 0
+        && evidence.botDocumentUtilityCurveSelections > 0
+        && evidence.botDocumentUtilityNestedSelections > 0
+        && evidence.botDocumentUtilityMomentumSelections > 0
+        && evidence.botDocumentUtilityCooldownSuppressions > 0
+        && evidence.failures.length === 0;
+}
+function physicsEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 5_000
+        && evidence.categoryPassed
+        && evidence.noFastStressHonored
+        && evidence.proofMode === 'full-step'
+        && evidence.fullRequiredProofCovered
+        && evidence.fullStepRollbackEquivalent
+        && evidence.fullStepContactsAndQueriesCovered
+        && evidence.stackStabilityCovered
+        && evidence.stackRollbackEquivalent
+        && evidence.stackAuthoringOrderStable
+        && evidence.scheduledQueriesRan
+        && evidence.shapeCastsCovered
+        && evidence.callbackLifecycleCovered
+        && evidence.materialResponseCovered
+        && evidence.meshStaticCollidersCovered
+        && evidence.angularGeometryCovered
+        && evidence.fullStepFrames > 0
+        && evidence.optimizedStressFrames === 0
+        && evidence.failures.length === 0;
+}
+function kccEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 5_000
+        && evidence.categoryPassed
+        && evidence.noFastStressHonored
+        && evidence.proofMode === 'full-step'
+        && evidence.fullRequiredProofCovered
+        && evidence.fullStepRollbackEquivalent
+        && evidence.slopesCovered
+        && evidence.stepsCovered
+        && evidence.movingPlatformsCovered
+        && evidence.sweptCollisionsCovered
+        && evidence.physicsQueriesCovered
+        && evidence.perHitCallbackFilteringCovered
+        && evidence.controllerGeometryConfigurable
+        && evidence.adversarialRollbackEquivalent
+        && evidence.adversarialThinWallSweepsCovered
+        && evidence.adversarialCornerSweepsCovered
+        && evidence.adversarialSlopeLimitRejectionsCovered
+        && evidence.fullStepPlayers === 128
+        && evidence.fullStepFrames > 0
+        && evidence.optimizedStressFrames === 0
+        && evidence.failures.length === 0;
+}
+function navigationEvidencePasses(evidence) {
+    return evidence !== undefined
+        && evidence.result === 'pass'
+        && evidence.players === 128
+        && evidence.frames >= 5_000
+        && evidence.categoryPassed
+        && evidence.rollbackEquivalent
+        && evidence.agentsCovered
+        && evidence.importedCookOrderStable
+        && evidence.importedPointPathCovered
+        && evidence.importedPortalAndSpawnCovered
+        && evidence.importedValidationFailuresCovered
+        && evidence.offMeshTraversalLifecycleCovered
+        && evidence.layered3DLookupDisambiguated
+        && evidence.layered3DOffMeshTraversalCovered
+        && evidence.layered3DRollbackEquivalent
+        && evidence.velocityObstacleAvoidanceCovered
+        && evidence.velocityObstaclePredictionCovered
+        && evidence.velocityObstacleOrderStable
+        && evidence.velocityObstacleValidationRejected
+        && evidence.agentVelocityObstacleAvoidanceCovered
+        && evidence.avoidanceCorrections > 0
+        && evidence.velocityObstacleAvoidanceCorrections > 0
+        && evidence.importedPortalCount > 0
+        && evidence.layeredVerticalOffMeshTraversals > 0
+        && evidence.failures.length === 0;
+}
+function statusCounts(entries) {
+    return {
+        'project-certified': entries.filter((entry) => entry.status === 'project-certified').length,
+        implemented: entries.filter((entry) => entry.status === 'implemented').length,
+        'headless-only': entries.filter((entry) => entry.status === 'headless-only').length,
+        'fixture-only': entries.filter((entry) => entry.status === 'fixture-only').length,
+        unsupported: entries.filter((entry) => entry.status === 'unsupported').length,
+        'non-goal': entries.filter((entry) => entry.status === 'non-goal').length,
+    };
+}
+const engineParityMatrixEntries = [
+    {
+        id: 'typed-frame-runtime',
+        system: 'ECS and frame runtime',
+        engineExpectation: 'DSL-defined components, singleton/global state, stateless systems, generated accessors, frame-owned snapshots, deterministic queries, rollback restore.',
+        status: 'implemented',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/engine-runtime.ts',
+            'packages/syncplay/src/sparse-set.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+        ],
+        cliProofs: [
+            'npm run certify:engine-complete -- --filter typed-frame-runtime --players 128 --frames 5000',
+            'npm run schema:runtime <descriptor.json> --execute --json artifacts/certification/schema-runtime.json',
+        ],
+        gaps: [
+            'Project-authored generated runtime replay is not yet mandatory in the top-level parity artifact.',
+            'Frame-heap allocation/free-on-component-lifecycle policy is not yet project-certified.',
+        ],
+        nextCliWork: [
+            'Require generated runtime source hash and self-contained replay bundle verification in project:certify.',
+            'Add descriptor-level dynamic collection lifecycle fixtures for add/remove component and entity destroy.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/engine-ecs/dsl',
+            'external-deterministic-engine-reference:manual/engine-ecs/systems',
+        ],
+    },
+    {
+        id: 'project-level-certification',
+        system: 'Project artifact chain',
+        engineExpectation: 'A game project can be certified from authored DSL, systems, assets, configs, static checks, replay identity, and runtime execution as one artifact.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/cli.ts',
+            'packages/syncplay/src/engine-complete.ts',
+            'packages/syncplay/fixtures/projects/engine-parity/project.json',
+            'packages/syncplay/tests/product-cli.test.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+        ],
+        cliProofs: [
+            'npm run project:certify fixtures/projects/engine-parity/project.json -- --require all --out-dir artifacts/certification/project --json artifacts/certification/project-certify.json',
+            'npm run certify:engine-complete -- --filter project-runtime --players 128 --frames 5000 --json artifacts/certification/engine-complete-project-runtime.json',
+        ],
+        gaps: [
+            'Project proof is not yet tied into SDK packed-export smoke tests or browser-safe subpath certification.',
+            'Project certification artifacts are not yet ingested by an evidence-derived parity matrix.',
+        ],
+        nextCliWork: [
+            'Add project certification output to static artifact audit and SDK pack/install smoke.',
+            'Promote project:certify valid runtime replay and minimized runtime desync artifact into final certification artifact audit.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/assets/assets-simulation',
+            'external-deterministic-engine-reference:manual/config-files',
+            'external-deterministic-engine-reference:manual/replay',
+        ],
+    },
+    {
+        id: 'assets-config-prototypes',
+        system: 'Assets, configs, prototypes',
+        engineExpectation: 'Immutable asset DB, session/simulation/runtime/player config identity, entity prototypes, baked map materialization, stale hash rejection, migrations.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/asset-cooking.ts',
+            'packages/syncplay/src/config-bundle.ts',
+            'packages/syncplay/tests/asset-cooking.test.ts',
+            'packages/syncplay/tests/config-bundle.test.ts',
+        ],
+        cliProofs: [
+            'npm run cook:syncplay-assets -- --verify fixtures/assets --json artifacts/certification/assets.json',
+            'npm run config:bundle <config.json> --out artifacts/certification/config.bundle.json --json artifacts/certification/config-bundle.json',
+            'npm run config:verify artifacts/certification/config.bundle.json --json artifacts/certification/config-verify.json',
+        ],
+        gaps: [
+            'Prototype materialization is shallow component cloning, not full map/entity-prototype authoring parity.',
+            'Dynamic collection allocation inside prototypes is not certified.',
+        ],
+        nextCliWork: [
+            'Add compound prototype inheritance, override, typed defaults, dynamic collection allocation, map spawn, and rebake invalidation fixtures.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/entity-prototypes',
+            'external-deterministic-engine-reference:manual/assets/assets-simulation',
+        ],
+    },
+    {
+        id: 'input-command-protocol',
+        system: 'Inputs, commands, protocol',
+        engineExpectation: 'Per-tick compact inputs plus reliable occasional commands, prediction, validation, rollback delivery, loss/dup/reorder resilience.',
+        status: 'implemented',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/input-timeline.ts',
+            'packages/syncplay/src/commands.ts',
+            'packages/syncplay/src/protocol-lab.ts',
+            'packages/syncplay/tests/command-timeline.test.ts',
+            'packages/syncplay/tests/input-timeline.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:input-timeline -- --players 128 --frames 1000 --json artifacts/reports/input-timeline-p128.json',
+            'npm run lab:command-timeline -- --players 128 --json artifacts/reports/command-timeline-p128.json',
+            'npm run lab:protocol-rollback -- --players 128 --frames 1000 --json artifacts/reports/protocol-p128.json',
+        ],
+        gaps: [
+            'Reliable command resend/ack is not yet proven over the same live local authority session as the wire receiver.',
+        ],
+        nextCliWork: [
+            'Add a long integrated authority-wire protocol fixture with reliable commands, acks, resend, hostile rejection, and convergence.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/input',
+            'external-deterministic-engine-reference:manual/commands',
+        ],
+    },
+    {
+        id: 'authority-reconnect-latejoin',
+        system: 'Local authoritative runner',
+        engineExpectation: 'Server-confirmed verified frames, predicted clients, reconnect, late join, spectator reconstruction, snapshot exchange, migration, hostile-client rejection.',
+        status: 'fixture-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/local-authority.ts',
+            'packages/syncplay/src/local-authority-wire.ts',
+            'packages/syncplay/src/local-authority-server-runner.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:local-authority-server -- --players 128 --frames 1000 --seed 71 --json artifacts/reports/local-authority-server-p128.json',
+        ],
+        gaps: [
+            'Reconnect, late join, snapshot chunks, replay continuity, and command reliability are split across fixtures.',
+            'Current local server runner proof is not yet a long session parity gate.',
+        ],
+        nextCliWork: [
+            'Add one 128-client integrated session proof covering disconnect to snapshot restore to catch-up to replay verification.',
+            'Emit replay bundle and desync minimizer artifacts from that session.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/frames',
+            'external-deterministic-engine-reference:manual/game-session/reconnecting',
+        ],
+    },
+    {
+        id: 'replay-debugging',
+        system: 'Replay, checksum, desync debugger',
+        engineExpectation: 'Replay identity binds runtime, assets, configs, input/command history, checksums, debug tables, and minimized desync artifacts.',
+        status: 'implemented',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/replay-bundle.ts',
+            'packages/syncplay/tests/replay-bundle-cli.test.ts',
+        ],
+        cliProofs: [
+            'npm run replay-bundle:verify <bundle.json> --json artifacts/certification/replay-bundle.json',
+            'npm run replay-bundle:verify-runtime <bundle.json> --json artifacts/certification/replay-runtime.json',
+            'npm run replay-bundle:diff <expected.json> <actual.json> --json artifacts/certification/replay-diff.json',
+        ],
+        gaps: [
+            'Protocol-generated desyncs are not yet automatically converted into self-contained minimized replay bundle artifacts.',
+        ],
+        nextCliWork: [
+            'Wire protocol and local-authority desync scenarios into replay-bundle minimization outputs.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/replay',
+            'external-deterministic-engine-reference:getting-started/faq',
+        ],
+    },
+    {
+        id: 'physics',
+        system: 'Physics 2D, 2.5D, 3D',
+        engineExpectation: 'Deterministic rollback-safe 2D/3D/2.5D physics, queries, materials, constraints, CCD, triggers, callbacks, stable performance.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/physics2d.ts',
+            'packages/syncplay/src/physics3d.ts',
+            'packages/syncplay/tests/physics2d.test.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:physics3d -- --bodies 128 --frames 1000 --no-fast-stress --json artifacts/reports/physics3d-no-fast.json',
+            'npm run certify:engine-complete -- --filter physics3d --players 128 --frames 5000 --no-fast-stress',
+        ],
+        gaps: [
+            'Production-quality stacked rigid-body solving, broad mesh import, full CCD, and long no-fast stress are not proven.',
+            '100k stress can use optimized-tail mode unless no-fast-stress is required.',
+        ],
+        nextCliWork: [
+            'Add adversarial no-fast fixtures for stacks, tunneling, joints, query ordering, 2.5D overload, and rollback equivalence.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/physics/overview',
+            'external-deterministic-engine-reference:manual/physics/physics-25d',
+            'external-deterministic-engine-reference:manual/physics/queries',
+        ],
+    },
+    {
+        id: 'kcc-movement',
+        system: 'KCC and movement',
+        engineExpectation: 'Deterministic 2D/3D KCC, capsule processors, slopes, stairs, ledges, platforms, filters, callbacks, adversarial playground coverage.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/movement.ts',
+            'packages/syncplay/src/movement3d.ts',
+            'packages/syncplay/tests/movement.test.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:kcc3d -- --players 128 --frames 1000 --no-fast-stress --json artifacts/reports/kcc3d-no-fast.json',
+            'npm run certify:engine-complete -- --filter kcc3d --players 128 --frames 5000 --no-fast-stress',
+        ],
+        gaps: [
+            'KCC processor asset model and authored playground/import fixture are missing.',
+            'Long full-workload no-fast KCC stress is not mandatory.',
+        ],
+        nextCliWork: [
+            'Add processor asset compile/trace and playground-style CLI fixture for stairs, slopes, corridors, gaps, moving platforms, filters, and callbacks.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/physics/kcc',
+            'external-deterministic-engine-reference:addons/kcc/sample-project',
+        ],
+    },
+    {
+        id: 'navigation',
+        system: 'Navigation and avoidance',
+        engineExpectation: 'Deterministic navmesh bake/import, pathfinding, steering, regions, off-mesh links, 3D nav, HRVO-style agent avoidance, dynamic obstacles.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/navigation.ts',
+            'packages/syncplay/src/navmesh.ts',
+            'packages/syncplay/tests/navigation.test.ts',
+        ],
+        cliProofs: [
+            'npm run navmesh:validate -- fixtures/navmesh/engine-parity-arena.json --json artifacts/reports/navmesh-validate.json',
+            'npm run navmesh:trace -- fixtures/navmesh/engine-parity-arena.json --agents 128 --frames 1000 --out artifacts/traces/navmesh.json --json artifacts/reports/navmesh-trace.json',
+        ],
+        gaps: [
+            'HRVO-style dense symmetric avoidance/deadlock fixtures need stronger candidate-solver evidence beyond current avoidance/progress trace counters.',
+            'DCC/R3F navmesh import and bake are outside current headless proof.',
+        ],
+        nextCliWork: [
+            'Add HRVO-style candidate velocity solver fixtures for dense corridor, symmetric crossing, dynamic obstacle, region toggle, off-mesh, and layered 3D navmesh stress.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/navigation/overview',
+            'external-deterministic-engine-reference:manual/navigation/avoidance',
+        ],
+    },
+    {
+        id: 'bots',
+        system: 'Bot SDK runtime',
+        engineExpectation: 'HFSM, behavior trees, utility theory, blackboards, document compile, traces, rich utility curves, momentum, cooldowns, nested considerations.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/bot-primitives.ts',
+            'packages/syncplay/src/bot-documents.ts',
+            'packages/syncplay/tests/bot-primitives.test.ts',
+        ],
+        cliProofs: [
+            'npm run bot:compile -- fixtures/bots/engine-parity-bot.json --valid-asset-refs ability.dash --out artifacts/cooked/bot.json --json artifacts/reports/bot-compile.json',
+            'npm run bot:trace -- fixtures/bots/engine-parity-bot.json --valid-asset-refs ability.dash --slots 0,1,2,3 --frames 120 --require-model-coverage --require-advanced-coverage --out artifacts/traces/bot.json --json artifacts/reports/bot-trace.json',
+        ],
+        gaps: [
+            'Advanced bot document coverage is now modeled and strictly traceable, but the final parity matrix still requires generated evidence artifacts to promote it to project-certified.',
+            'Visual authoring remains a non-CLI gap; CLI scope should focus on richer fail-closed document validation and artifact ingestion.',
+        ],
+        nextCliWork: [
+            'Promote strict bot trace and project certification artifacts into the evidence-derived parity matrix.',
+            'Add negative bot document fixtures for duplicate ids, bad blackboard refs, invalid nested utility refs, service cadence errors, and unsupported deterministic value types.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:addons/bot-sdk/overview',
+            'external-deterministic-engine-reference:addons/bot-sdk/utility-theory',
+        ],
+    },
+    {
+        id: 'animation',
+        system: 'Deterministic animation',
+        engineExpectation: 'Deterministic animation state machines, Mecanim-style baking constraints, clips, transitions, events, blends, layers, root motion, rollback-safe playback.',
+        status: 'headless-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/animation.ts',
+            'packages/syncplay/tests/engine-complete.test.ts',
+            'packages/syncplay/tests/product-cli.test.ts',
+        ],
+        cliProofs: [
+            'npm run animation:compile -- fixtures/animation/engine-parity-animator.json --out artifacts/cooked/animation.json --json artifacts/reports/animation-compile.json',
+            'npm run animation:trace -- fixtures/animation/engine-parity-animator.json --frames 240 --require-transition-coverage --require-advanced-coverage --out artifacts/traces/animation.json --json artifacts/reports/animation-trace.json',
+        ],
+        gaps: [
+            'Blend trees, layers, root motion, and synchronized event reconstruction are now strictly traceable, but final parity still depends on generated evidence artifacts and long-run project certification.',
+        ],
+        nextCliWork: [
+            'Promote strict animation trace and project certification artifacts into the evidence-derived parity matrix.',
+            'Add CLI fixtures for non-synchronized event reconstruction policy, late-join animation slicing, transition interruption, layer masks, and invalid animator descriptor rejection.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/animation',
+        ],
+    },
+    {
+        id: 'lag-compensation',
+        system: 'Lag compensation',
+        engineExpectation: 'Authoritative rewind, per-client shot timing, hitbox proxies, occlusion, anti-forgery, replay validation, rollback-safe snapshots.',
+        status: 'implemented',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/lag-compensation3d.ts',
+            'packages/syncplay/tests/lag-compensation3d.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:lag-compensation3d -- --players 128 --frames 1000 --seed 71 --json artifacts/reports/lag-comp3d.json',
+        ],
+        gaps: [
+            'End-to-end authority session proof with command ingestion, per-client shot time, anti-forgery, replay bundle validation, and rollback is not mandatory.',
+        ],
+        nextCliWork: [
+            'Integrate lag-compensated shot commands into the local authority session proof and replay bundle verification.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:game-samples/engine-simple-fps/overview',
+        ],
+    },
+    {
+        id: 'samples',
+        system: 'Samples and common scenes',
+        engineExpectation: 'Robust reusable samples for common multiplayer genres that prove engine systems in realistic combinations.',
+        status: 'fixture-only',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/sample-scenes.ts',
+            'packages/syncplay/tests/sample-scenes.test.ts',
+        ],
+        cliProofs: [
+            'npm run certify:v2 -- --profile required-full --players 128 --frames 1000 --json artifacts/certification/engine-parity-required-full.json',
+        ],
+        gaps: [
+            'Headless sample counters do not yet prove creator-facing scene templates or artifact-rendered sample state.',
+            'Integrated samples need stronger per-scene mechanics assertions and replay artifacts.',
+        ],
+        nextCliWork: [
+            'Add CLI-rendered or artifact-traced Simple FPS, platform shooter, arena brawler, nav agents, animator, KCC playground, vehicle, and waiting-room samples.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:game-samples/engine-simple-fps/overview',
+            'external-deterministic-engine-reference:technical-samples/asteroids/overview',
+        ],
+    },
+    {
+        id: 'browser-sdk-boundary',
+        system: 'Browser and SDK boundary',
+        engineExpectation: 'Engine core is consumable from SDK/browser-safe subpaths, with Node-only tooling excluded and browser replay proofs required.',
+        status: 'implemented',
+        requiredForCliParity: true,
+        canCloseWithCli: true,
+        currentEvidence: [
+            'packages/syncplay/src/browser.ts',
+            'packages/sdk/src/syncplay/index.ts',
+            'packages/sdk/src/syncplay/browser.ts',
+            'packages/sdk/src/syncplay/node.ts',
+            'packages/sdk/tests/deterministicMultiplayer.test.ts',
+        ],
+        cliProofs: [
+            'npm run lab:replay-verify-browser -- artifacts/replays/browser-proof-current.json --runtime chromium --json artifacts/certification/browser-replay-chromium-current.json',
+            'cd packages/sdk && npm test -- deterministicMultiplayer.test.ts --runInBand && npm run build:sdk',
+        ],
+        gaps: [
+            'Browser proof artifacts are not always present and are not yet mandatory for every parity report.',
+        ],
+        nextCliWork: [
+            'Require Chromium browser replay and SDK test-app proof artifacts in static:determinism certification mode.',
+        ],
+        referenceDocs: [
+            'external-deterministic-engine-reference:manual/replay',
+        ],
+    },
+    {
+        id: 'venus-r3f-production-integration',
+        system: 'Venus, R3F, production hosting',
+        engineExpectation: 'Production multiplayer transport, R3F presentation, Cloud Run room deployment, and hosted game-engine integration.',
+        status: 'non-goal',
+        requiredForCliParity: false,
+        canCloseWithCli: false,
+        currentEvidence: [
+            'Explicit user scope keeps R3F presentation out of this CLI-first goal and keeps third-party game-engine work out of scope.',
+        ],
+        cliProofs: [],
+        gaps: [
+            'Out of scope until core deterministic engine systems are fully CLI-certified.',
+        ],
+        nextCliWork: [],
+        referenceDocs: [
+            'external-deterministic-engine-reference:engine-intro',
+        ],
+    },
+    {
+        id: 'external-engine-non-goal',
+        system: 'Third-party game engines',
+        engineExpectation: 'No integration work for third-party game engines.',
+        status: 'non-goal',
+        requiredForCliParity: false,
+        canCloseWithCli: false,
+        currentEvidence: [
+            'Working with third-party game engines is explicitly not a goal.',
+        ],
+        cliProofs: [],
+        gaps: [
+            'No third-party game-engine work should be done for this goal.',
+        ],
+        nextCliWork: [],
+        referenceDocs: [
+            'external-deterministic-engine-reference:engine-intro',
+        ],
+    },
+];