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

package/dist/engine-core-proof.d.ts

@@ -0,0 +1,26 @@
+export interface DeterministicEngineCoreNumericProofOptions {
+    readonly players?: number;
+    readonly frames?: number;
+    readonly seed?: number;
+}
+export interface DeterministicEngineCoreNumericCategoryProof {
+    readonly category: 'physics3d' | 'kcc3d' | 'navmesh';
+    readonly checksum: string;
+    readonly metrics: Readonly<Record<string, boolean | number | string>>;
+}
+export interface DeterministicEngineCoreNumericProof {
+    readonly schemaVersion: 1;
+    readonly kind: 'engine-core-numeric-proof';
+    readonly players: number;
+    readonly frames: number;
+    readonly seed: number;
+    readonly categories: readonly DeterministicEngineCoreNumericCategoryProof[];
+    readonly checksum: string;
+}
+export interface ResolvedDeterministicEngineCoreNumericProofOptions {
+    readonly players: number;
+    readonly frames: number;
+    readonly seed: number;
+}
+export declare function runDeterministicEngineCoreNumericProof(...args: readonly [DeterministicEngineCoreNumericProofOptions?]): DeterministicEngineCoreNumericProof;
+export declare function resolveDeterministicEngineCoreNumericProofOptions(options?: DeterministicEngineCoreNumericProofOptions): ResolvedDeterministicEngineCoreNumericProofOptions;

package/dist/engine-core-proof.js

@@ -0,0 +1,66 @@
+import { defaultChecksum } from './canonical.js';
+import { runDeterministicKcc3DCrowdFixture } from './movement3d.js';
+import { runDeterministicNavmeshStress } from './navmesh.js';
+import { runDeterministicPhysics3DStress } from './physics3d.js';
+export function runDeterministicEngineCoreNumericProof(...args) {
+    const { players, frames, seed } = resolveDeterministicEngineCoreNumericProofOptions(...args);
+    const physics = runDeterministicPhysics3DStress(players, frames);
+    const kcc = runDeterministicKcc3DCrowdFixture(players, frames);
+    const navmesh = runDeterministicNavmeshStress(players, frames);
+    const categories = [
+        {
+            category: 'physics3d',
+            checksum: physics.checksum,
+            metrics: {
+                bodies: physics.bodies,
+                frames: physics.frames,
+                contacts: physics.contactCount,
+                queries: physics.queryCount,
+                shapeCasts: physics.shapeCastCount,
+                p99StepCost: physics.p99StepCost,
+            },
+        },
+        {
+            category: 'kcc3d',
+            checksum: kcc.checksum,
+            metrics: {
+                players: kcc.players,
+                frames: kcc.frames,
+                physicsQueries: kcc.physicsQueryCount,
+                corrections: kcc.correctionCount,
+                rollbackEquivalent: kcc.rollbackEquivalent,
+            },
+        },
+        {
+            category: 'navmesh',
+            checksum: navmesh.checksum,
+            metrics: {
+                agents: navmesh.agents,
+                frames: navmesh.frames,
+                replans: navmesh.replans,
+                avoidanceCorrections: navmesh.avoidanceCorrections,
+                rollbackEquivalent: navmesh.rollbackEquivalent,
+            },
+        },
+    ];
+    const withoutChecksum = {
+        schemaVersion: 1,
+        kind: 'engine-core-numeric-proof',
+        players,
+        frames,
+        seed,
+        categories,
+        checksum: '',
+    };
+    return {
+        ...withoutChecksum,
+        checksum: defaultChecksum(withoutChecksum),
+    };
+}
+export function resolveDeterministicEngineCoreNumericProofOptions(options = {}) {
+    return {
+        players: options.players ?? 128,
+        frames: options.frames ?? 1000,
+        seed: options.seed ?? 71,
+    };
+}

package/dist/engine-parity-matrix.d.ts

@@ -0,0 +1,300 @@
+export type EngineParityMatrixStatus = 'project-certified' | 'implemented' | 'headless-only' | 'fixture-only' | 'unsupported' | 'non-goal';
+export interface EngineParityMatrixEntry {
+    readonly id: string;
+    readonly system: string;
+    readonly engineExpectation: string;
+    readonly status: EngineParityMatrixStatus;
+    readonly requiredForCliParity: boolean;
+    readonly canCloseWithCli: boolean;
+    readonly currentEvidence: readonly string[];
+    readonly cliProofs: readonly string[];
+    readonly gaps: readonly string[];
+    readonly nextCliWork: readonly string[];
+    readonly referenceDocs: readonly string[];
+}
+export interface EngineParityMatrixProjectRuntimeEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly projectRuntimePassed: boolean;
+    readonly replayRuntimeVerified: boolean;
+    readonly selfContainedReplayRuntimeVerified: boolean;
+    readonly generatedRuntimeSourceCertified: boolean;
+    readonly descriptorCertified: boolean;
+    readonly replayAcceptsGeneratedRuntimeSourceHash: boolean;
+    readonly replayUsesProjectGameStateRuntime: boolean;
+    readonly replayRuntimeCoversProjectCommands: boolean;
+    readonly replayRuntimeCoversProjectEvents: boolean;
+    readonly assetsConfigCertified: boolean;
+    readonly botNavAnimationCertified: boolean;
+    readonly generatedRuntimeSourceHash: string;
+    readonly runtimeDescriptorHash: string;
+    readonly replaySystemId: string;
+    readonly replayRuntimeCommandChannels: number;
+    readonly replayRuntimeEventChannels: number;
+}
+export interface EngineParityMatrixAuthorityEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly serverEvaluated: boolean;
+    readonly migrationRestored: boolean;
+    readonly convergence: boolean;
+    readonly disconnects: number;
+    readonly reconnects: number;
+    readonly lateJoins: number;
+    readonly spectators: number;
+    readonly snapshotMaxAgeFrames: number;
+    readonly wireSnapshotRequestEnvelopes: number;
+    readonly wireSnapshotOfferEnvelopes: number;
+    readonly wireSnapshotChunkEnvelopes: number;
+    readonly wireSnapshotCompleteEnvelopes: number;
+    readonly wireSnapshotNegotiationCompletesApplied: number;
+    readonly wireSnapshotsApplied: number;
+    readonly wireAcceptedCommands: number;
+    readonly wireRejectedCommands: number;
+    readonly wireSpectatorCommandsRejected: number;
+    readonly reliableCommandAcked: number;
+    readonly reliableCommandResent: number;
+    readonly reliableCommandLossesInjected: number;
+    readonly reliableCommandDuplicatesRejected: number;
+    readonly reliableCommandReordersObserved: number;
+    readonly reliableCommandRollbackConverged: boolean;
+    readonly commandEffectSubmissions: number;
+    readonly commandEffectValue: number;
+    readonly commandEffectChecksum: string;
+    readonly commandEffectProjectionChecksum: string;
+    readonly lagCompCommandSubmissions: number;
+    readonly lagCompAcceptedShots: number;
+    readonly lagCompHitCommands: number;
+    readonly lagCompInvalidShotCommands: number;
+    readonly lagCompForgedTimingRejected: number;
+    readonly lagCompReplayChecksum: string;
+    readonly lagCompRestoredChecksum: string;
+    readonly lagCompRollbackEquivalent: boolean;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixReplayDebuggingEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly verifiedResyncBundles: number;
+    readonly semanticReplayFrames: number;
+    readonly minimizedDesyncBundles: number;
+    readonly minimizedDesyncFirstMismatchFrame: number;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixBrowserSdkEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly staticAuditPassed: boolean;
+    readonly browserReplayVerified: boolean;
+    readonly browserReplayFrames: number;
+    readonly browserReplayPlayers: number;
+    readonly engineCoreBrowserVerified: boolean;
+    readonly engineCorePlayers: number;
+    readonly engineCoreFrames: number;
+    readonly engineCoreCategoryMatches: number;
+    readonly sdkTestAppVerified: boolean;
+    readonly sdkCanvasRendered: boolean;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixSampleEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly sampleCategoryPassed: boolean;
+    readonly allMechanicsCovered: boolean;
+    readonly integratedHeadlessSceneCovered: boolean;
+    readonly integratedReplayVerified: boolean;
+    readonly integratedRollbackEquivalent: boolean;
+    readonly artifactTracePresent: boolean;
+    readonly artifactTraceAllSamplesCovered: boolean;
+    readonly artifactTraceMechanicsCovered: boolean;
+    readonly artifactTraceRollbackEquivalent: boolean;
+    readonly artifactTraceIntegratedReplayVerified: boolean;
+    readonly artifactTraceSampleCount: number;
+    readonly artifactTraceMechanicCount: number;
+    readonly artifactTraceRepresentativeStates: number;
+    readonly artifactTraceIntegratedReplaySnapshots: number;
+    readonly artifactTraceHash: string;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixAssetConfigEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly assetCategoryPassed: boolean;
+    readonly configCategoryPassed: boolean;
+    readonly descriptorBackedPrototypeValidation: boolean;
+    readonly compoundPrototypeInheritanceCovered: boolean;
+    readonly dynamicCollectionAllocationCovered: boolean;
+    readonly mapSpawnMaterializationCovered: boolean;
+    readonly mapRebakeInvalidationCovered: boolean;
+    readonly configInheritedPrototypeMaterialized: boolean;
+    readonly configDynamicCollectionsMaterialized: boolean;
+    readonly configMapMaterializationStable: boolean;
+    readonly configMapRebakeInvalidated: boolean;
+    readonly runtimeValidatedPrototypeEntities: number;
+    readonly runtimeInjectedPrototypeComponents: number;
+    readonly assetMapMaterializedEntityCount: number;
+    readonly configMapMaterializedEntityCount: number;
+    readonly mapBakeHash: string;
+    readonly configMapBakeHash: string;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixAnimationEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly animationCategoryPassed: boolean;
+    readonly stateTransitionsCovered: boolean;
+    readonly exitFrameTransitionsCovered: boolean;
+    readonly transitionBlendCovered: boolean;
+    readonly triggerLatchCovered: boolean;
+    readonly animationEventsEmitted: boolean;
+    readonly normalizedClipTimeCovered: boolean;
+    readonly sampledPoseCovered: boolean;
+    readonly blendTreeCovered: boolean;
+    readonly animationLayersCovered: boolean;
+    readonly rootMotionCovered: boolean;
+    readonly eventReconstructionCovered: boolean;
+    readonly rollbackEquivalent: boolean;
+    readonly blendTreeFrames: number;
+    readonly layerPoseFrames: number;
+    readonly rootMotionFrames: number;
+    readonly reconstructedEvents: number;
+    readonly reconstructedEventHash: string;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixBotEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly botCategoryPassed: boolean;
+    readonly player128BotReplacement: boolean;
+    readonly rollbackEquivalent: boolean;
+    readonly behaviorServicesCovered: boolean;
+    readonly utilityCurvesCovered: boolean;
+    readonly utilityNestedCovered: boolean;
+    readonly utilityMomentumCovered: boolean;
+    readonly utilityCooldownCovered: boolean;
+    readonly botDocumentBehaviorServicesCovered: boolean;
+    readonly botDocumentUtilityCurvesCovered: boolean;
+    readonly botDocumentUtilityNestedCovered: boolean;
+    readonly botDocumentUtilityMomentumCovered: boolean;
+    readonly botDocumentUtilityCooldownCovered: boolean;
+    readonly behaviorServiceTicks: number;
+    readonly utilityCurveSelections: number;
+    readonly utilityNestedSelections: number;
+    readonly utilityMomentumSelections: number;
+    readonly utilityCooldownSuppressions: number;
+    readonly botDocumentBehaviorServiceTicks: number;
+    readonly botDocumentUtilityCurveSelections: number;
+    readonly botDocumentUtilityNestedSelections: number;
+    readonly botDocumentUtilityMomentumSelections: number;
+    readonly botDocumentUtilityCooldownSuppressions: number;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixPhysicsEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly categoryPassed: boolean;
+    readonly noFastStressHonored: boolean;
+    readonly proofMode: string;
+    readonly fullRequiredProofCovered: boolean;
+    readonly fullStepRollbackEquivalent: boolean;
+    readonly fullStepContactsAndQueriesCovered: boolean;
+    readonly stackStabilityCovered: boolean;
+    readonly stackRollbackEquivalent: boolean;
+    readonly stackAuthoringOrderStable: boolean;
+    readonly scheduledQueriesRan: boolean;
+    readonly shapeCastsCovered: boolean;
+    readonly callbackLifecycleCovered: boolean;
+    readonly materialResponseCovered: boolean;
+    readonly meshStaticCollidersCovered: boolean;
+    readonly angularGeometryCovered: boolean;
+    readonly fullStepFrames: number;
+    readonly optimizedStressFrames: number;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixKccEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly categoryPassed: boolean;
+    readonly noFastStressHonored: boolean;
+    readonly proofMode: string;
+    readonly fullRequiredProofCovered: boolean;
+    readonly fullStepRollbackEquivalent: boolean;
+    readonly slopesCovered: boolean;
+    readonly stepsCovered: boolean;
+    readonly movingPlatformsCovered: boolean;
+    readonly sweptCollisionsCovered: boolean;
+    readonly physicsQueriesCovered: boolean;
+    readonly perHitCallbackFilteringCovered: boolean;
+    readonly controllerGeometryConfigurable: boolean;
+    readonly adversarialRollbackEquivalent: boolean;
+    readonly adversarialThinWallSweepsCovered: boolean;
+    readonly adversarialCornerSweepsCovered: boolean;
+    readonly adversarialSlopeLimitRejectionsCovered: boolean;
+    readonly fullStepPlayers: number;
+    readonly fullStepFrames: number;
+    readonly optimizedStressFrames: number;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixNavigationEvidence {
+    readonly result: 'pass' | 'fail' | 'missing';
+    readonly players: number;
+    readonly frames: number;
+    readonly categoryPassed: boolean;
+    readonly rollbackEquivalent: boolean;
+    readonly agentsCovered: boolean;
+    readonly importedCookOrderStable: boolean;
+    readonly importedPointPathCovered: boolean;
+    readonly importedPortalAndSpawnCovered: boolean;
+    readonly importedValidationFailuresCovered: boolean;
+    readonly offMeshTraversalLifecycleCovered: boolean;
+    readonly layered3DLookupDisambiguated: boolean;
+    readonly layered3DOffMeshTraversalCovered: boolean;
+    readonly layered3DRollbackEquivalent: boolean;
+    readonly velocityObstacleAvoidanceCovered: boolean;
+    readonly velocityObstaclePredictionCovered: boolean;
+    readonly velocityObstacleOrderStable: boolean;
+    readonly velocityObstacleValidationRejected: boolean;
+    readonly agentVelocityObstacleAvoidanceCovered: boolean;
+    readonly avoidanceCorrections: number;
+    readonly velocityObstacleAvoidanceCorrections: number;
+    readonly importedPortalCount: number;
+    readonly layeredVerticalOffMeshTraversals: number;
+    readonly failures: readonly string[];
+}
+export interface EngineParityMatrixEvidence {
+    readonly projectRuntime?: EngineParityMatrixProjectRuntimeEvidence;
+    readonly authority?: EngineParityMatrixAuthorityEvidence;
+    readonly replayDebugging?: EngineParityMatrixReplayDebuggingEvidence;
+    readonly browserSdk?: EngineParityMatrixBrowserSdkEvidence;
+    readonly samples?: EngineParityMatrixSampleEvidence;
+    readonly assetConfig?: EngineParityMatrixAssetConfigEvidence;
+    readonly animation?: EngineParityMatrixAnimationEvidence;
+    readonly bots?: EngineParityMatrixBotEvidence;
+    readonly physics?: EngineParityMatrixPhysicsEvidence;
+    readonly kcc?: EngineParityMatrixKccEvidence;
+    readonly navigation?: EngineParityMatrixNavigationEvidence;
+}
+export interface EngineParityMatrixReport {
+    readonly schemaVersion: 1;
+    readonly kind: 'engine-parity-matrix';
+    readonly reportId: string;
+    readonly summary: {
+        readonly entries: number;
+        readonly requiredForCliParity: number;
+        readonly canCloseWithCli: number;
+        readonly byStatus: Readonly<Record<EngineParityMatrixStatus, number>>;
+        readonly requiredOpenCliGaps: number;
+        readonly unsupportedRequiredCliGaps: number;
+    };
+    readonly entries: readonly EngineParityMatrixEntry[];
+    readonly result: 'pass' | 'warn' | 'fail';
+}
+export declare function evaluateEngineParityMatrixResult(summary: Pick<EngineParityMatrixReport['summary'], 'unsupportedRequiredCliGaps' | 'requiredOpenCliGaps'>): EngineParityMatrixReport['result'];
+export declare function createEngineParityMatrixReport(evidence?: EngineParityMatrixEvidence): EngineParityMatrixReport;
+export declare function stableEngineParityMatrixJson(report: EngineParityMatrixReport): string;