@casual-simulation/aux-runtime 3.2.7-alpha.6226622763

package/runtime/AuxPartitionRealtimeEditModeProvider.d.ts

@@ -0,0 +1,9 @@
+import { AuxRealtimeEditModeProvider } from './AuxRealtimeEditModeProvider';
+import { AuxPartitions } from '@casual-simulation/aux-common';
+import { RealtimeEditMode } from './RuntimeBot';
+export declare class AuxPartitionRealtimeEditModeProvider implements AuxRealtimeEditModeProvider {
+    private _partitions;
+    constructor(partitions: AuxPartitions);
+    getEditMode(space: string): RealtimeEditMode;
+}
+//# sourceMappingURL=AuxPartitionRealtimeEditModeProvider.d.ts.map

package/runtime/AuxPartitionRealtimeEditModeProvider.js

@@ -0,0 +1,21 @@
+import { DEFAULT_REALTIME_EDIT_MODE, } from './AuxRealtimeEditModeProvider';
+import { realtimeStrategyToRealtimeEditMode } from './Utils';
+import { RealtimeEditMode } from './RuntimeBot';
+export class AuxPartitionRealtimeEditModeProvider {
+    constructor(partitions) {
+        this._partitions = partitions;
+    }
+    getEditMode(space) {
+        if (space in this._partitions) {
+            return realtimeStrategyToRealtimeEditMode(this._partitions[space].realtimeStrategy);
+        }
+        if (space === 'certified') {
+            return RealtimeEditMode.None;
+        }
+        else if (space === 'bootstrap') {
+            return RealtimeEditMode.None;
+        }
+        return DEFAULT_REALTIME_EDIT_MODE;
+    }
+}
+//# sourceMappingURL=AuxPartitionRealtimeEditModeProvider.js.map

package/runtime/AuxPartitionRealtimeEditModeProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuxPartitionRealtimeEditModeProvider.js","sourceRoot":"","sources":["AuxPartitionRealtimeEditModeProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,0BAA0B,GAC7B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,kCAAkC,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,OAAO,oCAAoC;IAK7C,YAAY,UAAyB;QACjC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAClC,CAAC;IAED,WAAW,CAAC,KAAa;QACrB,IAAI,KAAK,IAAI,IAAI,CAAC,WAAW,EAAE;YAC3B,OAAO,kCAAkC,CACrC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAC3C,CAAC;SACL;QACD,IAAI,KAAK,KAAK,WAAW,EAAE;YACvB,OAAO,gBAAgB,CAAC,IAAI,CAAC;SAChC;aAAM,IAAI,KAAK,KAAK,WAAW,EAAE;YAC9B,OAAO,gBAAgB,CAAC,IAAI,CAAC;SAChC;QACD,OAAO,0BAA0B,CAAC;IACtC,CAAC;CACJ"}

package/runtime/AuxRealtimeEditModeProvider.d.ts

@@ -0,0 +1,35 @@
+import { RealtimeEditMode } from './RuntimeBot';
+/**
+ * The default realtime edit mode.
+ */
+export declare const DEFAULT_REALTIME_EDIT_MODE: RealtimeEditMode;
+/**
+ * A map between space types and the realtime edit modes they should use.
+ */
+export type SpaceRealtimeEditModeMap = Map<string, RealtimeEditMode>;
+/**
+ * The default map between bot spaces and realtime edit modes.
+ */
+export declare const DEFAULT_SPACE_REALTIME_EDIT_MODE_MAP: SpaceRealtimeEditModeMap;
+/**
+ * Gets the realtime edit mode for the given space and map.
+ * @param map The map.
+ * @param space The space.
+ */
+export declare function getRealtimeEditMode(map: SpaceRealtimeEditModeMap, space: string): RealtimeEditMode;
+/**
+ * Defines an interface for an object that is able to provide realtime edit modes for a particular partition key.
+ */
+export interface AuxRealtimeEditModeProvider {
+    /**
+     * Gets the edit mode for the given space.
+     * @param space The space.
+     */
+    getEditMode(space: string): RealtimeEditMode;
+}
+export declare class DefaultRealtimeEditModeProvider implements AuxRealtimeEditModeProvider {
+    private _map;
+    constructor(map?: SpaceRealtimeEditModeMap);
+    getEditMode(space: string): RealtimeEditMode;
+}
+//# sourceMappingURL=AuxRealtimeEditModeProvider.d.ts.map

package/runtime/AuxRealtimeEditModeProvider.js

@@ -0,0 +1,34 @@
+import { RealtimeEditMode } from './RuntimeBot';
+/**
+ * The default realtime edit mode.
+ */
+export const DEFAULT_REALTIME_EDIT_MODE = RealtimeEditMode.Immediate;
+/**
+ * The default map between bot spaces and realtime edit modes.
+ */
+export const DEFAULT_SPACE_REALTIME_EDIT_MODE_MAP = new Map([
+    ['shared', RealtimeEditMode.Immediate],
+    ['local', RealtimeEditMode.Immediate],
+    ['tempLocal', RealtimeEditMode.Immediate],
+    ['history', RealtimeEditMode.Delayed],
+    ['admin', RealtimeEditMode.Delayed],
+    ['certified', RealtimeEditMode.None],
+    ['bootstrap', RealtimeEditMode.None],
+]);
+/**
+ * Gets the realtime edit mode for the given space and map.
+ * @param map The map.
+ * @param space The space.
+ */
+export function getRealtimeEditMode(map, space) {
+    return map.get(space) || DEFAULT_REALTIME_EDIT_MODE;
+}
+export class DefaultRealtimeEditModeProvider {
+    constructor(map = DEFAULT_SPACE_REALTIME_EDIT_MODE_MAP) {
+        this._map = map;
+    }
+    getEditMode(space) {
+        return getRealtimeEditMode(this._map, space);
+    }
+}
+//# sourceMappingURL=AuxRealtimeEditModeProvider.js.map

package/runtime/AuxRealtimeEditModeProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuxRealtimeEditModeProvider.js","sourceRoot":"","sources":["AuxRealtimeEditModeProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GACnC,gBAAgB,CAAC,SAAS,CAAC;AAO/B;;GAEG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAC7C,IAAI,GAAG,CAAC;IACJ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,SAAS,CAAC;IACtC,CAAC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC;IACrC,CAAC,WAAW,EAAE,gBAAgB,CAAC,SAAS,CAAC;IACzC,CAAC,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC;IACrC,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC;IACnC,CAAC,WAAW,EAAE,gBAAgB,CAAC,IAAI,CAAC;IACpC,CAAC,WAAW,EAAE,gBAAgB,CAAC,IAAI,CAAC;CACvC,CAAC,CAAC;AAEP;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAC/B,GAA6B,EAC7B,KAAa;IAEb,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,0BAA0B,CAAC;AACxD,CAAC;AAaD,MAAM,OAAO,+BAA+B;IAKxC,YACI,MAAgC,oCAAoC;QAEpE,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;IACpB,CAAC;IAED,WAAW,CAAC,KAAa;QACrB,OAAO,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;CACJ"}

package/runtime/AuxResults.d.ts

@@ -0,0 +1,77 @@
+import { Bot } from '@casual-simulation/aux-common/bots/Bot';
+import { RuntimeActions } from './RuntimeEvents';
+export declare class RanOutOfEnergyError extends Error {
+    constructor();
+}
+/**
+ * Defines the result of a script.
+ */
+export interface ScriptResult {
+    /**
+     * The actions that the script queued.
+     */
+    actions: RuntimeActions[];
+    /**
+     * The value that the script returned.
+     */
+    result: any;
+    /**
+     * The error that the script ran into.
+     */
+    error: ScriptError;
+}
+/**
+ * Defines an error that a script ran into,
+ */
+export interface ScriptError {
+    /**
+     * The error.
+     */
+    error: Error;
+    /**
+     * The bot that ran into the error.
+     * Null if the script was not attached to a bot.
+     */
+    bot: Bot;
+    /**
+     * The tag that ran into the error.
+     * Null if the script was not attached to a bot.
+     */
+    tag: string;
+    /**
+     * The line number that the error occurred at.
+     */
+    line?: number;
+    /**
+     * The column number that the error occurred at.
+     */
+    column?: number;
+    /**
+     * The script that caused the error.
+     * Only set if the script was unable to be compiled.
+     */
+    script?: string;
+}
+/**
+ * Defines the result of running an action.
+ */
+export interface ActionResult {
+    /**
+     * The actions that were queued.
+     */
+    actions: RuntimeActions[];
+    /**
+     * The results from the scripts that were run.
+     */
+    results: any[];
+    /**
+     * The errors that occurred.
+     */
+    errors: ScriptError[];
+    /**
+     * The bots that ran a script for the action.
+     */
+    listeners: Bot[];
+}
+export type ProcessActionResult = ActionResult | null;
+//# sourceMappingURL=AuxResults.d.ts.map

package/runtime/AuxResults.js

@@ -0,0 +1,6 @@
+export class RanOutOfEnergyError extends Error {
+    constructor() {
+        super('Ran out of energy');
+    }
+}
+//# sourceMappingURL=AuxResults.js.map

package/runtime/AuxResults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuxResults.js","sourceRoot":"","sources":["AuxResults.ts"],"names":[],"mappings":"AAIA,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC1C;QACI,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC/B,CAAC;CACJ"}

package/runtime/AuxRuntime.d.ts

@@ -0,0 +1,252 @@
+import { StateUpdatedEvent, Bot, BotSpace, RuntimeBot, CompiledBotListener } from '@casual-simulation/aux-common/bots';
+import { Observable, SubscriptionLike } from 'rxjs';
+import { AuxGlobalContext } from './AuxGlobalContext';
+import { AuxLibrary } from './AuxLibrary';
+import { RuntimeBotInterface, RuntimeBotFactory, RealtimeEditMode, RealtimeEditConfig, RuntimeInterpreterGeneratorProcessor } from './RuntimeBot';
+import { CompiledBot, CompiledBotsState, RuntimeBreakpoint, RuntimeStop } from './CompiledBot';
+import { ScriptError, ActionResult } from './AuxResults';
+import { AuxVersion } from './AuxVersion';
+import { AuxDevice } from './AuxDevice';
+import { RuntimePromise } from './Utils';
+import { AuxRealtimeEditModeProvider } from './AuxRealtimeEditModeProvider';
+import { CurrentVersion } from '@casual-simulation/aux-common';
+import { RuntimeStateVersion } from './RuntimeStateVersion';
+import type { Interpreter as InterpreterType, InterpreterContinuation, InterpreterStop } from '@casual-simulation/js-interpreter';
+import { RuntimeActions } from './RuntimeEvents';
+export declare function registerInterpreterModule(module: any): void;
+/**
+ * Defines an class that is able to manage the runtime state of an AUX.
+ *
+ * Being a runtime means providing and managing the execution state that an AUX is in.
+ * This means taking state updates events, shouts and whispers, and emitting additional events to affect the future state.
+ */
+export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactory, RuntimeInterpreterGeneratorProcessor, SubscriptionLike {
+    private _compiledState;
+    private _existingMasks;
+    private _compiler;
+    private _onActions;
+    private _onErrors;
+    private _onRuntimeStop;
+    private _stopState;
+    private _breakpoints;
+    private _currentStopCount;
+    private _currentPromise;
+    private _actionBatch;
+    private _errorBatch;
+    private _userId;
+    private _sub;
+    private _currentVersion;
+    private _updatedBots;
+    private _newBots;
+    private _globalContext;
+    private _library;
+    private _editModeProvider;
+    private _exemptSpaces;
+    private _batchPending;
+    private _jobQueueCheckPending;
+    private _jobQueueCheckCount;
+    private _processingErrors;
+    private _portalBots;
+    private _builtinPortalBots;
+    private _globalChanges;
+    private _globalObject;
+    private _interpretedApi;
+    private _interpretedTagSpecificApi;
+    private _beforeActionListeners;
+    private _scriptActionEnqueuedListeners;
+    private _scriptUpdatedTagListeners;
+    private _scriptUpdatedTagMaskListeners;
+    /**
+     * The counter that is used to generate function names.
+     */
+    private _functionNameCounter;
+    /**
+     * A map of function names to their respective functions.
+     */
+    private _functionMap;
+    /**
+     * A map of bot IDs to a list of function names.
+     */
+    private _botFunctionMap;
+    /**
+     * Whether changes should be automatically batched.
+     */
+    private _autoBatch;
+    private _forceSyncScripts;
+    private _currentDebugger;
+    private _libraryFactory;
+    private _interpreter;
+    /**
+     * The number of times that the runtime can call onError for an error from the same script.
+     */
+    repeatedErrorLimit: number;
+    get context(): AuxGlobalContext;
+    get currentVersion(): RuntimeStateVersion;
+    get globalObject(): any;
+    get canTriggerBreakpoint(): boolean;
+    /**
+     * Creates a new AuxRuntime using the given library factory.
+     * @param libraryFactory
+     * @param forceSignedScripts Whether to force the runtime to only allow scripts that are signed.
+     * @param exemptSpaces The spaces that are exempt from requiring signed scripts.
+     * @param interpreter The interpreter that should be used for the runtime.
+     */
+    constructor(version: AuxVersion, device: AuxDevice, libraryFactory?: (context: AuxGlobalContext) => AuxLibrary, editModeProvider?: AuxRealtimeEditModeProvider, exemptSpaces?: BotSpace[], forceSyncScripts?: boolean, interpreter?: InterpreterType);
+    getShoutTimers(): {
+        [shout: string]: number;
+    };
+    get closed(): boolean;
+    unsubscribe(): void;
+    /**
+     * Gets the current state that the runtime is operating on.
+     */
+    get currentState(): CompiledBotsState;
+    get userId(): string;
+    set userId(id: string);
+    get userBot(): RuntimeBot;
+    /**
+     * An observable that resolves whenever the runtime issues an action.
+     */
+    get onActions(): Observable<RuntimeActions[]>;
+    /**
+     * An observable that resolves whenever the runtime issues an error.
+     */
+    get onErrors(): Observable<ScriptError[]>;
+    /**
+     * An observable that resolves whenever the runtime pauses in a script.
+     */
+    get onRuntimeStop(): Observable<RuntimeStop>;
+    /**
+     * Processes the given bot actions and dispatches the resulting actions in the future.
+     * @param actions The actions to process.
+     */
+    process(actions: RuntimeActions[]): MaybeRuntimePromise<ActionResult[]>;
+    private _getExecutingDebugger;
+    private _createDebugger;
+    private _mapCallStack;
+    private _processCore;
+    private _processAction;
+    private _registerPortalBot;
+    private _rejectAction;
+    /**
+     * Executes the given function based on the current execution state of the runtime.
+     * If the runtime is stopped, then the given function will be executed after the current promise finishes.
+     * If the runtime is executing normally, then the given function will be executed immediately.
+     * Returns the function result if the function executes immediately,
+     * or returns a runtime promise if the function executes after the current promise.
+     *
+     * This function essentially forces the given function to execute synchronously with respect to other functions wrapped with this function.
+     *
+     * @param func The function to execute.
+     *
+     */
+    private _wrapWithCurrentPromise;
+    /**
+     * Executes a shout with the given event name on the given bot IDs with the given argument.
+     * Also dispatches any actions and errors that occur.
+     * @param eventName The name of the event.
+     * @param botIds The Bot IDs that the shout is being sent to.
+     * @param arg The argument to include in the shout.
+     */
+    shout(eventName: string, botIds?: string[], arg?: any): MaybeRuntimePromise<ActionResult>;
+    /**
+     * Executes the given shout synchronously with respect to other scripts that may be running or paused.
+     * @param eventName The name of the event that should be executed.
+     * @param botIds The IDs of the bots that the shout should be sent to.
+     * @param arg The argument that should be sent with the shout.
+     * @param batch Whether to batch events.
+     * @param resetEnergy Whether to reset the runtime energy before executing the shout.
+     */
+    private _synchronousShout;
+    private _shout;
+    /**
+     * Executes the given script.
+     * @param script The script to run.
+     */
+    execute(script: string): MaybeRuntimePromise<{
+        result: any;
+        actions: RuntimeActions[];
+        errors: ScriptError[];
+    }>;
+    private _execute;
+    /**
+     * Signals to the runtime that the bots state has been updated.
+     * @param update The bot state update.
+     */
+    stateUpdated(update: StateUpdatedEvent): StateUpdatedEvent;
+    /**
+     * Signals to the runtime that the state version has been updated.
+     * @param newVersion The version update.
+     */
+    versionUpdated(newVersion: CurrentVersion): RuntimeStateVersion;
+    private _sendOnBotsAddedShouts;
+    private _sendOnBotsRemovedShouts;
+    private _sendOnBotsChangedShouts;
+    private _triggerPortalChangedHandlers;
+    private _addBotsToState;
+    private _removeBotsFromState;
+    private _updateBotsWithState;
+    notifyChange(): void;
+    notifyActionEnqueued(action: RuntimeActions): void;
+    createRuntimeBot(bot: Bot): RuntimeBot;
+    destroyScriptBot(bot: RuntimeBot): RealtimeEditMode;
+    private _processBatch;
+    private _processErrors;
+    private _batchScriptResults;
+    private _calculateScriptResults;
+    private _processUnbatchedErrors;
+    private _processUnbatchedActions;
+    private _compileTags;
+    private _createCompiledBot;
+    private _createRuntimeBot;
+    updateTag(bot: CompiledBot, tag: string, newValue: any): RealtimeEditConfig;
+    getValue(bot: CompiledBot, tag: string): any;
+    getRawValue(bot: CompiledBot, tag: string): any;
+    updateTagMask(bot: CompiledBot, tag: string, spaces: string[], value: any): RealtimeEditConfig;
+    getTagMask(bot: CompiledBot, tag: string): any;
+    getListener(bot: CompiledBot, tag: string): CompiledBotListener;
+    getTagLink(bot: CompiledBot, tag: string): RuntimeBot | RuntimeBot[];
+    getSignature(bot: CompiledBot, signature: string): string;
+    private _compileTagOrMask;
+    private _compileTag;
+    private _compileTagValue;
+    private _compileValue;
+    private _compileTagMaskValue;
+    private _compile;
+    private _handleError;
+    private _getRuntimeBot;
+    /**
+     * Maps the given value to a new value where bots are replaced with script bots.
+     * This makes it easy to modify other bot values in listeners. If the value is not convertable,
+     * then it is returned unaffected. Only objects and arrays are convertable.
+     *
+     * Works by making a copy of the value where every bot value is replaced with a reference
+     * to a script bot instance for the bot. The copy has a reference to the original value in the ORIGINAL_OBJECT symbol property.
+     * We use this property in action.reject() to resolve the original action value so that doing a action.reject() in a onAnyAction works properly.
+     *
+     * @param context The sandbox context.
+     * @param value The value that should be converted.
+     */
+    private _mapBotsToRuntimeBots;
+    private _mapBotsToRuntimeBotsCore;
+    private _getFunctionNamesForBot;
+    setBreakpoint(breakpoint: RuntimeBreakpoint): void;
+    removeBreakpoint(breakpointId: string): void;
+    continueAfterStop(stopId: RuntimeStop['stopId'], continuation?: InterpreterContinuation): void;
+    private _scheduleJob;
+    private _scheduleJobQueueCheck;
+    private _processJobQueueNow;
+    processGenerator<T>(generator: Generator<InterpreterStop, T, InterpreterContinuation>): void;
+    private _processGenerator;
+    private _executeGenerator;
+}
+type MaybeRuntimePromise<T> = T | RuntimePromise<T>;
+/**
+ * Recursively maps each of the given library's functions using the given map function and returns a new library that contains the converted functions.
+ * The returned object will contain the same enumerable properties as the original library except that its functions have been mapped.
+ * @param library The library to map.
+ * @param map The function to use for mapping library functions.
+ */
+export declare function mapLibraryFunctions<T extends AuxLibrary>(library: T, map: (func: Function, key: string) => any): T;
+export {};
+//# sourceMappingURL=AuxRuntime.d.ts.map