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

package/dist/bot-primitives.d.ts

@@ -0,0 +1,152 @@
+export type DeterministicBlackboardValue = boolean | number | string;
+export interface DeterministicBlackboardEntry {
+    readonly key: string;
+    readonly value: DeterministicBlackboardValue;
+}
+export interface DeterministicBotBlackboard {
+    readonly entries: readonly DeterministicBlackboardEntry[];
+    readonly hash: string;
+}
+export interface DeterministicHfsmState {
+    readonly id: string;
+    readonly parent?: string;
+    readonly action?: string;
+}
+export interface DeterministicHfsmTransition {
+    readonly from: string;
+    readonly to: string;
+    readonly whenKey: string;
+    readonly equals: DeterministicBlackboardValue;
+}
+export interface DeterministicHfsmDefinition {
+    readonly initialState: string;
+    readonly states: readonly DeterministicHfsmState[];
+    readonly transitions: readonly DeterministicHfsmTransition[];
+}
+export interface DeterministicHfsmAgent {
+    readonly state: string;
+    readonly transitionsTaken: number;
+    readonly actionLog: readonly string[];
+}
+export type DeterministicBehaviorTreeStatus = 'success' | 'failure' | 'running';
+export interface DeterministicBehaviorTreeService {
+    readonly id: string;
+    readonly action: string;
+    readonly intervalFrames: number;
+}
+export type DeterministicBehaviorTreeNode = {
+    readonly id: string;
+    readonly type: 'sequence' | 'selector';
+    readonly children: readonly DeterministicBehaviorTreeNode[];
+    readonly services?: readonly DeterministicBehaviorTreeService[];
+} | {
+    readonly id: string;
+    readonly type: 'decorator';
+    readonly mode: 'invert' | 'force-success' | 'force-failure';
+    readonly child: DeterministicBehaviorTreeNode;
+    readonly services?: readonly DeterministicBehaviorTreeService[];
+} | {
+    readonly id: string;
+    readonly type: 'condition';
+    readonly key: string;
+    readonly equals: DeterministicBlackboardValue;
+    readonly services?: readonly DeterministicBehaviorTreeService[];
+} | {
+    readonly id: string;
+    readonly type: 'action';
+    readonly action: string;
+    readonly status?: DeterministicBehaviorTreeStatus;
+    readonly services?: readonly DeterministicBehaviorTreeService[];
+};
+export interface DeterministicBehaviorTreeTick {
+    readonly status: DeterministicBehaviorTreeStatus;
+    readonly actions: readonly string[];
+    readonly visitedNodeIds: readonly string[];
+}
+export interface DeterministicBehaviorTreeMemory {
+    readonly runningNodeIds: readonly string[];
+    readonly completedRunningNodeIds: readonly string[];
+}
+export interface DeterministicBehaviorTreeStatefulTick extends DeterministicBehaviorTreeTick {
+    readonly memory: DeterministicBehaviorTreeMemory;
+    readonly resumedNodeIds: readonly string[];
+    readonly serviceActions: readonly string[];
+    readonly serviceNodeIds: readonly string[];
+}
+export type DeterministicUtilityCurve = 'linear' | 'inverse' | 'quadratic' | 'step';
+export interface DeterministicUtilityNestedConsideration {
+    readonly id: string;
+    readonly inputKey: string;
+    readonly min: number;
+    readonly max: number;
+    readonly weight: number;
+    readonly curve?: DeterministicUtilityCurve;
+}
+export interface DeterministicUtilityConsideration {
+    readonly id: string;
+    readonly inputKey: string;
+    readonly action: string;
+    readonly min: number;
+    readonly max: number;
+    readonly weight: number;
+    readonly rank?: number;
+    readonly curve?: DeterministicUtilityCurve;
+    readonly momentumKey?: string;
+    readonly momentum?: number;
+    readonly cooldownKey?: string;
+    readonly cooldownPenalty?: number;
+    readonly nested?: readonly DeterministicUtilityNestedConsideration[];
+}
+export interface DeterministicUtilitySelection {
+    readonly action: string;
+    readonly considerationId: string;
+    readonly score: number;
+    readonly scores: readonly {
+        readonly id: string;
+        readonly score: number;
+        readonly baseScore: number;
+        readonly nestedScore: number;
+        readonly momentumScore: number;
+        readonly cooldownPenalty: number;
+    }[];
+}
+export interface DeterministicBotAssetSource {
+    readonly id: string;
+    readonly hfsm?: DeterministicHfsmDefinition;
+    readonly behaviorTree?: DeterministicBehaviorTreeNode;
+    readonly utility?: readonly DeterministicUtilityConsideration[];
+}
+export interface CookedDeterministicBotAsset {
+    readonly id: string;
+    readonly bytes: string;
+    readonly hash: string;
+}
+export interface DeterministicBotSimulationMetrics {
+    readonly checksum: string;
+    readonly blackboardHash: string;
+    readonly cookedBotHash: string;
+    readonly styles: string;
+    readonly hfsmTransitions: number;
+    readonly behaviorTreeTicks: number;
+    readonly behaviorRunningTicks: number;
+    readonly behaviorResumeTicks: number;
+    readonly behaviorDecoratorTicks: number;
+    readonly behaviorServiceTicks: number;
+    readonly utilitySelections: number;
+    readonly utilityCurveSelections: number;
+    readonly utilityNestedSelections: number;
+    readonly utilityMomentumSelections: number;
+    readonly utilityCooldownSuppressions: number;
+    readonly botReplacementSlots: number;
+    readonly humanInputSlots: number;
+    readonly botInputSlots: number;
+    readonly mixedHumanBotLanes: boolean;
+}
+export declare function createDeterministicBotBlackboard(entries: readonly DeterministicBlackboardEntry[]): DeterministicBotBlackboard;
+export declare function getBlackboardValue(blackboard: DeterministicBotBlackboard, key: string): DeterministicBlackboardValue | undefined;
+export declare function tickDeterministicHfsm(definition: DeterministicHfsmDefinition, agent: DeterministicHfsmAgent, blackboard: DeterministicBotBlackboard): DeterministicHfsmAgent;
+export declare function tickDeterministicBehaviorTree(node: DeterministicBehaviorTreeNode, blackboard: DeterministicBotBlackboard): DeterministicBehaviorTreeTick;
+export declare function tickDeterministicBehaviorTreeWithMemory(node: DeterministicBehaviorTreeNode, blackboard: DeterministicBotBlackboard, memory?: DeterministicBehaviorTreeMemory): DeterministicBehaviorTreeStatefulTick;
+export declare function selectDeterministicUtility(considerations: readonly DeterministicUtilityConsideration[], blackboard: DeterministicBotBlackboard): DeterministicUtilitySelection;
+export declare function cookDeterministicBotAsset(source: DeterministicBotAssetSource): CookedDeterministicBotAsset;
+export declare function runDeterministicBotSimulation(players: number, frames: number, seed: number, restoreFrame?: number): DeterministicBotSimulationMetrics;

package/dist/bot-primitives.js

@@ -0,0 +1,472 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+export 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: defaultChecksum(sorted),
+    };
+}
+export function getBlackboardValue(blackboard, key) {
+    return blackboard.entries.find((entry) => entry.key === key)?.value;
+}
+export 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,
+    };
+}
+export function tickDeterministicBehaviorTree(node, blackboard) {
+    const visitedNodeIds = [];
+    const actions = [];
+    const status = evaluateBehaviorTree(node, blackboard, visitedNodeIds, actions);
+    return {
+        status,
+        actions,
+        visitedNodeIds,
+    };
+}
+export 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),
+    };
+}
+export 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,
+    };
+}
+export 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 = canonicalStringify(cooked);
+    return {
+        id: source.id,
+        bytes,
+        hash: defaultChecksum(bytes),
+    };
+}
+export 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 = cloneCanonical(bots);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 6) {
+            bots = 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: 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/browser.d.ts

@@ -0,0 +1,57 @@
+export { verifyReplay } from './replay.js';
+export { verifyReplayWithDescriptor as verifyDeterministicReplay } from './replay.js';
+export { createOfflineSession } from './offline-session.js';
+export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export { createSyncplayOfflineRuntime as createSyncplayGameRuntime } from './sdk-offline.js';
+export { runNumberLab } from './number-lab.js';
+export { runDeterministicEngineCoreNumericProof } from './engine-core-proof.js';
+export { hydrateLabInput, labDefaultInput, labStep } from './sample-lab.js';
+export { createFixedArenaDescriptor, createInitialFixedArenaState, fixedArenaDefaultInput, fixedArenaStep, projectFixedArenaReferenceView, projectFixedArenaRenderState, runFixedArenaExample, } from './examples/fixed-arena.js';
+export { createDeterministicR3fRenderAdapter as createDeterministicR3fAdapter, createDeterministicR3fRenderAdapter, interpolateDeterministicRenderNumber, interpolateDeterministicRenderVec2, } from './r3f-render-adapter.js';
+export * from './animation.js';
+export * from './asset-cooking.js';
+export * from './bot-documents.js';
+export * from './bot-primitives.js';
+export * from './canonical.js';
+export * from './collections.js';
+export * from './commands.js';
+export * from './config-bundle.js';
+export * from './deterministic-session.js';
+export * from './effects-adapter.js';
+export * from './engine-runtime.js';
+export * from './events.js';
+export { deterministicButtonInitialState, runDeterministicButtonFixture, runDeterministicDescriptorButtonFixture, stepDeterministicButton, } from './input-button.js';
+export type { DeterministicButtonFixtureResult, DeterministicButtonState, DeterministicButtonStep, DeterministicDescriptorButtonFixtureResult, } from './input-button.js';
+export * from './input-timeline.js';
+export * from './instant-replay.js';
+export * from './pause-resume.js';
+export * from './session-promotion.js';
+export * from './lag-compensation3d.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 './authority-room.js';
+export * from './networked-client.js';
+export * from './math.js';
+export { createSyncplayClient } from './multiplayer-service.js';
+export type { DeterministicAuthorityCertificationArtifact, DeterministicAuthorityCertificationVerification, DeterministicAuthorityChecksums, SyncplayClient, SyncplayClientConnection, SyncplayClientRole, SyncplayCommand, SyncplayCommandPollOptions, SyncplayCommandSubmitResult, SyncplayInput, SyncplayLifecycleResult, SyncplaySubmitResult, } from './multiplayer-service.js';
+export * from './movement.js';
+export * from './movement3d.js';
+export * from './navigation.js';
+export * from './navmesh.js';
+export * from './collision.js';
+export * from './physics2d.js';
+export * from './physics3d.js';
+export * from './replay-bundle.js';
+export * from './schema.js';
+export * from './schema-artifacts.js';
+export * from './schema-codegen.js';
+export * from './schema-dsl-binary.js';
+export * from './signals.js';
+export * from './sparse-set.js';
+export * from './sample-scenes.js';
+export * from './system-lifecycle.js';
+export type { DeterministicEngineCoreNumericProof, DeterministicEngineCoreNumericProofOptions } from './engine-core-proof.js';
+export type { DeterministicStep, ReplayFile, ReplayVerificationResult } from './types.js';