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

package/dist/cjs/bot-primitives.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicBotBlackboard = createDeterministicBotBlackboard;
+exports.getBlackboardValue = getBlackboardValue;
+exports.tickDeterministicHfsm = tickDeterministicHfsm;
+exports.tickDeterministicBehaviorTree = tickDeterministicBehaviorTree;
+exports.tickDeterministicBehaviorTreeWithMemory = tickDeterministicBehaviorTreeWithMemory;
+exports.selectDeterministicUtility = selectDeterministicUtility;
+exports.cookDeterministicBotAsset = cookDeterministicBotAsset;
+exports.runDeterministicBotSimulation = runDeterministicBotSimulation;
+const canonical_js_1 = require("./canonical.js");
+function createDeterministicBotBlackboard(entries) {
+    const sorted = [...entries].sort((left, right) => compareStrings(left.key, right.key));
+    const duplicate = sorted.find((entry, index) => index > 0 && entry.key === sorted[index - 1].key);
+    if (duplicate !== undefined) {
+        throw new Error(`Duplicate blackboard key ${duplicate.key}`);
+    }
+    return {
+        entries: sorted,
+        hash: (0, canonical_js_1.defaultChecksum)(sorted),
+    };
+}
+function getBlackboardValue(blackboard, key) {
+    return blackboard.entries.find((entry) => entry.key === key)?.value;
+}
+function tickDeterministicHfsm(definition, agent, blackboard) {
+    const states = new Map(definition.states.map((state) => [state.id, state]));
+    const current = states.get(agent.state);
+    if (current === undefined) {
+        throw new Error(`Unknown HFSM state ${agent.state}`);
+    }
+    const transition = definition.transitions
+        .filter((candidate) => candidate.from === agent.state || candidate.from === current.parent)
+        .sort(compareTransitions)
+        .find((candidate) => getBlackboardValue(blackboard, candidate.whenKey) === candidate.equals);
+    const nextState = transition?.to ?? agent.state;
+    const next = states.get(nextState);
+    if (next === undefined) {
+        throw new Error(`Unknown HFSM transition target ${nextState}`);
+    }
+    const actionLog = next.action === undefined ? agent.actionLog : [...agent.actionLog, next.action];
+    return {
+        state: nextState,
+        transitionsTaken: agent.transitionsTaken + (transition === undefined ? 0 : 1),
+        actionLog,
+    };
+}
+function tickDeterministicBehaviorTree(node, blackboard) {
+    const visitedNodeIds = [];
+    const actions = [];
+    const status = evaluateBehaviorTree(node, blackboard, visitedNodeIds, actions);
+    return {
+        status,
+        actions,
+        visitedNodeIds,
+    };
+}
+function tickDeterministicBehaviorTreeWithMemory(node, blackboard, memory = { runningNodeIds: [], completedRunningNodeIds: [] }) {
+    const visitedNodeIds = [];
+    const actions = [];
+    const resumedNodeIds = [];
+    const serviceActions = [];
+    const serviceNodeIds = [];
+    const nextMemory = {
+        runningNodeIds: [...memory.runningNodeIds].sort(compareStrings),
+        completedRunningNodeIds: [...memory.completedRunningNodeIds].sort(compareStrings),
+    };
+    const status = evaluateBehaviorTreeWithMemory(node, blackboard, visitedNodeIds, actions, resumedNodeIds, serviceActions, serviceNodeIds, nextMemory);
+    return {
+        status,
+        actions,
+        visitedNodeIds,
+        memory: {
+            runningNodeIds: nextMemory.runningNodeIds.sort(compareStrings),
+            completedRunningNodeIds: nextMemory.completedRunningNodeIds.sort(compareStrings),
+        },
+        resumedNodeIds: resumedNodeIds.sort(compareStrings),
+        serviceActions,
+        serviceNodeIds: serviceNodeIds.sort(compareStrings),
+    };
+}
+function selectDeterministicUtility(considerations, blackboard) {
+    const scores = considerations
+        .map((consideration) => {
+        const baseScore = scoreUtilityInput(getBlackboardValue(blackboard, consideration.inputKey), consideration.min, consideration.max, consideration.weight, consideration.curve ?? 'linear');
+        const nestedScore = (consideration.nested ?? []).reduce((sum, nested) => sum + scoreUtilityInput(getBlackboardValue(blackboard, nested.inputKey), nested.min, nested.max, nested.weight, nested.curve ?? 'linear'), 0);
+        const momentumValue = consideration.momentumKey === undefined ? undefined : getBlackboardValue(blackboard, consideration.momentumKey);
+        const momentumScore = typeof momentumValue === 'number'
+            ? Math.trunc(momentumValue * (consideration.momentum ?? 0))
+            : momentumValue === true ? Math.trunc(consideration.momentum ?? 0) : 0;
+        const cooldownValue = consideration.cooldownKey === undefined ? undefined : getBlackboardValue(blackboard, consideration.cooldownKey);
+        const cooldownPenalty = typeof cooldownValue === 'number' && cooldownValue > 0
+            ? Math.trunc(cooldownValue * (consideration.cooldownPenalty ?? 1_000))
+            : cooldownValue === true ? Math.trunc(consideration.cooldownPenalty ?? 1_000) : 0;
+        const score = baseScore + nestedScore + momentumScore + (consideration.rank ?? 0) - cooldownPenalty;
+        return { id: consideration.id, score, baseScore, nestedScore, momentumScore, cooldownPenalty };
+    })
+        .sort((left, right) => right.score - left.score || compareStrings(left.id, right.id));
+    const selectedScore = scores[0];
+    const selected = considerations.find((consideration) => consideration.id === selectedScore.id);
+    if (selected === undefined) {
+        throw new Error('Utility selector requires at least one consideration');
+    }
+    return {
+        action: selected.action,
+        considerationId: selected.id,
+        score: selectedScore.score,
+        scores,
+    };
+}
+function cookDeterministicBotAsset(source) {
+    const cooked = {
+        id: source.id,
+        hfsm: source.hfsm === undefined ? undefined : normalizeHfsm(source.hfsm),
+        behaviorTree: source.behaviorTree === undefined ? undefined : normalizeBehaviorTree(source.behaviorTree),
+        utility: source.utility === undefined
+            ? undefined
+            : [...source.utility].sort((left, right) => compareStrings(left.id, right.id)),
+    };
+    const bytes = (0, canonical_js_1.canonicalStringify)(cooked);
+    return {
+        id: source.id,
+        bytes,
+        hash: (0, canonical_js_1.defaultChecksum)(bytes),
+    };
+}
+function runDeterministicBotSimulation(players, frames, seed, restoreFrame = -1) {
+    const hfsm = defaultHfsm();
+    const tree = defaultBehaviorTree();
+    const utility = defaultUtility();
+    const cooked = cookDeterministicBotAsset({ id: 'bot.default', hfsm, behaviorTree: tree, utility });
+    let bots = Array.from({ length: players }, (_, slot) => ({
+        slot,
+        lane: slot % 4 === 0 ? 'human' : 'bot',
+        hp: 10,
+        hfsm: { state: hfsm.initialState, transitionsTaken: 0, actionLog: [] },
+        target: (slot + 1) % players,
+        utility: 0,
+        utilityScoreBreakdown: [],
+        behaviorActions: [],
+        behaviorServiceActions: [],
+        behaviorStatus: 'success',
+        visitedBehaviorNodes: [],
+        behaviorMemory: { runningNodeIds: [], completedRunningNodeIds: [] },
+    }));
+    let snapshot = bots;
+    let hfsmTransitions = 0;
+    let behaviorTreeTicks = 0;
+    let behaviorRunningTicks = 0;
+    let behaviorResumeTicks = 0;
+    let behaviorDecoratorTicks = 0;
+    let behaviorServiceTicks = 0;
+    let utilitySelections = 0;
+    let utilityCurveSelections = 0;
+    let utilityNestedSelections = 0;
+    let utilityMomentumSelections = 0;
+    let utilityCooldownSuppressions = 0;
+    let humanInputSlots = 0;
+    let botInputSlots = 0;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = (0, canonical_js_1.cloneCanonical)(bots);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 6) {
+            bots = (0, canonical_js_1.cloneCanonical)(snapshot);
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                bots = stepBotFrame(bots, replay, seed, hfsm, tree, utility);
+            }
+        }
+        bots = stepBotFrame(bots, frame, seed, hfsm, tree, utility);
+        hfsmTransitions += bots.reduce((sum, bot) => sum + bot.hfsm.transitionsTaken, 0);
+        behaviorTreeTicks += bots.length;
+        behaviorRunningTicks += bots.filter((bot) => bot.behaviorStatus === 'running').length;
+        behaviorResumeTicks += bots.filter((bot) => bot.behaviorMemory.completedRunningNodeIds.length > 0).length;
+        behaviorDecoratorTicks += bots.filter((bot) => bot.visitedBehaviorNodes.includes('maybe-patrol')).length;
+        behaviorServiceTicks += bots.filter((bot) => bot.behaviorServiceActions.length > 0).length;
+        utilitySelections += bots.filter((bot) => bot.utility > 5_000).length;
+        utilityCurveSelections += bots.filter((bot) => bot.utilityScoreBreakdown.some((score) => score.baseScore !== 0)).length;
+        utilityNestedSelections += bots.filter((bot) => bot.utilityScoreBreakdown.some((score) => score.nestedScore !== 0)).length;
+        utilityMomentumSelections += bots.filter((bot) => bot.utilityScoreBreakdown.some((score) => score.momentumScore !== 0)).length;
+        utilityCooldownSuppressions += bots.filter((bot) => bot.utilityScoreBreakdown.some((score) => score.cooldownPenalty > 0)).length;
+        humanInputSlots += bots.filter((bot) => bot.lane === 'human').length;
+        botInputSlots += bots.filter((bot) => bot.lane === 'bot').length;
+    }
+    const blackboard = createDeterministicBotBlackboard(bots.map((bot) => ({
+        key: `slot:${bot.slot.toString().padStart(3, '0')}`,
+        value: `${bot.hfsm.state}:${bot.target}`,
+    })));
+    return {
+        checksum: (0, canonical_js_1.defaultChecksum)(bots),
+        blackboardHash: blackboard.hash,
+        cookedBotHash: cooked.hash,
+        styles: 'behavior-tree,hfsm,utility',
+        hfsmTransitions,
+        behaviorTreeTicks,
+        behaviorRunningTicks,
+        behaviorResumeTicks,
+        behaviorDecoratorTicks,
+        behaviorServiceTicks,
+        utilitySelections,
+        utilityCurveSelections,
+        utilityNestedSelections,
+        utilityMomentumSelections,
+        utilityCooldownSuppressions,
+        botReplacementSlots: bots.filter((bot) => bot.lane === 'bot' && bot.slot >= Math.floor(players / 2)).length,
+        humanInputSlots,
+        botInputSlots,
+        mixedHumanBotLanes: humanInputSlots > 0 && botInputSlots > 0,
+    };
+}
+function stepBotFrame(bots, frame, seed, hfsm, tree, utility) {
+    return bots.map((bot) => {
+        const threat = (seed + frame + bot.slot) % 10;
+        const health = Math.max(0, bot.hp - ((frame + bot.slot) % 17 === 0 ? 1 : 0));
+        const blackboard = createDeterministicBotBlackboard([
+            { key: 'health', value: health },
+            { key: 'hasTarget', value: true },
+            { key: 'threat', value: threat },
+            { key: 'ammo', value: 5 - ((frame + bot.slot) % 5) },
+            { key: 'lastActionAttack', value: bot.utility > 5_000 },
+            { key: 'attackCooldown', value: (frame + bot.slot) % 11 === 0 ? 2 : 0 },
+            { key: 'frame', value: frame },
+        ]);
+        const nextHfsm = tickDeterministicHfsm(hfsm, bot.hfsm, blackboard);
+        const treeTick = tickDeterministicBehaviorTreeWithMemory(tree, blackboard, bot.behaviorMemory);
+        const selected = selectDeterministicUtility(utility, blackboard);
+        return {
+            slot: bot.slot,
+            lane: bot.lane,
+            hp: health,
+            hfsm: nextHfsm,
+            target: (bot.slot + 1 + (selected.action === 'flank' ? 1 : 0)) % bots.length,
+            utility: selected.score,
+            utilityScoreBreakdown: selected.scores,
+            behaviorActions: treeTick.actions,
+            behaviorServiceActions: treeTick.serviceActions,
+            behaviorStatus: treeTick.status,
+            visitedBehaviorNodes: treeTick.visitedNodeIds,
+            behaviorMemory: treeTick.memory,
+        };
+    });
+}
+function evaluateBehaviorTree(node, blackboard, visitedNodeIds, actions) {
+    visitedNodeIds.push(node.id);
+    if (node.type === 'condition') {
+        return getBlackboardValue(blackboard, node.key) === node.equals ? 'success' : 'failure';
+    }
+    if (node.type === 'action') {
+        actions.push(node.action);
+        return node.status ?? 'success';
+    }
+    if (node.type === 'decorator') {
+        const status = evaluateBehaviorTree(node.child, blackboard, visitedNodeIds, actions);
+        if (node.mode === 'force-success') {
+            return 'success';
+        }
+        if (node.mode === 'force-failure') {
+            return 'failure';
+        }
+        if (status === 'success') {
+            return 'failure';
+        }
+        if (status === 'failure') {
+            return 'success';
+        }
+        return 'running';
+    }
+    if (node.type === 'sequence') {
+        for (const child of node.children) {
+            const status = evaluateBehaviorTree(child, blackboard, visitedNodeIds, actions);
+            if (status !== 'success') {
+                return status;
+            }
+        }
+        return 'success';
+    }
+    for (const child of node.children) {
+        const status = evaluateBehaviorTree(child, blackboard, visitedNodeIds, actions);
+        if (status !== 'failure') {
+            return status;
+        }
+    }
+    return 'failure';
+}
+function evaluateBehaviorTreeWithMemory(node, blackboard, visitedNodeIds, actions, resumedNodeIds, serviceActions, serviceNodeIds, memory) {
+    visitedNodeIds.push(node.id);
+    runBehaviorTreeServices(node, blackboard, serviceActions, serviceNodeIds);
+    if (node.type === 'condition') {
+        return getBlackboardValue(blackboard, node.key) === node.equals ? 'success' : 'failure';
+    }
+    if (node.type === 'action') {
+        actions.push(node.action);
+        if (node.status !== 'running') {
+            removeRunningNode(memory, node.id);
+            return node.status ?? 'success';
+        }
+        if (memory.runningNodeIds.includes(node.id)) {
+            removeRunningNode(memory, node.id);
+            if (!memory.completedRunningNodeIds.includes(node.id)) {
+                memory.completedRunningNodeIds.push(node.id);
+            }
+            resumedNodeIds.push(node.id);
+            return 'success';
+        }
+        if (!memory.completedRunningNodeIds.includes(node.id)) {
+            memory.runningNodeIds.push(node.id);
+            return 'running';
+        }
+        return 'success';
+    }
+    if (node.type === 'decorator') {
+        const status = evaluateBehaviorTreeWithMemory(node.child, blackboard, visitedNodeIds, actions, resumedNodeIds, serviceActions, serviceNodeIds, memory);
+        if (node.mode === 'force-success') {
+            return 'success';
+        }
+        if (node.mode === 'force-failure') {
+            return 'failure';
+        }
+        if (status === 'success') {
+            return 'failure';
+        }
+        if (status === 'failure') {
+            return 'success';
+        }
+        return 'running';
+    }
+    if (node.type === 'sequence') {
+        for (const child of node.children) {
+            const status = evaluateBehaviorTreeWithMemory(child, blackboard, visitedNodeIds, actions, resumedNodeIds, serviceActions, serviceNodeIds, memory);
+            if (status !== 'success') {
+                return status;
+            }
+        }
+        return 'success';
+    }
+    for (const child of node.children) {
+        const status = evaluateBehaviorTreeWithMemory(child, blackboard, visitedNodeIds, actions, resumedNodeIds, serviceActions, serviceNodeIds, memory);
+        if (status !== 'failure') {
+            return status;
+        }
+    }
+    return 'failure';
+}
+function runBehaviorTreeServices(node, blackboard, serviceActions, serviceNodeIds) {
+    const frame = getBlackboardValue(blackboard, 'frame');
+    const frameNumber = typeof frame === 'number' ? frame : 0;
+    for (const service of [...(node.services ?? [])].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (service.intervalFrames <= 0) {
+            throw new Error(`Behavior service ${service.id} interval must be positive`);
+        }
+        if (frameNumber % service.intervalFrames === 0) {
+            serviceActions.push(service.action);
+            serviceNodeIds.push(`service:${service.id}`);
+        }
+    }
+}
+function scoreUtilityInput(value, min, max, weight, curve) {
+    const numericValue = typeof value === 'number' ? value : value === true ? max : min;
+    const clamped = Math.max(min, Math.min(max, numericValue));
+    const range = Math.max(1, max - min);
+    const linear = Math.trunc(((clamped - min) * 1_000) / range);
+    const curved = curve === 'inverse'
+        ? 1_000 - linear
+        : curve === 'quadratic'
+            ? Math.trunc((linear * linear) / 1_000)
+            : curve === 'step'
+                ? linear >= 500 ? 1_000 : 0
+                : linear;
+    return Math.trunc(curved * weight);
+}
+function removeRunningNode(memory, nodeId) {
+    memory.runningNodeIds = memory.runningNodeIds.filter((id) => id !== nodeId);
+}
+function normalizeHfsm(definition) {
+    return {
+        initialState: definition.initialState,
+        states: [...definition.states].sort((left, right) => compareStrings(left.id, right.id)),
+        transitions: [...definition.transitions].sort(compareTransitions),
+    };
+}
+function normalizeBehaviorTree(node) {
+    if (node.type === 'action' || node.type === 'condition') {
+        return { ...node, services: normalizeBehaviorServices(node.services) };
+    }
+    if (node.type === 'decorator') {
+        return { ...node, services: normalizeBehaviorServices(node.services), child: normalizeBehaviorTree(node.child) };
+    }
+    return {
+        ...node,
+        services: normalizeBehaviorServices(node.services),
+        children: node.children.map(normalizeBehaviorTree),
+    };
+}
+function normalizeBehaviorServices(services) {
+    if (services === undefined) {
+        return undefined;
+    }
+    return [...services].sort((left, right) => compareStrings(left.id, right.id));
+}
+function compareTransitions(left, right) {
+    return compareStrings(`${left.from}:${left.whenKey}:${left.to}`, `${right.from}:${right.whenKey}:${right.to}`);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function defaultHfsm() {
+    return {
+        initialState: 'idle',
+        states: [
+            { id: 'idle', action: 'wait' },
+            { id: 'seek', action: 'move' },
+            { id: 'attack', parent: 'seek', action: 'fire' },
+            { id: 'retreat', action: 'fallback' },
+        ],
+        transitions: [
+            { from: 'idle', to: 'seek', whenKey: 'hasTarget', equals: true },
+            { from: 'seek', to: 'attack', whenKey: 'threat', equals: 7 },
+            { from: 'attack', to: 'retreat', whenKey: 'health', equals: 3 },
+            { from: 'retreat', to: 'seek', whenKey: 'health', equals: 8 },
+        ],
+    };
+}
+function defaultBehaviorTree() {
+    return {
+        id: 'root',
+        type: 'selector',
+        services: [{ id: 'root-targeting-service', action: 'update-target', intervalFrames: 3 }],
+        children: [
+            {
+                id: 'attack-sequence',
+                type: 'sequence',
+                children: [
+                    { id: 'has-target', type: 'condition', key: 'hasTarget', equals: true },
+                    {
+                        id: 'maybe-patrol',
+                        type: 'decorator',
+                        mode: 'force-success',
+                        child: { id: 'patrol-if-calm', type: 'condition', key: 'threat', equals: 0 },
+                    },
+                    {
+                        id: 'windup-if-danger',
+                        type: 'selector',
+                        children: [
+                            {
+                                id: 'danger-windup',
+                                type: 'sequence',
+                                children: [
+                                    { id: 'is-dangerous', type: 'condition', key: 'threat', equals: 9 },
+                                    { id: 'windup-action', type: 'action', action: 'windup', status: 'running' },
+                                ],
+                            },
+                            { id: 'ready-action', type: 'action', action: 'ready' },
+                        ],
+                    },
+                    { id: 'attack-action', type: 'action', action: 'attack' },
+                ],
+            },
+            { id: 'idle-action', type: 'action', action: 'idle' },
+        ],
+    };
+}
+function defaultUtility() {
+    return [
+        {
+            id: 'attack',
+            inputKey: 'threat',
+            action: 'attack',
+            min: 0,
+            max: 9,
+            weight: 7,
+            rank: 2,
+            curve: 'quadratic',
+            momentumKey: 'lastActionAttack',
+            momentum: 2_000,
+            cooldownKey: 'attackCooldown',
+            cooldownPenalty: 3_000,
+            nested: [{ id: 'ammo-ready', inputKey: 'ammo', min: 0, max: 5, weight: 2, curve: 'step' }],
+        },
+        { id: 'flank', inputKey: 'threat', action: 'flank', min: 0, max: 9, weight: 6, rank: 1, curve: 'linear' },
+        { id: 'retreat', inputKey: 'health', action: 'retreat', min: 0, max: 10, weight: 5, curve: 'inverse' },
+    ];
+}

package/dist/cjs/browser.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncplayClient = exports.stepDeterministicButton = exports.runDeterministicDescriptorButtonFixture = exports.runDeterministicButtonFixture = exports.deterministicButtonInitialState = exports.interpolateDeterministicRenderVec2 = exports.interpolateDeterministicRenderNumber = exports.createDeterministicR3fRenderAdapter = exports.createDeterministicR3fAdapter = exports.runFixedArenaExample = exports.projectFixedArenaRenderState = exports.projectFixedArenaReferenceView = exports.fixedArenaStep = exports.fixedArenaDefaultInput = exports.createInitialFixedArenaState = exports.createFixedArenaDescriptor = exports.labStep = exports.labDefaultInput = exports.hydrateLabInput = exports.runDeterministicEngineCoreNumericProof = exports.runNumberLab = exports.createSyncplayGameRuntime = exports.createSyncplayOfflineRuntime = exports.createOfflineSession = exports.verifyDeterministicReplay = exports.verifyReplay = void 0;
+var replay_js_1 = require("./replay.js");
+Object.defineProperty(exports, "verifyReplay", { enumerable: true, get: function () { return replay_js_1.verifyReplay; } });
+var replay_js_2 = require("./replay.js");
+Object.defineProperty(exports, "verifyDeterministicReplay", { enumerable: true, get: function () { return replay_js_2.verifyReplayWithDescriptor; } });
+var offline_session_js_1 = require("./offline-session.js");
+Object.defineProperty(exports, "createOfflineSession", { enumerable: true, get: function () { return offline_session_js_1.createOfflineSession; } });
+var sdk_offline_js_1 = require("./sdk-offline.js");
+Object.defineProperty(exports, "createSyncplayOfflineRuntime", { enumerable: true, get: function () { return sdk_offline_js_1.createSyncplayOfflineRuntime; } });
+var sdk_offline_js_2 = require("./sdk-offline.js");
+Object.defineProperty(exports, "createSyncplayGameRuntime", { enumerable: true, get: function () { return sdk_offline_js_2.createSyncplayOfflineRuntime; } });
+var number_lab_js_1 = require("./number-lab.js");
+Object.defineProperty(exports, "runNumberLab", { enumerable: true, get: function () { return number_lab_js_1.runNumberLab; } });
+var engine_core_proof_js_1 = require("./engine-core-proof.js");
+Object.defineProperty(exports, "runDeterministicEngineCoreNumericProof", { enumerable: true, get: function () { return engine_core_proof_js_1.runDeterministicEngineCoreNumericProof; } });
+var sample_lab_js_1 = require("./sample-lab.js");
+Object.defineProperty(exports, "hydrateLabInput", { enumerable: true, get: function () { return sample_lab_js_1.hydrateLabInput; } });
+Object.defineProperty(exports, "labDefaultInput", { enumerable: true, get: function () { return sample_lab_js_1.labDefaultInput; } });
+Object.defineProperty(exports, "labStep", { enumerable: true, get: function () { return sample_lab_js_1.labStep; } });
+var fixed_arena_js_1 = require("./examples/fixed-arena.js");
+Object.defineProperty(exports, "createFixedArenaDescriptor", { enumerable: true, get: function () { return fixed_arena_js_1.createFixedArenaDescriptor; } });
+Object.defineProperty(exports, "createInitialFixedArenaState", { enumerable: true, get: function () { return fixed_arena_js_1.createInitialFixedArenaState; } });
+Object.defineProperty(exports, "fixedArenaDefaultInput", { enumerable: true, get: function () { return fixed_arena_js_1.fixedArenaDefaultInput; } });
+Object.defineProperty(exports, "fixedArenaStep", { enumerable: true, get: function () { return fixed_arena_js_1.fixedArenaStep; } });
+Object.defineProperty(exports, "projectFixedArenaReferenceView", { enumerable: true, get: function () { return fixed_arena_js_1.projectFixedArenaReferenceView; } });
+Object.defineProperty(exports, "projectFixedArenaRenderState", { enumerable: true, get: function () { return fixed_arena_js_1.projectFixedArenaRenderState; } });
+Object.defineProperty(exports, "runFixedArenaExample", { enumerable: true, get: function () { return fixed_arena_js_1.runFixedArenaExample; } });
+var r3f_render_adapter_js_1 = require("./r3f-render-adapter.js");
+Object.defineProperty(exports, "createDeterministicR3fAdapter", { enumerable: true, get: function () { return r3f_render_adapter_js_1.createDeterministicR3fRenderAdapter; } });
+Object.defineProperty(exports, "createDeterministicR3fRenderAdapter", { enumerable: true, get: function () { return r3f_render_adapter_js_1.createDeterministicR3fRenderAdapter; } });
+Object.defineProperty(exports, "interpolateDeterministicRenderNumber", { enumerable: true, get: function () { return r3f_render_adapter_js_1.interpolateDeterministicRenderNumber; } });
+Object.defineProperty(exports, "interpolateDeterministicRenderVec2", { enumerable: true, get: function () { return r3f_render_adapter_js_1.interpolateDeterministicRenderVec2; } });
+__exportStar(require("./animation.js"), exports);
+__exportStar(require("./asset-cooking.js"), exports);
+__exportStar(require("./bot-documents.js"), exports);
+__exportStar(require("./bot-primitives.js"), exports);
+__exportStar(require("./canonical.js"), exports);
+__exportStar(require("./collections.js"), exports);
+__exportStar(require("./commands.js"), exports);
+__exportStar(require("./config-bundle.js"), exports);
+__exportStar(require("./deterministic-session.js"), exports);
+__exportStar(require("./effects-adapter.js"), exports);
+__exportStar(require("./engine-runtime.js"), exports);
+__exportStar(require("./events.js"), exports);
+var input_button_js_1 = require("./input-button.js");
+Object.defineProperty(exports, "deterministicButtonInitialState", { enumerable: true, get: function () { return input_button_js_1.deterministicButtonInitialState; } });
+Object.defineProperty(exports, "runDeterministicButtonFixture", { enumerable: true, get: function () { return input_button_js_1.runDeterministicButtonFixture; } });
+Object.defineProperty(exports, "runDeterministicDescriptorButtonFixture", { enumerable: true, get: function () { return input_button_js_1.runDeterministicDescriptorButtonFixture; } });
+Object.defineProperty(exports, "stepDeterministicButton", { enumerable: true, get: function () { return input_button_js_1.stepDeterministicButton; } });
+__exportStar(require("./input-timeline.js"), exports);
+__exportStar(require("./instant-replay.js"), exports);
+__exportStar(require("./pause-resume.js"), exports);
+__exportStar(require("./session-promotion.js"), exports);
+__exportStar(require("./lag-compensation3d.js"), exports);
+__exportStar(require("./local-authority.js"), exports);
+__exportStar(require("./local-authority-wire.js"), exports);
+__exportStar(require("./input-authority.js"), exports);
+__exportStar(require("./session-wire.js"), exports);
+__exportStar(require("./session-snapshot.js"), exports);
+__exportStar(require("./authority-room.js"), exports);
+__exportStar(require("./networked-client.js"), exports);
+__exportStar(require("./math.js"), exports);
+var multiplayer_service_js_1 = require("./multiplayer-service.js");
+Object.defineProperty(exports, "createSyncplayClient", { enumerable: true, get: function () { return multiplayer_service_js_1.createSyncplayClient; } });
+__exportStar(require("./movement.js"), exports);
+__exportStar(require("./movement3d.js"), exports);
+__exportStar(require("./navigation.js"), exports);
+__exportStar(require("./navmesh.js"), exports);
+__exportStar(require("./collision.js"), exports);
+__exportStar(require("./physics2d.js"), exports);
+__exportStar(require("./physics3d.js"), exports);
+__exportStar(require("./replay-bundle.js"), exports);
+__exportStar(require("./schema.js"), exports);
+__exportStar(require("./schema-artifacts.js"), exports);
+__exportStar(require("./schema-codegen.js"), exports);
+__exportStar(require("./schema-dsl-binary.js"), exports);
+__exportStar(require("./signals.js"), exports);
+__exportStar(require("./sparse-set.js"), exports);
+__exportStar(require("./sample-scenes.js"), exports);
+__exportStar(require("./system-lifecycle.js"), exports);