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

package/dist/examples/fixed-arena.js

@@ -0,0 +1,356 @@
+import { defaultChecksum } from '../canonical.js';
+import { fixedCircle, circleIntersects } from '../collision.js';
+import { createDeterministicEventTimeline } from '../events.js';
+import { createOfflineSession } from '../offline-session.js';
+import { DeterministicRandom } from '../random.js';
+import { verifyReplay } from '../replay.js';
+import { defineSyncplayGame } from '../schema.js';
+const arenaHalfExtent = 2048;
+const playerRadius = 24;
+const maxVelocity = 48;
+const dashImpulse = 9;
+const thrustScale = 3;
+export const fixedArenaDefaultInput = {
+    thrustX: 0,
+    thrustY: 0,
+    dash: false,
+};
+export function createFixedArenaDescriptor(maxPlayers = 128) {
+    return {
+        deterministicVersion: 'fixed-arena@1',
+        tickRate: 30,
+        maxPlayers,
+        input: {
+            id: 'fixed-arena-input/v1',
+            fields: [
+                { name: 'thrustX', kind: 'integer', policy: 'repeat', defaultValue: 0, min: -1, max: 1 },
+                { name: 'thrustY', kind: 'integer', policy: 'repeat', defaultValue: 0, min: -1, max: 1 },
+                { name: 'dash', kind: 'boolean', policy: 'command', defaultValue: false },
+            ],
+        },
+        state: {
+            id: 'fixed-arena-state/v1',
+            fields: [
+                { name: 'frame', kind: 'integer', numericMode: 'integer', checksummed: true },
+                { name: 'x', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: -8192, max: 8192 },
+                { name: 'y', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: -8192, max: 8192 },
+                { name: 'vx', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: -maxVelocity, max: maxVelocity },
+                { name: 'vy', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: -maxVelocity, max: maxVelocity },
+                { name: 'score', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: 0, max: 1_000_000 },
+                { name: 'collisions', kind: 'integer', numericMode: 'integer', collectionOrdering: 'indexed', checksummed: true, min: 0, max: 1_000_000 },
+            ],
+        },
+        systems: [{ id: 'input' }, { id: 'movement' }, { id: 'bounds' }, { id: 'collision' }],
+    };
+}
+export function createFixedArenaSession(players, seed, options = {}) {
+    // Stamp the CONTENT-HASHED identity so descriptor-based verification
+    // (verifyReplayWithDescriptor) agrees with these replays.
+    const identity = defineSyncplayGame(createFixedArenaDescriptor(players)).replayIdentity;
+    return createOfflineSession({
+        tickRate: 30,
+        playerCount: players,
+        initialState: createInitialFixedArenaState(players, seed),
+        step: fixedArenaStep,
+        defaultInput: fixedArenaDefaultInput,
+        inputSchemaId: identity.inputSchemaId,
+        stateSchemaId: identity.stateSchemaId,
+        deterministicVersion: 'fixed-arena@1',
+        randomSeed: seed,
+        snapshotBufferSize: options.snapshotBufferSize,
+        replayRecordingMode: options.replayRecordingMode,
+    });
+}
+export function runFixedArenaExample(options) {
+    validateFixedArenaOptions(options);
+    const session = createFixedArenaSession(options.players, options.seed);
+    const inputRandom = new DeterministicRandom(options.seed);
+    const eventTimeline = createDeterministicEventTimeline();
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        for (let slot = 0; slot < options.players; slot += 1) {
+            session.setInput(slot, makeFixedArenaInput(inputRandom));
+        }
+        session.stepFrames(1);
+        const nextState = session.getState();
+        for (const pair of findFixedArenaCollisionPairs(nextState)) {
+            eventTimeline.emitVerifiedOnly('fixed-arena.collision', nextState.frame, {
+                a: pair.a,
+                b: pair.b,
+                ax: nextState.x[pair.a],
+                ay: nextState.y[pair.a],
+                bx: nextState.x[pair.b],
+                by: nextState.y[pair.b],
+            }, `fixed-arena.collision:${nextState.frame}:${pair.a}:${pair.b}`);
+        }
+    }
+    const replay = session.exportReplay();
+    if (options.verify === true) {
+        verifyFixedArenaReplay(replay);
+    }
+    const finalChecksum = replay.checksums.at(-1)?.checksum ?? defaultChecksum(session.getState());
+    return {
+        frames: options.frames,
+        players: options.players,
+        events: eventTimeline.records().length,
+        replayChecksums: replay.checksums.length,
+        finalChecksum,
+        verified: options.verify === true,
+        result: 'pass',
+        replay,
+        renderState: projectFixedArenaRenderState(session.getState()),
+        eventTimeline: eventTimeline.records(),
+    };
+}
+export function verifyFixedArenaReplay(replay) {
+    const identity = defineSyncplayGame(createFixedArenaDescriptor(replay.playerCount)).replayIdentity;
+    const result = verifyReplay({
+        replay,
+        step: fixedArenaStep,
+        defaultInput: fixedArenaDefaultInput,
+        inputSchemaId: identity.inputSchemaId,
+        stateSchemaId: identity.stateSchemaId,
+        deterministicVersion: 'fixed-arena@1',
+        hydrateInput: hydrateFixedArenaInput,
+    });
+    if (result.mismatches !== 0) {
+        throw new Error(`Fixed Arena replay mismatch: ${result.mismatches}`);
+    }
+}
+export function projectFixedArenaRenderState(state) {
+    return {
+        players: state.x.map((x, slot) => ({
+            key: `player-${slot}`,
+            x,
+            y: state.y[slot],
+            radius: playerRadius,
+            color: slot % 2 === 0 ? 'cyan' : 'magenta',
+            score: state.score[slot],
+            collisions: state.collisions[slot],
+        })),
+        bounds: {
+            minX: -arenaHalfExtent,
+            minY: -arenaHalfExtent,
+            maxX: arenaHalfExtent,
+            maxY: arenaHalfExtent,
+        },
+    };
+}
+export function projectFixedArenaReferenceView(state) {
+    const leaderboard = state.score
+        .map((score, slot) => ({
+        slot,
+        score,
+        collisions: state.collisions[slot],
+        color: fixedArenaColor(slot),
+    }))
+        .sort((left, right) => {
+        if (left.score !== right.score) {
+            return right.score - left.score;
+        }
+        return left.slot - right.slot;
+    });
+    const ranks = new Map(leaderboard.map((entry, index) => [entry.slot, index + 1]));
+    const topScore = leaderboard[0]?.score ?? 0;
+    return {
+        camera: {
+            position: [0, 0, 10],
+            zoom: 0.1,
+        },
+        arena: {
+            width: (arenaHalfExtent * 2) / 100,
+            height: (arenaHalfExtent * 2) / 100,
+            wallThickness: 0.2,
+            backgroundColor: '#071014',
+            wallColor: '#10242b',
+        },
+        players: state.x.map((x, slot) => ({
+            key: `player-${slot}`,
+            slot,
+            position: [x / 100, state.y[slot] / 100, 0],
+            scale: [1 + minInt(state.score[slot], 20) / 50, 1 + minInt(state.collisions[slot], 10) / 40, 1],
+            color: fixedArenaColor(slot),
+            ringColor: ranks.get(slot) === 1 ? '#f5d76e' : '#d7eef2',
+            velocity: [state.vx[slot] / 100, state.vy[slot] / 100, 0],
+            score: state.score[slot],
+            collisions: state.collisions[slot],
+            rank: ranks.get(slot) ?? state.x.length,
+        })),
+        leaderboard,
+        debug: {
+            frame: state.frame,
+            players: state.x.length,
+            topScore,
+        },
+    };
+}
+export function makeFixedArenaInput(random) {
+    return {
+        thrustX: random.nextInt(-1, 1),
+        thrustY: random.nextInt(-1, 1),
+        dash: random.nextInt(0, 31) === 0,
+    };
+}
+export function createInitialFixedArenaState(players, seed) {
+    const columns = ceilSqrtInt(players);
+    const spacing = maxInt(playerRadius * 3, truncDivTowardZero(arenaHalfExtent * 2, columns + 1));
+    const random = new DeterministicRandom(seed).fork('fixed-arena-spawn');
+    return {
+        frame: 0,
+        x: Array.from({ length: players }, (_, slot) => {
+            const column = slot % columns;
+            return -arenaHalfExtent + spacing * (column + 1) + random.nextInt(-8, 8);
+        }),
+        y: Array.from({ length: players }, (_, slot) => {
+            const row = truncDivTowardZero(slot, columns);
+            return -arenaHalfExtent + spacing * (row + 1) + random.nextInt(-8, 8);
+        }),
+        vx: Array.from({ length: players }, () => 0),
+        vy: Array.from({ length: players }, () => 0),
+        score: Array.from({ length: players }, () => 0),
+        collisions: Array.from({ length: players }, () => 0),
+    };
+}
+export function fixedArenaStep(state, inputs) {
+    const x = [...state.x];
+    const y = [...state.y];
+    const vx = [...state.vx];
+    const vy = [...state.vy];
+    const score = [...state.score];
+    const collisions = [...state.collisions];
+    for (let slot = 0; slot < inputs.length; slot += 1) {
+        const input = inputs[slot];
+        const impulse = input.dash ? dashImpulse : thrustScale;
+        vx[slot] = clamp(vx[slot] + input.thrustX * impulse, -maxVelocity, maxVelocity);
+        vy[slot] = clamp(vy[slot] + input.thrustY * impulse, -maxVelocity, maxVelocity);
+        x[slot] += vx[slot];
+        y[slot] += vy[slot];
+        if (x[slot] < -arenaHalfExtent || x[slot] > arenaHalfExtent) {
+            x[slot] = clamp(x[slot], -arenaHalfExtent, arenaHalfExtent);
+            vx[slot] = -truncDivTowardZero(vx[slot], 2);
+        }
+        if (y[slot] < -arenaHalfExtent || y[slot] > arenaHalfExtent) {
+            y[slot] = clamp(y[slot], -arenaHalfExtent, arenaHalfExtent);
+            vy[slot] = -truncDivTowardZero(vy[slot], 2);
+        }
+    }
+    for (let left = 0; left < inputs.length; left += 1) {
+        for (let right = left + 1; right < inputs.length; right += 1) {
+            if (!circleIntersects(fixedCircle({ x: x[left], y: y[left] }, playerRadius), fixedCircle({ x: x[right], y: y[right] }, playerRadius))) {
+                continue;
+            }
+            const axis = chooseResolutionAxis(x[left] - x[right], y[left] - y[right], left, right);
+            x[left] += axis.x * playerRadius;
+            y[left] += axis.y * playerRadius;
+            x[right] -= axis.x * playerRadius;
+            y[right] -= axis.y * playerRadius;
+            vx[left] = -truncDivTowardZero(vx[left], 2);
+            vy[left] = -truncDivTowardZero(vy[left], 2);
+            vx[right] = -truncDivTowardZero(vx[right], 2);
+            vy[right] = -truncDivTowardZero(vy[right], 2);
+            collisions[left] += 1;
+            collisions[right] += 1;
+            if ((state.frame + left + right) % 2 === 0) {
+                score[left] += 1;
+            }
+            else {
+                score[right] += 1;
+            }
+        }
+    }
+    return {
+        frame: state.frame + 1,
+        x,
+        y,
+        vx,
+        vy,
+        score,
+        collisions,
+    };
+}
+function findFixedArenaCollisionPairs(state) {
+    const pairs = [];
+    for (let left = 0; left < state.x.length; left += 1) {
+        for (let right = left + 1; right < state.x.length; right += 1) {
+            if (circleIntersects(fixedCircle({ x: state.x[left], y: state.y[left] }, playerRadius), fixedCircle({ x: state.x[right], y: state.y[right] }, playerRadius))) {
+                pairs.push({ a: left, b: right });
+            }
+        }
+    }
+    return pairs;
+}
+function chooseResolutionAxis(dx, dy, left, right) {
+    if (absInt(dx) > absInt(dy)) {
+        return { x: dx >= 0 ? 1 : -1, y: 0 };
+    }
+    if (absInt(dy) > 0) {
+        return { x: 0, y: dy >= 0 ? 1 : -1 };
+    }
+    return { x: left < right ? -1 : 1, y: 0 };
+}
+function hydrateFixedArenaInput(recordedInput) {
+    if (recordedInput === null ||
+        typeof recordedInput !== 'object' ||
+        typeof recordedInput.thrustX !== 'number' ||
+        typeof recordedInput.thrustY !== 'number' ||
+        typeof recordedInput.dash !== 'boolean') {
+        throw new Error('Invalid Fixed Arena replay input');
+    }
+    return {
+        thrustX: clampInput(recordedInput.thrustX),
+        thrustY: clampInput(recordedInput.thrustY),
+        dash: recordedInput.dash,
+    };
+}
+function clampInput(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error('Fixed Arena input thrust must be an integer');
+    }
+    return clamp(value, -1, 1);
+}
+function clamp(value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+function ceilSqrtInt(value) {
+    let candidate = 1;
+    while (candidate * candidate < value) {
+        candidate += 1;
+    }
+    return candidate;
+}
+function maxInt(left, right) {
+    return left >= right ? left : right;
+}
+function minInt(left, right) {
+    return left <= right ? left : right;
+}
+function absInt(value) {
+    return value < 0 ? -value : value;
+}
+function fixedArenaColor(slot) {
+    return slot % 4 === 0 ? '#40d9ff' : slot % 4 === 1 ? '#ff4fd8' : slot % 4 === 2 ? '#7cff6b' : '#ffcc4d';
+}
+function truncDivTowardZero(value, divisor) {
+    if (!Number.isInteger(value) || !Number.isInteger(divisor) || divisor <= 0) {
+        throw new Error('Integer division requires integer value and positive integer divisor');
+    }
+    const positive = value >= 0 ? value : -value;
+    const quotient = (positive - (positive % divisor)) / divisor;
+    return value >= 0 ? quotient : -quotient;
+}
+function validateFixedArenaOptions(options) {
+    if (!Number.isInteger(options.players) || options.players < 2 || options.players > 128) {
+        throw new Error('Fixed Arena requires 2 to 128 players');
+    }
+    if (!Number.isInteger(options.frames) || options.frames < 1) {
+        throw new Error('Fixed Arena requires at least one frame');
+    }
+    if (!Number.isInteger(options.seed)) {
+        throw new Error('Fixed Arena seed must be an integer');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+export { canonicalize, canonicalStringify, cloneCanonical, decodeCanonicalValue, decodeUtf8, defaultChecksum, encodeUtf8 } from './canonical.js';
+export type { CanonicalValue } from './canonical.js';
+export * from './animation.js';
+export { cookDeterministicBotAsset, createDeterministicBotBlackboard, getBlackboardValue, runDeterministicBotSimulation, selectDeterministicUtility, tickDeterministicBehaviorTree, tickDeterministicBehaviorTreeWithMemory, tickDeterministicHfsm, } from './bot-primitives.js';
+export * from './bot-documents.js';
+export * from './commands.js';
+export * from './config-bundle.js';
+export * from './input-timeline.js';
+export * from './lag-compensation3d.js';
+export type { CookedDeterministicBotAsset, DeterministicBehaviorTreeNode, DeterministicBehaviorTreeStatus, DeterministicBehaviorTreeTick, DeterministicBlackboardEntry, DeterministicBlackboardValue, DeterministicBotAssetSource, DeterministicBotBlackboard, DeterministicBotSimulationMetrics, DeterministicHfsmAgent, DeterministicHfsmDefinition, DeterministicHfsmState, DeterministicHfsmTransition, DeterministicUtilityConsideration, DeterministicUtilitySelection, } from './bot-primitives.js';
+export { assertAssetManifestMatches, cookDeterministicAssets, materializePrototypeEntities, stableAssetCookJson, } from './asset-cooking.js';
+export type { DeterministicAssetCookManifest, DeterministicAssetCookResult, DeterministicAssetDependency, DeterministicAssetRecord, DeterministicAssetSource, DeterministicCookedAsset, DeterministicPrototypeEntity, } from './asset-cooking.js';
+export type { CertificationBudgetResult, CertificationBudgets, CertificationBotReplacementFixture, CertificationBotReplacementMetrics, CertificationEcsLiteFixture, CertificationEcsLiteMetrics, CertificationEventCallbacksFixture, CertificationEventCallbacksMetrics, CertificationExternalPhysicsGateFixture, CertificationExternalPhysicsGateMetrics, CertificationFixture, CertificationFixtureKind, CertificationFixtureReport, CertificationFixtureTier, CertificationFixedFoundationFixture, CertificationFixedFoundationMetrics, CertificationFrameModelMetrics, CertificationGenre128Fixture, CertificationGenre128Metrics, CertificationKccLiteFixture, CertificationKccLiteMetrics, CertificationManifest, CertificationMetrics, CertificationNetcodeFixture, CertificationNetcodeMetrics, CertificationNetcodeShape, CertificationPhysicsBuiltinFixture, CertificationPhysicsBuiltinMetrics, CertificationPredictionCullingFixture, CertificationPredictionCullingMetrics, CertificationProjectileHitscanFixture, CertificationProjectileHitscanMetrics, CertificationProtocolMatrixFixture, CertificationProtocolMatrixMetrics, CertificationProtocolProfileId, CertificationProtocolProfileMetrics, CertificationSchemaToolingFixture, CertificationSchemaToolingMetrics, CertificationStaticAnalysisFixture, CertificationStaticAnalysisMetrics, CertificationDesyncArtifact, CertificationReplayNodeFixture, CertificationReplayNodeMetrics, CertificationResult, CertificationRuntimeTarget, CertificationSuiteReport, CertificationSuiteRun, } from './certification.js';
+export { aabbContainsPoint, aabbIntersects, circleIntersects, circleIntersectsAabb, fixedAabb, fixedCircle, fixedVec2, sortAabbsByStableId, translateAabb, } from './collision.js';
+export type { FixedAabb, FixedCircle, FixedVec2 } from './collision.js';
+export { createStableIndexedMap, deterministicShuffle, stableEntries, stableSortedKeys } from './collections.js';
+export type { StableIndexedEntry } from './collections.js';
+export { combineDeterministicPhysicsMaterial, cookStaticColliders, detectVerticalCcdHit, quantizeFpsAim, stepKccLiteBody, stepTopDownBody, } from './deterministic-primitives.js';
+export type { CookedDeterministicStaticCollider, CookedStaticColliderSet, DeterministicPhysicsMaterial, DeterministicStaticCollider, FpsAimInput, MovementBody, MovementInput, QuantizedFpsAim, } from './deterministic-primitives.js';
+export { createDeterministicEventEffectsAdapter } from './effects-adapter.js';
+export type { DeterministicEffectDispatch, DeterministicEffectTarget, DeterministicEventEffectsAdapter, DeterministicEventEffectsAdapterConfig, DeterministicRenderSafeEffect, } from './effects-adapter.js';
+export { createDeterministicEventTimeline, filterDeterministicEventsForPlayer, runDeterministicEventKeywordFixture } from './events.js';
+export type { DeterministicEventDeliveryScope, DeterministicEventEmitOptions, DeterministicEventKeywordFixtureResult, DeterministicEventPredictionState, DeterministicEventRecord, DeterministicEventTimeline, } from './events.js';
+export { createEcsLiteWorld } from './ecs-lite.js';
+export type { EcsComponentName, EcsEntityId, EcsLiteQueryResult, EcsLiteSnapshot, EcsLiteWorld } from './ecs-lite.js';
+export * from './engine-core-proof.js';
+export * from './engine-complete.js';
+export * from './engine-runtime.js';
+export * from './deterministic-session.js';
+export { deterministicButtonInitialState, runDeterministicButtonFixture, runDeterministicDescriptorButtonFixture, stepDeterministicButton, } from './input-button.js';
+export type { DeterministicButtonFixtureResult, DeterministicButtonState, DeterministicButtonStep, DeterministicDescriptorButtonFixtureResult, } from './input-button.js';
+export { createCounterDuelSession, counterDuelDefaultInput, makeCounterDuelInput, runCounterDuelExample, verifyCounterDuelReplay, } from './examples/counter-duel.js';
+export { createFixedArenaDescriptor, createFixedArenaSession, createInitialFixedArenaState, fixedArenaDefaultInput, fixedArenaStep, makeFixedArenaInput, projectFixedArenaReferenceView, projectFixedArenaRenderState, runFixedArenaExample, verifyFixedArenaReplay, } from './examples/fixed-arena.js';
+export type { CounterDuelInput, CounterDuelOptions, CounterDuelResult, CounterDuelSessionOptions, CounterDuelState, } from './examples/counter-duel.js';
+export type { FixedArenaInput, FixedArenaOptions, FixedArenaReferenceView, FixedArenaRenderState, FixedArenaResult, FixedArenaSessionOptions, FixedArenaState, } from './examples/fixed-arena.js';
+export { SyncplayError } from './errors.js';
+export { createDeterministicMath } from './math.js';
+export { createDeterministicMockNetworkAdapter } from './mock-network-adapter.js';
+export type { DeterministicMockNetworkAdapter, DeterministicMockNetworkReplay } from './mock-network-adapter.js';
+export { runDeterministicMovementCrowdSimulation, rewindDeterministicTargets, runDeterministicMovementSimulation, stepDeterministicFpsAim, stepDeterministicKcc2D, stepDeterministicTopDownMover, validateDeterministicLagCompensatedHit, } from './movement.js';
+export * from './movement3d.js';
+export type { DeterministicFpsAimState, DeterministicFpsInput, DeterministicKccBody, DeterministicKccInput, DeterministicKccStepResult, DeterministicMovementCrowdMetrics, DeterministicMovementSimulationMetrics, DeterministicMovementWorld, DeterministicMovingPlatform, DeterministicOneWayPlatform, DeterministicSlope, DeterministicMovementStep, DeterministicTargetSnapshot, DeterministicTopDownBody, DeterministicTopDownBounds, DeterministicTopDownInput, } from './movement.js';
+export { applyDeterministicReciprocalAvoidance, cookDeterministicNavigationGraph, cookTilemapNavigationGraph, createDeterministicFlowField, findDeterministicPath, smoothDeterministicPath, stepDeterministicNavigationAgents, } from './navigation.js';
+export * from './navmesh.js';
+export * from './engine-parity-matrix.js';
+export type { CookedDeterministicNavigationGraph, DeterministicFlowField, DeterministicNavEdge, DeterministicNavigationAgent, DeterministicNavigationGraphSource, DeterministicNavigationStepOptions, DeterministicNavigationStepResult, DeterministicNavNode, DeterministicNavRegion, DeterministicPathQuery, DeterministicPathResult, DeterministicTilemapSource, } from './navigation.js';
+export { runNumberLab } from './number-lab.js';
+export { createOfflineSession } from './offline-session.js';
+export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export * from './rollback-history.js';
+export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D, } from './physics2d.js';
+export * from './physics3d.js';
+export type { DeterministicBodyKind, DeterministicContactEvent2D, DeterministicContactEventType, DeterministicPhysicsAabbQuery2D, DeterministicPhysicsBody2D, DeterministicPhysicsConstraint2D, DeterministicPhysicsHit2D, DeterministicPhysicsQueryOptions2D, DeterministicPhysicsRaycastQuery2D, DeterministicPhysicsCircleCastQuery2D, DeterministicPhysicsShape2D, DeterministicPhysicsShapeOverlapQuery2D, DeterministicPhysicsStepOptions2D, DeterministicPhysicsStepResult2D, DeterministicPhysicsWorld2D, } from './physics2d.js';
+export { runPhysicsCert, runRapierPhysicsCert } from './physics-cert.js';
+export { runPredictionCullingLab } from './prediction-culling.js';
+export { createDeterministicR3fDebugOverlay, createDeterministicR3fRenderAdapter, interpolateDeterministicRenderNumber, interpolateDeterministicRenderVec2, } from './r3f-render-adapter.js';
+export { runProtocolRollbackLab } from './protocol-lab.js';
+export { createProtocolRollbackReport, diffDeterministicReports, renderDeterministicReportHtml, stableReportDiffJson, stableReportJson, } from './reports.js';
+export { diffReplayFrames, explainReplayChecksum, inspectReplayFrame, inspectReplayFrameWithDescriptor, stableFrameDiffJson, stableFrameDumpJson, } from './replay-inspect.js';
+export { deterministicSampleSceneIds, runAllDeterministicSampleScenes, runDeterministicIntegratedHeadlessScene, runDeterministicSampleScene, } from './sample-scenes.js';
+export type { DeterministicIntegratedHeadlessSceneResult, DeterministicSampleSceneId, DeterministicSampleSceneResult, } from './sample-scenes.js';
+export { DeterministicRandom } from './random.js';
+export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
+export * from './replay-scoring.js';
+export { createDeterministicReplayBundle, createDeterministicReplayDebugTables, createDeterministicReplayRuntimeManifest, minimizeDeterministicReplayDesync, minimizeDeterministicReplayDesyncBundle, sliceDeterministicReplayBundle, verifyDeterministicFrameRuntimeReplayBundle, verifyDeterministicReplayBundle, verifyDeterministicSelfContainedFrameRuntimeReplayBundle, } from './replay-bundle.js';
+export type { DeterministicFrameRuntimeReplayBundleOptions, DeterministicFrameRuntimeReplayBundleVerification, DeterministicReplayBundle, DeterministicReplayBundleMismatch, DeterministicReplayBundleVerification, DeterministicReplayDebugTables, DeterministicReplayDesyncMinimization, DeterministicReplayRuntimeBeforeFrameId, DeterministicReplayRuntimeManifest, DeterministicReplayRuntimeManifestSource, DeterministicReplayRuntimeSystemId, DeterministicReplaySemanticModel, DeterministicReplaySemanticOperation, DeterministicReplaySliceOrigin, DeterministicReplaySnapshot, } from './replay-bundle.js';
+export * from './local-authority.js';
+export * from './local-authority-wire.js';
+export * from './input-authority.js';
+export * from './session-wire.js';
+export * from './session-snapshot.js';
+export * from './networked-client.js';
+export * from './authority-room.js';
+export * from './multiclient-authority.js';
+export { withRuntimeDeterminismGuards } from './runtime-guards.js';
+export { createLabSession, hydrateLabInput, labDefaultInput, labStep } from './sample-lab.js';
+export { createSchemaArtifacts } from './schema-artifacts.js';
+export { createDeterministicDescriptorBinarySchema, generateSchemaBinarySource, generateSchemaTypes, proveSchemaBinaryRoundTrip, } from './schema-codegen.js';
+export { defineSyncplayGame, stableDescriptorId } from './schema.js';
+export * from './schema-dsl-binary.js';
+export * from './signals.js';
+export * from './sparse-set.js';
+export * from './system-lifecycle.js';
+export { createCooldown, framesToMilliseconds, millisecondsToFrames, popDueFrameEvents, scheduleFrameEvent, tickCooldown, } from './timers.js';
+export { runVenusMpBudgetLab } from './venus-mp-budget.js';
+export type { DeterministicCooldown, ScheduledFrameEvent } from './timers.js';
+export type { DeterministicSchemaArtifacts, SchemaFrameDump } from './schema-artifacts.js';
+export type { DeterministicOfflineFrame, DeterministicOfflineRuntime, DeterministicOfflineRuntimeConfig, } from './sdk-offline.js';
+export type { SchemaBinaryProof, SchemaBinarySourceOptions, SchemaTypesOptions } from './schema-codegen.js';
+export type { AssetDescriptor, CollectionOrdering, CommandChannelDescriptor, ConfigDescriptor, DeterministicGameDescriptor, EventDescriptor, InputFieldDescriptor, InputFieldPolicy, NumericMode, SchemaFieldDescriptor, SchemaFieldKind, StateFieldDescriptor, SystemDescriptor, PrototypeDescriptor, ValidatedDeterministicGameDescriptor, } from './schema.js';
+export type { LabInput, LabSessionOptions, LabState } from './sample-lab.js';
+export type { ProtocolRollbackEventPayload, ProtocolRollbackEventTimeline, ProtocolPredictionPolicy, ProtocolRollbackGame, ProtocolRollbackLabOptions, ProtocolRollbackLabResult, } from './protocol-lab.js';
+export type { DeterministicReport, DeterministicAssetCookCliFileResult, DeterministicAssetCookCliReport, DeterministicReportDiff, DeterministicReportDiffEntry, ProtocolRollbackReport, ReplayVerifyCliFileResult, ReplayVerifyCliReport, StaticDeterminismReport, } from './reports.js';
+export type { PredictionCullingMode, PredictionCullingOptions, PredictionCullingResult } from './prediction-culling.js';
+export type { DeterministicR3fRenderAdapter, DeterministicR3fRenderAdapterConfig, DeterministicR3fRenderDebug, DeterministicR3fRenderFrame, DeterministicRenderReadonly, } from './r3f-render-adapter.js';
+export type { DescriptorReplayInspectConfig, ReplayDiffResult, ReplayFrameDiff, ReplayFrameDump, ReplayInspectConfig, ReplayChecksumExplanation, ReplayChecksumTableExplanation, } from './replay-inspect.js';
+export type { DescriptorReplayVerificationConfig, ReplayVerificationConfig } from './replay.js';
+export type { NumberLabMode, NumberLabOptions, NumberLabResult } from './number-lab.js';
+export type { PhysicsCertEngine, PhysicsCertOptions, PhysicsCertResult, PhysicsCertShape } from './physics-cert.js';
+export type { VenusMpBudgetOptions, VenusMpBudgetResult } from './venus-mp-budget.js';
+export type { DeterministicSessionConfig, DeterministicStep, DeterministicStepContext, FrameSnapshot, OfflineSession, RecordedChecksum, RecordedCommandFrame, RecordedDebugEvent, RecordedInputFrame, ReplayFile, ReplayRecordingMode, ReplayVerificationMismatch, ReplayVerificationResult, TickRate, } from './types.js';

package/dist/index.js

@@ -0,0 +1,66 @@
+export { canonicalize, canonicalStringify, cloneCanonical, decodeCanonicalValue, decodeUtf8, defaultChecksum, encodeUtf8 } from './canonical.js';
+export * from './animation.js';
+export { cookDeterministicBotAsset, createDeterministicBotBlackboard, getBlackboardValue, runDeterministicBotSimulation, selectDeterministicUtility, tickDeterministicBehaviorTree, tickDeterministicBehaviorTreeWithMemory, tickDeterministicHfsm, } from './bot-primitives.js';
+export * from './bot-documents.js';
+export * from './commands.js';
+export * from './config-bundle.js';
+export * from './input-timeline.js';
+export * from './lag-compensation3d.js';
+export { assertAssetManifestMatches, cookDeterministicAssets, materializePrototypeEntities, stableAssetCookJson, } from './asset-cooking.js';
+export { aabbContainsPoint, aabbIntersects, circleIntersects, circleIntersectsAabb, fixedAabb, fixedCircle, fixedVec2, sortAabbsByStableId, translateAabb, } from './collision.js';
+export { createStableIndexedMap, deterministicShuffle, stableEntries, stableSortedKeys } from './collections.js';
+export { combineDeterministicPhysicsMaterial, cookStaticColliders, detectVerticalCcdHit, quantizeFpsAim, stepKccLiteBody, stepTopDownBody, } from './deterministic-primitives.js';
+export { createDeterministicEventEffectsAdapter } from './effects-adapter.js';
+export { createDeterministicEventTimeline, filterDeterministicEventsForPlayer, runDeterministicEventKeywordFixture } from './events.js';
+export { createEcsLiteWorld } from './ecs-lite.js';
+export * from './engine-core-proof.js';
+export * from './engine-complete.js';
+export * from './engine-runtime.js';
+export * from './deterministic-session.js';
+export { deterministicButtonInitialState, runDeterministicButtonFixture, runDeterministicDescriptorButtonFixture, stepDeterministicButton, } from './input-button.js';
+export { createCounterDuelSession, counterDuelDefaultInput, makeCounterDuelInput, runCounterDuelExample, verifyCounterDuelReplay, } from './examples/counter-duel.js';
+export { createFixedArenaDescriptor, createFixedArenaSession, createInitialFixedArenaState, fixedArenaDefaultInput, fixedArenaStep, makeFixedArenaInput, projectFixedArenaReferenceView, projectFixedArenaRenderState, runFixedArenaExample, verifyFixedArenaReplay, } from './examples/fixed-arena.js';
+export { SyncplayError } from './errors.js';
+export { createDeterministicMath } from './math.js';
+export { createDeterministicMockNetworkAdapter } from './mock-network-adapter.js';
+export { runDeterministicMovementCrowdSimulation, rewindDeterministicTargets, runDeterministicMovementSimulation, stepDeterministicFpsAim, stepDeterministicKcc2D, stepDeterministicTopDownMover, validateDeterministicLagCompensatedHit, } from './movement.js';
+export * from './movement3d.js';
+export { applyDeterministicReciprocalAvoidance, cookDeterministicNavigationGraph, cookTilemapNavigationGraph, createDeterministicFlowField, findDeterministicPath, smoothDeterministicPath, stepDeterministicNavigationAgents, } from './navigation.js';
+export * from './navmesh.js';
+export * from './engine-parity-matrix.js';
+export { runNumberLab } from './number-lab.js';
+export { createOfflineSession } from './offline-session.js';
+export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export * from './rollback-history.js';
+export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D, } from './physics2d.js';
+export * from './physics3d.js';
+export { runPhysicsCert, runRapierPhysicsCert } from './physics-cert.js';
+export { runPredictionCullingLab } from './prediction-culling.js';
+export { createDeterministicR3fDebugOverlay, createDeterministicR3fRenderAdapter, interpolateDeterministicRenderNumber, interpolateDeterministicRenderVec2, } from './r3f-render-adapter.js';
+export { runProtocolRollbackLab } from './protocol-lab.js';
+export { createProtocolRollbackReport, diffDeterministicReports, renderDeterministicReportHtml, stableReportDiffJson, stableReportJson, } from './reports.js';
+export { diffReplayFrames, explainReplayChecksum, inspectReplayFrame, inspectReplayFrameWithDescriptor, stableFrameDiffJson, stableFrameDumpJson, } from './replay-inspect.js';
+export { deterministicSampleSceneIds, runAllDeterministicSampleScenes, runDeterministicIntegratedHeadlessScene, runDeterministicSampleScene, } from './sample-scenes.js';
+export { DeterministicRandom } from './random.js';
+export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
+export * from './replay-scoring.js';
+export { createDeterministicReplayBundle, createDeterministicReplayDebugTables, createDeterministicReplayRuntimeManifest, minimizeDeterministicReplayDesync, minimizeDeterministicReplayDesyncBundle, sliceDeterministicReplayBundle, verifyDeterministicFrameRuntimeReplayBundle, verifyDeterministicReplayBundle, verifyDeterministicSelfContainedFrameRuntimeReplayBundle, } from './replay-bundle.js';
+export * from './local-authority.js';
+export * from './local-authority-wire.js';
+export * from './input-authority.js';
+export * from './session-wire.js';
+export * from './session-snapshot.js';
+export * from './networked-client.js';
+export * from './authority-room.js';
+export * from './multiclient-authority.js';
+export { withRuntimeDeterminismGuards } from './runtime-guards.js';
+export { createLabSession, hydrateLabInput, labDefaultInput, labStep } from './sample-lab.js';
+export { createSchemaArtifacts } from './schema-artifacts.js';
+export { createDeterministicDescriptorBinarySchema, generateSchemaBinarySource, generateSchemaTypes, proveSchemaBinaryRoundTrip, } from './schema-codegen.js';
+export { defineSyncplayGame, stableDescriptorId } from './schema.js';
+export * from './schema-dsl-binary.js';
+export * from './signals.js';
+export * from './sparse-set.js';
+export * from './system-lifecycle.js';
+export { createCooldown, framesToMilliseconds, millisecondsToFrames, popDueFrameEvents, scheduleFrameEvent, tickCooldown, } from './timers.js';
+export { runVenusMpBudgetLab } from './venus-mp-budget.js';

package/dist/input-authority.d.ts

@@ -0,0 +1,82 @@
+import { type CanonicalValue } from './canonical.js';
+/**
+ * Game-agnostic input authority (server orders inputs, clients simulate — §2 Option 1).
+ *
+ * It orders per-slot inputs by tick and confirms each tick exactly once, in order,
+ * either when every player slot has reported or when a HardTolerance deadline elapses
+ * (substituting the slot's last confirmed input). It never runs the simulation — only
+ * inputs cross the wire and clients run the deterministic sim locally.
+ *
+ * This module is the reusable core: the M0 spike hosts it over sockets, and M2 lifts it
+ * into the mp-room-server room type unchanged.
+ */
+/** Opaque, engine-defined input payload. The authority never interprets it. */
+export type EncodedInput = CanonicalValue;
+export interface ConfirmedInputFrame {
+    readonly tick: number;
+    /** One entry per player slot, in slot order. */
+    readonly inputs: readonly EncodedInput[];
+    /** Slots whose input was substituted (repeated) because it never arrived in time. */
+    readonly substitutedSlots: readonly number[];
+    readonly checksum: string;
+}
+export interface InputAuthorityConfig {
+    readonly playerCount: number;
+    /** Confirm a tick once `now - tick >= hardToleranceTicks`, substituting any missing input. */
+    readonly hardToleranceTicks: number;
+    /** Substitute this when a slot has no prior confirmed input to repeat. */
+    readonly neutralInput: EncodedInput;
+    /** Reject inputs whose tick is further ahead than `confirmedThrough + maxFutureTicks`. */
+    readonly maxFutureTicks?: number;
+    /** Confirmed frames retained for the redundant broadcast window. */
+    readonly retainedConfirmedFrames?: number;
+    /**
+     * Rebuild a previously-persisted authority (M6.5 crash recovery): the
+     * retained frames, frontier, and per-slot last-confirmed inputs (derived
+     * from the final frame — confirmed inputs equal the post-substitution
+     * last-confirmed values by construction). Fail-loud on gaps or a frontier
+     * mismatch.
+     */
+    readonly restoreFrom?: InputAuthorityRestoreState;
+}
+export interface InputAuthorityRestoreState {
+    readonly confirmedThrough: number;
+    readonly frames: readonly ConfirmedInputFrame[];
+}
+export type InputRejectionReason = 'slot-out-of-range' | 'invalid-tick' | 'tick-already-confirmed' | 'tick-too-far-ahead';
+export interface InputSubmissionResult {
+    readonly accepted: boolean;
+    readonly reason?: InputRejectionReason;
+}
+export interface InputAuthorityStats {
+    readonly confirmedTicks: number;
+    readonly substitutedInputs: number;
+    readonly droppedLateInputs: number;
+    readonly rejectedFutureInputs: number;
+}
+export interface InputAuthority {
+    readonly playerCount: number;
+    /** Highest confirmed tick, or -1 when nothing is confirmed yet. */
+    readonly confirmedThrough: number;
+    /** Lowest confirmed tick still retained, or -1 when nothing is confirmed yet. */
+    readonly earliestRetainedTick: number;
+    receiveInput(slot: number, tick: number, input: EncodedInput): InputSubmissionResult;
+    /** Confirm every tick that can be confirmed up to and including `now`. Returns the new frames in order. */
+    advance(now: number): readonly ConfirmedInputFrame[];
+    /** A confirmed frame still inside the retained window, for redundant re-broadcast. */
+    confirmedFrame(tick: number): ConfirmedInputFrame | undefined;
+    /**
+     * The retained frames `from..to` inclusive, for persistence (M6.5). Throws
+     * if any tick in the range is no longer retained — a persisted record with
+     * a silent gap would strand every restored client.
+     */
+    confirmedFrameRange(from: number, to: number): readonly ConfirmedInputFrame[];
+    /**
+     * Drop retained frames below `tick` (M5.5: history before a validated
+     * snapshot is no longer needed for late-join catch-up). Never moves the
+     * frontier; a no-op at or below the current earliest retained tick.
+     */
+    pruneConfirmedBefore(tick: number): void;
+    stats(): InputAuthorityStats;
+}
+export declare function createInputAuthority(config: InputAuthorityConfig): InputAuthority;