@casual-simulation/aux-common 3.2.6 → 3.2.7-alpha.6227012901

package/runtime/AuxRuntime.js

@@ -1,2700 +0,0 @@
-// CasualOS has several key components:
-//
-// 1. Simulations - These are wrapper objects that manage creating and interfacing with AUX virtual machines.
-// 2. VM - AUX Virtual Machines provide a security boundary to keep user scripts separate across multiple virtual machines.
-// 3. Channel - These are manager objects which handle the persistence and runtime aspects of an AUX.
-// 4. Partitions - These are services which manage the persistence and realtime sync of the AUX data model.
-// 5. Runtimes - These are services which manage script execution and formula precalculation.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { hasValue, tagsOnBot, isFormula, isScript, isNumber, BOT_SPACE_TAG, botUpdated, isBot, ORIGINAL_OBJECT, DEFAULT_ENERGY, getBotSpace, ON_ACTION_ACTION_NAME, breakIntoIndividualEvents, ON_BOT_ADDED_ACTION_NAME, ON_ANY_BOTS_ADDED_ACTION_NAME, ON_ANY_BOTS_REMOVED_ACTION_NAME, ON_BOT_CHANGED_ACTION_NAME, ON_ANY_BOTS_CHANGED_ACTION_NAME, updatedBot, TAG_MASK_SPACE_PRIORITIES, CLEAR_CHANGES_SYMBOL, DNA_TAG_PREFIX, isRuntimeBot, createBot, ON_ERROR, action, isBotInDimension, asyncResult, registerBuiltinPortal, defineGlobalBot, isBotLink, parseBotLink, isBotDate, parseBotDate, formatBotDate, isTaggedString, parseTaggedString, parseNumber, isTaggedNumber, isBotVector, parseBotVector, formatBotVector, isBotRotation, parseBotRotation, formatBotRotation, parseTaggedNumber, REPLACE_BOT_SYMBOL, } from '../bots';
-import { Subject, Subscription } from 'rxjs';
-import { AuxCompiler, getInterpretableFunction, isInterpretableFunction, } from './AuxCompiler';
-import { addToContext, MemoryGlobalContext, removeFromContext, isInContext, } from './AuxGlobalContext';
-import { createDefaultLibrary, GET_RUNTIME, } from './AuxLibrary';
-import { createRuntimeBot, RealtimeEditMode, } from './RuntimeBot';
-import { RanOutOfEnergyError, } from './AuxResults';
-import { convertToCopiableValue, DeepObjectError, isPromise, isRuntimePromise, markAsRuntimePromise, } from './Utils';
-import { DefaultRealtimeEditModeProvider, } from './AuxRealtimeEditModeProvider';
-import { sortBy, forOwn, merge, union } from 'lodash';
-import { tagValueHash } from '../aux-format-2/AuxOpTypes';
-import { applyTagEdit, isTagEdit } from '../aux-format-2';
-import { updateRuntimeVersion, } from './RuntimeStateVersion';
-import { replaceMacros } from './Transpiler';
-import { DateTime } from 'luxon';
-import { Rotation, Vector2, Vector3 } from '../math';
-import { isGenerator, UNCOPIABLE, } from '@casual-simulation/js-interpreter/InterpreterUtils';
-import { v4 as uuid } from 'uuid';
-import { importInterpreter as _dynamicImportInterpreter } from './AuxRuntimeDynamicImports';
-import { UNMAPPABLE, } from '../bots/BotEvents';
-let Interpreter;
-let DeclarativeEnvironmentRecord;
-let DefinePropertyOrThrow;
-let Descriptor;
-let Value;
-let hasModule = false;
-let interpreterImportPromise;
-export function registerInterpreterModule(module) {
-    hasModule = true;
-    Interpreter = module.Interpreter;
-    DeclarativeEnvironmentRecord = module.DeclarativeEnvironmentRecord;
-    DefinePropertyOrThrow = module.DefinePropertyOrThrow;
-    Descriptor = module.Descriptor;
-    Value = module.Value;
-}
-function importInterpreter() {
-    if (hasModule) {
-        return Promise.resolve();
-    }
-    if (interpreterImportPromise) {
-        return interpreterImportPromise;
-    }
-    else {
-        return (interpreterImportPromise = _importInterpreterCore());
-    }
-}
-function _importInterpreterCore() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const module = yield _dynamicImportInterpreter();
-        registerInterpreterModule(module);
-    });
-}
-/**
- * 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 class AuxRuntime {
-    get forceSignedScripts() {
-        return this._forceSignedScripts;
-    }
-    get context() {
-        return this._globalContext;
-    }
-    get currentVersion() {
-        return this._currentVersion;
-    }
-    get globalObject() {
-        return this._globalObject;
-    }
-    get canTriggerBreakpoint() {
-        return !!this._interpreter && this._interpreter.debugging;
-    }
-    /**
-     * 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, device, libraryFactory = createDefaultLibrary, editModeProvider = new DefaultRealtimeEditModeProvider(), forceSignedScripts = false, exemptSpaces = ['local', 'tempLocal'], forceSyncScripts = false, interpreter = null) {
-        this._compiledState = {};
-        this._existingMasks = {};
-        this._compiler = new AuxCompiler();
-        this._stopState = null;
-        this._breakpoints = new Map();
-        this._currentStopCount = 0;
-        this._currentPromise = null;
-        this._actionBatch = [];
-        this._errorBatch = [];
-        this._currentVersion = {
-            localSites: {},
-            vector: {},
-        };
-        this._updatedBots = new Map();
-        this._newBots = new Map();
-        this._batchPending = false;
-        this._jobQueueCheckPending = false;
-        this._jobQueueCheckCount = 0;
-        this._processingErrors = false;
-        this._portalBots = new Map();
-        this._builtinPortalBots = [];
-        this._globalChanges = {};
-        this._beforeActionListeners = [];
-        this._scriptActionEnqueuedListeners = [];
-        this._scriptUpdatedTagListeners = [];
-        this._scriptUpdatedTagMaskListeners = [];
-        // private _beforeScriptEnterListeners: ((
-        //     trace: DebuggerScriptEnterTrace
-        // ) => void)[] = [];
-        // private _afterScriptExitListeners: ((
-        //     trace: DebuggerScriptExitTrace
-        // ) => void)[] = [];
-        /**
-         * The counter that is used to generate function names.
-         */
-        this._functionNameCounter = 0;
-        /**
-         * A map of function names to their respective functions.
-         */
-        this._functionMap = new Map();
-        /**
-         * A map of bot IDs to a list of function names.
-         */
-        this._botFunctionMap = new Map();
-        /**
-         * Whether changes should be automatically batched.
-         */
-        this._autoBatch = true;
-        this._forceSyncScripts = false;
-        this._currentDebugger = null;
-        /**
-         * The number of times that the runtime can call onError for an error from the same script.
-         */
-        this.repeatedErrorLimit = 1000;
-        this._libraryFactory = libraryFactory;
-        this._interpreter = interpreter;
-        this._globalContext = new MemoryGlobalContext(version, device, this, this, this);
-        this._forceSyncScripts = forceSyncScripts;
-        this._globalContext.mockAsyncActions = forceSyncScripts;
-        this._library = merge(libraryFactory(this._globalContext), {
-            api: {
-                os: {
-                    createDebugger: this._createDebugger.bind(this),
-                    getExecutingDebugger: this._getExecutingDebugger.bind(this),
-                },
-            },
-        });
-        this._editModeProvider = editModeProvider;
-        this._forceSignedScripts = forceSignedScripts;
-        this._exemptSpaces = exemptSpaces;
-        this._onActions = new Subject();
-        this._onErrors = new Subject();
-        this._onRuntimeStop = new Subject();
-        let sub = (this._sub = new Subscription(() => {
-            this._globalContext.cancelAllBotTimers();
-        }));
-        sub.add(this._globalContext.startAnimationLoop());
-        if (globalThis.addEventListener) {
-            const unhandledRejectionListener = (event) => {
-                const data = this._handleError(event.reason, null, null);
-                this._globalContext.enqueueError(data);
-                event.preventDefault();
-            };
-            globalThis.addEventListener('unhandledrejection', unhandledRejectionListener);
-            sub.add(() => {
-                globalThis.removeEventListener('unhandledrejection', unhandledRejectionListener);
-            });
-        }
-        this._globalObject = new Proxy(globalThis, {
-            get: (target, key, receiver) => {
-                if (key in this._globalChanges) {
-                    return Reflect.get(this._globalChanges, key);
-                }
-                else if (key in target) {
-                    return Reflect.get(target, key);
-                }
-                return Reflect.get(target, key, receiver);
-            },
-            set: (target, key, value, receiver) => {
-                return Reflect.set(this._globalChanges, key, value);
-            },
-            deleteProperty: (target, key) => {
-                return Reflect.deleteProperty(this._globalChanges, key);
-            },
-            defineProperty: (target, key, options) => {
-                return Reflect.defineProperty(this._globalChanges, key, options);
-            },
-            ownKeys: (target) => {
-                const addedKeys = Reflect.ownKeys(this._globalChanges);
-                const otherKeys = Reflect.ownKeys(target);
-                return union(addedKeys, otherKeys);
-            },
-            has: (target, key) => {
-                return (Reflect.has(this._globalChanges, key) ||
-                    Reflect.has(target, key));
-            },
-            getOwnPropertyDescriptor: (target, key) => {
-                if (key in this._globalChanges) {
-                    return Reflect.getOwnPropertyDescriptor(this._globalChanges, key);
-                }
-                return Reflect.getOwnPropertyDescriptor(target, key);
-            },
-        });
-        this._globalContext.global = this._globalObject;
-        if (this._interpreter) {
-            // Use the interpreted versions of APIs
-            this._interpretedApi = Object.assign({}, this._library.api);
-            this._interpretedTagSpecificApi = Object.assign({}, this._library.tagSpecificApi);
-            for (let key in this._interpretedApi) {
-                const val = this._interpretedApi[key];
-                if (isInterpretableFunction(val)) {
-                    this._interpretedApi[key] = getInterpretableFunction(val);
-                }
-            }
-            for (let key in this._interpretedTagSpecificApi) {
-                const val = this._interpretedTagSpecificApi[key];
-                if (isInterpretableFunction(val)) {
-                    this._interpretedTagSpecificApi[key] =
-                        getInterpretableFunction(val);
-                }
-            }
-        }
-    }
-    getShoutTimers() {
-        return {};
-    }
-    get closed() {
-        return this._sub.closed;
-    }
-    unsubscribe() {
-        return this._sub.unsubscribe();
-    }
-    /**
-     * Gets the current state that the runtime is operating on.
-     */
-    get currentState() {
-        return this._compiledState;
-    }
-    get userId() {
-        return this._userId;
-    }
-    set userId(id) {
-        this._userId = id;
-        this._globalContext.playerBot = this.userBot;
-    }
-    get userBot() {
-        if (!this._userId) {
-            return;
-        }
-        const bot = this._compiledState[this._userId];
-        if (bot) {
-            return bot.script;
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * An observable that resolves whenever the runtime issues an action.
-     */
-    get onActions() {
-        return this._onActions;
-    }
-    /**
-     * An observable that resolves whenever the runtime issues an error.
-     */
-    get onErrors() {
-        return this._onErrors;
-    }
-    /**
-     * An observable that resolves whenever the runtime pauses in a script.
-     */
-    get onRuntimeStop() {
-        return this._onRuntimeStop;
-    }
-    /**
-     * Processes the given bot actions and dispatches the resulting actions in the future.
-     * @param actions The actions to process.
-     */
-    process(actions) {
-        if (this._beforeActionListeners.length > 0) {
-            for (let func of this._beforeActionListeners) {
-                for (let action of actions) {
-                    try {
-                        func(action);
-                    }
-                    catch (err) {
-                        console.error(err);
-                    }
-                }
-            }
-        }
-        this._processBatch();
-        const result = this._processCore(actions);
-        this._processBatch();
-        return result;
-    }
-    _getExecutingDebugger() {
-        return this._currentDebugger;
-    }
-    _createDebugger(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const forceSyncScripts = typeof (options === null || options === void 0 ? void 0 : options.allowAsynchronousScripts) === 'boolean'
-                ? !options.allowAsynchronousScripts
-                : false;
-            yield importInterpreter();
-            const interpreter = (options === null || options === void 0 ? void 0 : options.pausable) ? new Interpreter() : null;
-            const runtime = new AuxRuntime(this._globalContext.version, this._globalContext.device, this._libraryFactory, this._editModeProvider, this._forceSignedScripts, this._exemptSpaces, forceSyncScripts, interpreter);
-            runtime._autoBatch = true;
-            let idCount = 0;
-            if (!(options === null || options === void 0 ? void 0 : options.useRealUUIDs)) {
-                runtime._globalContext.uuid = () => {
-                    idCount += 1;
-                    return `uuid-${idCount}`;
-                };
-            }
-            let allActions = [];
-            let allErrors = [];
-            let create;
-            if (interpreter &&
-                isInterpretableFunction(runtime._library.tagSpecificApi.create)) {
-                const func = getInterpretableFunction(runtime._library.tagSpecificApi.create)({
-                    bot: null,
-                    config: null,
-                    creator: null,
-                    tag: null,
-                });
-                create = (...args) => {
-                    const result = func(...args);
-                    if (isGenerator(result)) {
-                        return runtime._processGenerator(result);
-                    }
-                    return result;
-                };
-            }
-            else {
-                create = runtime._library.tagSpecificApi.create({
-                    bot: null,
-                    config: null,
-                    creator: null,
-                    tag: null,
-                });
-            }
-            const isCommonAction = (action) => {
-                return !(action.type === 'add_bot' ||
-                    action.type === 'remove_bot' ||
-                    action.type === 'update_bot' ||
-                    action.type === 'apply_state');
-            };
-            const getAllActions = () => {
-                const actions = runtime._processUnbatchedActions();
-                allActions.push(...actions);
-                return allActions;
-            };
-            // The config bot is always ID 0 in debuggers
-            const configBotId = (options === null || options === void 0 ? void 0 : options.useRealUUIDs)
-                ? runtime.context.uuid()
-                : 'uuid-0';
-            const configBotTags = (options === null || options === void 0 ? void 0 : options.configBot)
-                ? isBot(options === null || options === void 0 ? void 0 : options.configBot)
-                    ? options.configBot.tags
-                    : options.configBot
-                : {};
-            runtime.context.createBot(createBot(configBotId, configBotTags, 'tempLocal'));
-            runtime.process(this._builtinPortalBots.map((b) => registerBuiltinPortal(b)));
-            runtime.userId = configBotId;
-            const api = Object.assign({}, runtime._library.api);
-            if (interpreter) {
-                for (let key in runtime._library.api) {
-                    const val = runtime._library.api[key];
-                    if (isInterpretableFunction(val)) {
-                        const func = getInterpretableFunction(val);
-                        api[key] = (...args) => {
-                            const result = func(...args);
-                            if (isGenerator(result)) {
-                                return runtime._processGenerator(result);
-                            }
-                            return result;
-                        };
-                    }
-                }
-            }
-            if (interpreter && (options === null || options === void 0 ? void 0 : options.pausable)) {
-                interpreter.debugging = true;
-            }
-            const debug = Object.assign(Object.assign({ [UNCOPIABLE]: true }, api), { getAllActions, getCommonActions: () => {
-                    return getAllActions().filter(isCommonAction);
-                }, getBotActions: () => {
-                    return getAllActions().filter((a) => !isCommonAction(a));
-                }, getErrors: () => {
-                    const errors = runtime._processUnbatchedErrors();
-                    allErrors.push(...errors);
-                    return allErrors;
-                }, onBeforeUserAction: (listener) => {
-                    runtime._beforeActionListeners.push(listener);
-                }, onScriptActionEnqueued: (listener) => {
-                    runtime._scriptActionEnqueuedListeners.push(listener);
-                }, onAfterScriptUpdatedTag: (listener) => {
-                    runtime._scriptUpdatedTagListeners.push(listener);
-                }, onAfterScriptUpdatedTagMask: (listener) => {
-                    runtime._scriptUpdatedTagMaskListeners.push(listener);
-                }, getCallStack() {
-                    if (!interpreter) {
-                        throw new Error('getCallStack() is only supported on pausable debuggers.');
-                    }
-                    return runtime._mapCallStack(interpreter.agent.executionContextStack);
-                },
-                performUserAction(...actions) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const result = yield runtime.process(actions);
-                        return result.map((r) => (r ? r.results : null));
-                    });
-                },
-                // TODO: Determine whether to support this
-                // onBeforeScriptEnter: (
-                //     listener: (trace: DebuggerScriptEnterTrace) => void
-                // ) => {
-                //     runtime._beforeScriptEnterListeners.push(listener);
-                // },
-                // onAfterScriptExit: (
-                //     listener: (trace: DebuggerScriptExitTrace) => void
-                // ) => {
-                //     runtime._afterScriptExitListeners.push(listener);
-                // },
-                setPauseTrigger(b, tag, options) {
-                    var _a, _b, _c;
-                    if (typeof b === 'object' && 'triggerId' in b) {
-                        runtime.setBreakpoint({
-                            id: b.triggerId,
-                            botId: b.botId,
-                            tag: b.tag,
-                            lineNumber: b.lineNumber,
-                            columnNumber: b.columnNumber,
-                            states: (_a = b.states) !== null && _a !== void 0 ? _a : ['before'],
-                            disabled: !((_b = b.enabled) !== null && _b !== void 0 ? _b : true),
-                        });
-                        return b;
-                    }
-                    else {
-                        const id = isBot(b) ? b.id : b;
-                        const trigger = Object.assign({ triggerId: uuid(), botId: id, tag: tag }, options);
-                        runtime.setBreakpoint({
-                            id: trigger.triggerId,
-                            botId: id,
-                            tag: tag,
-                            lineNumber: trigger.lineNumber,
-                            columnNumber: trigger.columnNumber,
-                            states: (_c = trigger.states) !== null && _c !== void 0 ? _c : ['before'],
-                            disabled: false,
-                        });
-                        return trigger;
-                    }
-                },
-                removePauseTrigger(triggerOrId) {
-                    let id = typeof triggerOrId === 'string'
-                        ? triggerOrId
-                        : triggerOrId.triggerId;
-                    runtime.removeBreakpoint(id);
-                },
-                disablePauseTrigger(triggerOrId) {
-                    var _a;
-                    if (typeof triggerOrId === 'string') {
-                        let trigger = runtime._breakpoints.get(triggerOrId);
-                        if (trigger) {
-                            trigger.disabled = true;
-                        }
-                    }
-                    else {
-                        runtime.setBreakpoint({
-                            id: triggerOrId.triggerId,
-                            botId: triggerOrId.botId,
-                            tag: triggerOrId.tag,
-                            lineNumber: triggerOrId.lineNumber,
-                            columnNumber: triggerOrId.columnNumber,
-                            states: (_a = triggerOrId.states) !== null && _a !== void 0 ? _a : ['before'],
-                            disabled: true,
-                        });
-                    }
-                },
-                enablePauseTrigger(triggerOrId) {
-                    var _a;
-                    if (typeof triggerOrId === 'string') {
-                        let trigger = runtime._breakpoints.get(triggerOrId);
-                        if (trigger) {
-                            trigger.disabled = false;
-                        }
-                    }
-                    else {
-                        runtime.setBreakpoint({
-                            id: triggerOrId.triggerId,
-                            botId: triggerOrId.botId,
-                            tag: triggerOrId.tag,
-                            lineNumber: triggerOrId.lineNumber,
-                            columnNumber: triggerOrId.columnNumber,
-                            states: (_a = triggerOrId.states) !== null && _a !== void 0 ? _a : ['before'],
-                            disabled: false,
-                        });
-                    }
-                },
-                listPauseTriggers() {
-                    let triggers = [];
-                    for (let breakpoint of runtime._breakpoints.values()) {
-                        triggers.push({
-                            triggerId: breakpoint.id,
-                            botId: breakpoint.botId,
-                            tag: breakpoint.tag,
-                            columnNumber: breakpoint.columnNumber,
-                            lineNumber: breakpoint.lineNumber,
-                            states: breakpoint.states.slice(),
-                            enabled: !breakpoint.disabled,
-                        });
-                    }
-                    return triggers;
-                },
-                listCommonPauseTriggers(botOrId, tag) {
-                    const id = typeof botOrId === 'string' ? botOrId : botOrId.id;
-                    const bot = runtime.currentState[id];
-                    const func = bot.listeners[tag];
-                    if (!func) {
-                        return [];
-                    }
-                    return runtime._compiler.listPossibleBreakpoints(func, runtime._interpreter);
-                },
-                onPause(callback) {
-                    runtime.onRuntimeStop.subscribe((stop) => {
-                        const pause = {
-                            pauseId: stop.stopId,
-                            state: stop.state,
-                            callStack: runtime._mapCallStack(stop.stack),
-                            trigger: {
-                                triggerId: stop.breakpoint.id,
-                                botId: stop.breakpoint.botId,
-                                tag: stop.breakpoint.tag,
-                                lineNumber: stop.breakpoint.lineNumber,
-                                columnNumber: stop.breakpoint.columnNumber,
-                                states: stop.breakpoint.states,
-                            },
-                        };
-                        callback(pause);
-                    });
-                },
-                resume(pause) {
-                    runtime.continueAfterStop(pause.pauseId);
-                },
-                [GET_RUNTIME]() {
-                    return runtime;
-                },
-                get configBot() {
-                    return runtime.userBot;
-                },
-                getPortalBots() {
-                    var _a;
-                    let portalBots = new Map();
-                    for (let [portal, id] of runtime._portalBots) {
-                        portalBots.set(portal, (_a = runtime.currentState[id]) === null || _a === void 0 ? void 0 : _a.script);
-                    }
-                    return portalBots;
-                },
-                create });
-            runtime._currentDebugger = debug;
-            this._scheduleJobQueueCheck();
-            return debug;
-        });
-    }
-    _mapCallStack(stack) {
-        const interpreter = this._interpreter;
-        return stack.map((s) => {
-            const callSite = s.callSite;
-            const funcName = callSite.getFunctionName();
-            let funcLocation = {};
-            if (funcName) {
-                const f = this._functionMap.get(funcName);
-                if (f) {
-                    funcLocation.name = f.metadata.diagnosticFunctionName;
-                    const location = this._compiler.calculateOriginalLineLocation(f, {
-                        lineNumber: callSite.lineNumber,
-                        column: callSite.columnNumber,
-                    });
-                    funcLocation.lineNumber = location.lineNumber + 1;
-                    funcLocation.columnNumber = location.column + 1;
-                    const tagName = f.metadata.context.tag;
-                    const bot = f.metadata.context.bot;
-                    if (bot) {
-                        funcLocation.botId = bot.id;
-                    }
-                    if (tagName) {
-                        funcLocation.tag = tagName;
-                    }
-                }
-                else {
-                    funcLocation.name = funcName;
-                }
-            }
-            if (!hasValue(funcLocation.lineNumber) &&
-                !hasValue(funcLocation.columnNumber) &&
-                hasValue(callSite.lineNumber) &&
-                hasValue(callSite.columnNumber)) {
-                funcLocation.lineNumber = callSite.lineNumber;
-                funcLocation.columnNumber = callSite.columnNumber;
-            }
-            if (!hasValue(funcLocation.lineNumber) &&
-                !hasValue(funcLocation.columnNumber) &&
-                !hasValue(funcLocation.name)) {
-                funcLocation = null;
-            }
-            const ret = {
-                location: funcLocation,
-                listVariables() {
-                    let variables = [];
-                    if (s.LexicalEnvironment instanceof
-                        DeclarativeEnvironmentRecord) {
-                        addBindingsFromEnvironment(s.LexicalEnvironment, 'block');
-                    }
-                    if (s.VariableEnvironment instanceof
-                        DeclarativeEnvironmentRecord) {
-                        addBindingsFromEnvironment(s.VariableEnvironment, 'frame');
-                        let parent = s.VariableEnvironment.OuterEnv;
-                        while (parent) {
-                            if (parent instanceof DeclarativeEnvironmentRecord) {
-                                addBindingsFromEnvironment(parent, 'closure');
-                            }
-                            parent = parent.OuterEnv;
-                        }
-                    }
-                    return variables;
-                    function addBindingsFromEnvironment(env, scope) {
-                        for (let [nameValue, binding,] of env.bindings.entries()) {
-                            const name = interpreter.copyFromValue(nameValue);
-                            const initialized = !!binding.initialized;
-                            const mutable = !!binding.mutable;
-                            const value = initialized
-                                ? interpreter.reverseProxyObject(binding.value, false)
-                                : undefined;
-                            const variable = {
-                                name,
-                                value,
-                                writable: mutable,
-                                scope,
-                            };
-                            if (!initialized) {
-                                variable.initialized = false;
-                            }
-                            variables.push(variable);
-                        }
-                    }
-                },
-                setVariableValue(name, value) {
-                    if (s.LexicalEnvironment instanceof
-                        DeclarativeEnvironmentRecord) {
-                        const nameValue = interpreter.copyToValue(name);
-                        const proxiedValue = interpreter.proxyObject(value);
-                        if (nameValue.Type !== 'normal') {
-                            throw interpreter.copyFromValue(nameValue.Value);
-                        }
-                        if (proxiedValue.Type !== 'normal') {
-                            throw interpreter.copyFromValue(proxiedValue.Value);
-                        }
-                        const result = s.LexicalEnvironment.SetMutableBinding(nameValue.Value, proxiedValue.Value, Value.true);
-                        if (result.Type !== 'normal') {
-                            throw interpreter.copyFromValue(result.Value);
-                        }
-                        return interpreter.copyFromValue(result.Value);
-                    }
-                },
-            };
-            return ret;
-        });
-    }
-    _processCore(actions) {
-        const _this = this;
-        const results = [];
-        function processAction(action, addToResults) {
-            let promise = _this._processAction(action);
-            if (addToResults) {
-                if (isRuntimePromise(promise)) {
-                    return markAsRuntimePromise(promise.then((result) => {
-                        results.push(result);
-                    }));
-                }
-                else {
-                    results.push(promise);
-                }
-                return;
-            }
-            return promise;
-        }
-        function handleRejection(action, rejection) {
-            let promise = processListOfMaybePromises(null, rejection.newActions, (action) => {
-                return processAction(action, false);
-            });
-            if (rejection.rejected) {
-                return;
-            }
-            if (promise) {
-                return markAsRuntimePromise(promise.then((p) => processAction(action, true)));
-            }
-            else {
-                return processAction(action, true);
-            }
-        }
-        let promise = processListOfMaybePromises(null, actions, (action) => {
-            let rejection = this._rejectAction(action);
-            let result;
-            if (isRuntimePromise(rejection)) {
-                result = markAsRuntimePromise(rejection.then((result) => handleRejection(action, result)));
-            }
-            else {
-                result = handleRejection(action, rejection);
-            }
-            return result;
-        });
-        if (isRuntimePromise(promise)) {
-            return markAsRuntimePromise(promise.then(() => results));
-        }
-        else {
-            return results;
-        }
-    }
-    _processAction(action) {
-        if (action.type === 'action') {
-            const result = this._shout(action.eventName, action.botIds, action.argument, false);
-            if (isRuntimePromise(result)) {
-                return markAsRuntimePromise(result
-                    .then((result) => this._processCore(result.actions))
-                    .then(() => result));
-            }
-            else {
-                let promise = this._processCore(result.actions);
-                if (isRuntimePromise(promise)) {
-                    return markAsRuntimePromise(promise.then(() => result));
-                }
-                else {
-                    return result;
-                }
-            }
-        }
-        else if (action.type === 'run_script') {
-            const result = this._execute(action.script, false, false);
-            if (isRuntimePromise(result)) {
-                return markAsRuntimePromise(result.then((result) => {
-                    const p = this._processCore(result.actions);
-                    if (isPromise(p)) {
-                        return p.then(() => {
-                            if (hasValue(action.taskId)) {
-                                this._globalContext.resolveTask(action.taskId, result.result, false);
-                            }
-                            return null;
-                        });
-                    }
-                    else {
-                        if (hasValue(action.taskId)) {
-                            if (this._globalContext.resolveTask(action.taskId, result.result, false)) {
-                                this._scheduleJobQueueCheck();
-                            }
-                        }
-                    }
-                    return null;
-                }));
-            }
-            else {
-                const p = this._processCore(result.actions);
-                if (isRuntimePromise(p)) {
-                    return markAsRuntimePromise(p.then(() => {
-                        if (hasValue(action.taskId)) {
-                            if (this._globalContext.resolveTask(action.taskId, result.result, false)) {
-                                this._scheduleJobQueueCheck();
-                            }
-                        }
-                        return null;
-                    }));
-                }
-                if (hasValue(action.taskId)) {
-                    if (this._globalContext.resolveTask(action.taskId, result.result, false)) {
-                        this._scheduleJobQueueCheck();
-                    }
-                }
-            }
-        }
-        else if (action.type === 'apply_state') {
-            const events = breakIntoIndividualEvents(this.currentState, action);
-            const promise = this._processCore(events);
-            if (isRuntimePromise(promise)) {
-                return markAsRuntimePromise(promise.then(() => null));
-            }
-            else {
-                return null;
-            }
-        }
-        else if (action.type === 'async_result') {
-            const value = action.mapBotsInResult === true
-                ? this._mapBotsToRuntimeBots(action.result)
-                : action.result;
-            if (!this._globalContext.resolveTask(action.taskId, value, false)) {
-                this._actionBatch.push(action);
-            }
-            else {
-                this._scheduleJobQueueCheck();
-            }
-        }
-        else if (action.type === 'async_error') {
-            if (!this._globalContext.rejectTask(action.taskId, action.error, false)) {
-                this._actionBatch.push(action);
-            }
-            else {
-                this._scheduleJobQueueCheck();
-            }
-        }
-        else if (action.type === 'device_result') {
-            if (!this._globalContext.resolveTask(action.taskId, action.result, true)) {
-                this._actionBatch.push(action);
-            }
-            else {
-                this._scheduleJobQueueCheck();
-            }
-        }
-        else if (action.type === 'device_error') {
-            if (!this._globalContext.rejectTask(action.taskId, action.error, true)) {
-                this._actionBatch.push(action);
-            }
-            else {
-                this._scheduleJobQueueCheck();
-            }
-        }
-        else if (action.type === 'register_custom_app') {
-            this._registerPortalBot(action.appId, action.botId);
-            this._actionBatch.push(action);
-        }
-        else if (action.type === 'register_builtin_portal') {
-            if (!this._portalBots.has(action.portalId)) {
-                const newBot = this.context.createBot(createBot(this.context.uuid(), undefined, 'tempLocal'));
-                this._builtinPortalBots.push(action.portalId);
-                this._registerPortalBot(action.portalId, newBot.id);
-                this._actionBatch.push(defineGlobalBot(action.portalId, newBot.id));
-            }
-            else {
-                const botId = this._portalBots.get(action.portalId);
-                this._actionBatch.push(defineGlobalBot(action.portalId, botId));
-            }
-        }
-        else if (action.type === 'define_global_bot') {
-            if (this._portalBots.get(action.name) !== action.botId) {
-                this._registerPortalBot(action.name, action.botId);
-                this._actionBatch.push(action);
-            }
-            if (hasValue(action.taskId)) {
-                const promise = this._processCore([
-                    asyncResult(action.taskId, null),
-                ]);
-                if (isRuntimePromise(promise)) {
-                    return markAsRuntimePromise(promise.then(() => null));
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-        else {
-            this._actionBatch.push(action);
-        }
-        return null;
-    }
-    _registerPortalBot(portalId, botId) {
-        const hadPortalBot = this._portalBots.has(portalId);
-        this._portalBots.set(portalId, botId);
-        if (!hadPortalBot) {
-            const variableName = `${portalId}Bot`;
-            const getValue = () => {
-                const botId = this._portalBots.get(portalId);
-                if (hasValue(botId)) {
-                    return this.context.state[botId];
-                }
-                else {
-                    return undefined;
-                }
-            };
-            Object.defineProperty(this._globalObject, variableName, {
-                get: getValue,
-                enumerable: false,
-                configurable: true,
-            });
-            if (this._interpreter) {
-                const proxiedGetResult = this._interpreter.proxyObject(getValue);
-                if (proxiedGetResult.Type !== 'normal') {
-                    throw this._interpreter.copyFromValue(proxiedGetResult.Value);
-                }
-                DefinePropertyOrThrow(this._interpreter.realm.GlobalObject, new Value(variableName), new Descriptor({
-                    Get: proxiedGetResult.Value,
-                    Configurable: Value.true,
-                }));
-            }
-        }
-    }
-    _rejectAction(action) {
-        const result = this._shout(ON_ACTION_ACTION_NAME, null, {
-            action: action,
-        }, false);
-        if (isRuntimePromise(result)) {
-            return markAsRuntimePromise(result.then((result) => {
-                return handleResult(result);
-            }));
-        }
-        return handleResult(result);
-        function handleResult(result) {
-            let rejected = false;
-            for (let i = 0; i < result.actions.length; i++) {
-                const a = result.actions[i];
-                if (a.type === 'reject' && a.actions.indexOf(action) >= 0) {
-                    rejected = true;
-                    result.actions.splice(i, 1);
-                    break;
-                }
-            }
-            return { rejected, newActions: result.actions };
-        }
-    }
-    /**
-     * 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.
-     *
-     */
-    _wrapWithCurrentPromise(func) {
-        if (this._stopState && isRuntimePromise(this._currentPromise)) {
-            // We have hit a breakpoint,
-            // only trigger this shout after the current state has finished.
-            return (this._currentPromise = markAsRuntimePromise(this._currentPromise.then(() => {
-                return func();
-            })));
-        }
-        return (this._currentPromise = func());
-    }
-    /**
-     * 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, botIds, arg) {
-        return this._synchronousShout(eventName, botIds, arg, true, true);
-    }
-    /**
-     * 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.
-     */
-    _synchronousShout(eventName, botIds, arg, batch, resetEnergy = true) {
-        return this._wrapWithCurrentPromise(() => {
-            return this._shout(eventName, botIds, arg, batch, resetEnergy);
-        });
-    }
-    _shout(eventName, botIds, arg, batch, resetEnergy = true) {
-        try {
-            arg = this._mapBotsToRuntimeBots(arg);
-            if (this._interpreter) {
-                const result = this._interpreter.proxyObject(arg);
-                if (result.Type !== 'normal') {
-                    throw new Error(`Unable to proxy shout argument!`);
-                }
-                arg = result.Value;
-            }
-        }
-        catch (err) {
-            arg = err;
-        }
-        const result = this._batchScriptResults(() => {
-            if (this.canTriggerBreakpoint) {
-                const results = (hasValue(botIds)
-                    ? getInterpretableFunction(this._library.api.whisper)(botIds, eventName, arg)
-                    : getInterpretableFunction(this._library.api.shout)(eventName, arg));
-                return this._processGenerator(results);
-            }
-            else {
-                const results = hasValue(botIds)
-                    ? this._library.api.whisper(botIds, eventName, arg)
-                    : this._library.api.shout(eventName, arg);
-                this._scheduleJobQueueCheck();
-                return results;
-            }
-        }, batch, resetEnergy);
-        if (isRuntimePromise(result)) {
-            return markAsRuntimePromise(result.then(({ actions, errors, result }) => {
-                return {
-                    actions,
-                    errors,
-                    results: result,
-                    listeners: [],
-                };
-            }));
-        }
-        return {
-            actions: result.actions,
-            errors: result.errors,
-            results: result.result,
-            listeners: [],
-        };
-    }
-    /**
-     * Executes the given script.
-     * @param script The script to run.
-     */
-    execute(script) {
-        return this._wrapWithCurrentPromise(() => {
-            return this._execute(script, true, true);
-        });
-    }
-    _execute(script, batch, resetEnergy) {
-        let fn;
-        try {
-            fn = this._compile(null, null, script, {});
-        }
-        catch (ex) {
-            let errors = [
-                {
-                    error: ex,
-                    bot: null,
-                    tag: null,
-                    script: script,
-                },
-            ];
-            this._onErrors.next(errors);
-            return {
-                result: undefined,
-                actions: [],
-                errors,
-            };
-        }
-        return this._batchScriptResults(() => {
-            try {
-                return fn();
-            }
-            catch (ex) {
-                this._globalContext.enqueueError(ex);
-            }
-        }, batch, resetEnergy);
-    }
-    /**
-     * Signals to the runtime that the bots state has been updated.
-     * @param update The bot state update.
-     */
-    stateUpdated(update) {
-        let nextUpdate = {
-            state: {},
-            addedBots: [],
-            updatedBots: [],
-            removedBots: [],
-            version: update.version,
-        };
-        let newBotIds = null;
-        let newBots = null;
-        let updates = null;
-        if (update.addedBots.length > 0) {
-            const { newBots: addedNewBots, newBotIDs: addedBotIds } = this._addBotsToState(update.addedBots.map((id) => update.state[id]), nextUpdate);
-            newBots = addedNewBots;
-            newBotIds = addedBotIds;
-        }
-        let removedBots = null;
-        if (update.removedBots.length > 0) {
-            removedBots = this._removeBotsFromState(update.removedBots, nextUpdate);
-        }
-        if (update.updatedBots.length > 0) {
-            updates = update.updatedBots.map((id) => {
-                const partial = update.state[id];
-                const current = this.currentState[id];
-                if (!current) {
-                    return null;
-                }
-                return updatedBot(partial, current);
-            });
-            this._updateBotsWithState(update, updates, nextUpdate, newBotIds || new Set());
-        }
-        this._sendOnBotsAddedShouts(newBots, nextUpdate);
-        this._sendOnBotsRemovedShouts(update.removedBots);
-        this._sendOnBotsChangedShouts(updates);
-        this._triggerPortalChangedHandlers(newBots, removedBots, updates);
-        return nextUpdate;
-    }
-    /**
-     * Signals to the runtime that the state version has been updated.
-     * @param newVersion The version update.
-     */
-    versionUpdated(newVersion) {
-        this._currentVersion = updateRuntimeVersion(newVersion, this._currentVersion);
-        return this._currentVersion;
-    }
-    _sendOnBotsAddedShouts(newBots, nextUpdate) {
-        if (newBots && nextUpdate.addedBots.length > 0) {
-            try {
-                this._synchronousShout(ON_BOT_ADDED_ACTION_NAME, nextUpdate.addedBots, undefined, true, false);
-                this._synchronousShout(ON_ANY_BOTS_ADDED_ACTION_NAME, null, {
-                    bots: newBots.map(([bot, precalc]) => bot),
-                }, true, false);
-            }
-            catch (err) {
-                if (!(err instanceof RanOutOfEnergyError)) {
-                    throw err;
-                }
-                else {
-                    console.warn(err);
-                }
-            }
-        }
-    }
-    _sendOnBotsRemovedShouts(botIds) {
-        if (botIds.length > 0) {
-            try {
-                let promise;
-                for (let bot of botIds) {
-                    const watchers = this._globalContext.getWatchersForBot(bot);
-                    promise = processListOfMaybePromises(promise, watchers, (watcher) => {
-                        const generator = watcher.handler();
-                        if (isGenerator(generator)) {
-                            return this._processGenerator(generator);
-                        }
-                    });
-                }
-                if (promise) {
-                    return markAsRuntimePromise(promise
-                        .then(() => {
-                        return this._synchronousShout(ON_ANY_BOTS_REMOVED_ACTION_NAME, null, {
-                            botIDs: botIds,
-                        }, true, false);
-                    })
-                        .catch((err) => {
-                        if (!(err instanceof RanOutOfEnergyError)) {
-                            throw err;
-                        }
-                        else {
-                            console.warn(err);
-                        }
-                    }));
-                }
-                else {
-                    const maybePromise = this._synchronousShout(ON_ANY_BOTS_REMOVED_ACTION_NAME, null, {
-                        botIDs: botIds,
-                    }, true, false);
-                    if (isRuntimePromise(maybePromise)) {
-                        return markAsRuntimePromise(maybePromise.catch((err) => {
-                            if (!(err instanceof RanOutOfEnergyError)) {
-                                throw err;
-                            }
-                            else {
-                                console.warn(err);
-                            }
-                        }));
-                    }
-                }
-            }
-            catch (err) {
-                if (!(err instanceof RanOutOfEnergyError)) {
-                    throw err;
-                }
-                else {
-                    console.warn(err);
-                }
-            }
-        }
-    }
-    _sendOnBotsChangedShouts(updates) {
-        if (updates && updates.length > 0) {
-            try {
-                let promise = processListOfMaybePromises(null, updates, (update) => {
-                    if (!update) {
-                        return;
-                    }
-                    let promise = this._synchronousShout(ON_BOT_CHANGED_ACTION_NAME, [update.bot.id], {
-                        tags: update.tags,
-                    }, true, false);
-                    const watchers = this._globalContext.getWatchersForBot(update.bot.id);
-                    return processListOfMaybePromises(promise, watchers, (watcher) => {
-                        const generator = watcher.handler();
-                        if (isGenerator(generator)) {
-                            return this._processGenerator(generator);
-                        }
-                        return generator;
-                    });
-                });
-                if (isPromise(promise)) {
-                    return promise
-                        .then(() => {
-                        return this._synchronousShout(ON_ANY_BOTS_CHANGED_ACTION_NAME, null, updates, true, false);
-                    })
-                        .catch((err) => {
-                        if (!(err instanceof RanOutOfEnergyError)) {
-                            throw err;
-                        }
-                        else {
-                            console.warn(err);
-                        }
-                    });
-                }
-                else {
-                    const maybePromise = this._synchronousShout(ON_ANY_BOTS_CHANGED_ACTION_NAME, null, updates, true, false);
-                    if (isPromise(maybePromise)) {
-                        return maybePromise.catch((err) => {
-                            if (!(err instanceof RanOutOfEnergyError)) {
-                                throw err;
-                            }
-                            else {
-                                console.warn(err);
-                            }
-                        });
-                    }
-                    else {
-                        return maybePromise;
-                    }
-                }
-            }
-            catch (err) {
-                if (!(err instanceof RanOutOfEnergyError)) {
-                    throw err;
-                }
-                else {
-                    console.warn(err);
-                }
-            }
-        }
-    }
-    _triggerPortalChangedHandlers(newBots, removedBots, updates) {
-        const portals = this._globalContext.getWatchedPortals();
-        if (!hasValue(this.userId)) {
-            return;
-        }
-        if (portals.size <= 0) {
-            return;
-        }
-        if ((!newBots || newBots.length <= 0) &&
-            (!removedBots || removedBots.length <= 0) &&
-            (!updates || updates.length <= 0)) {
-            return;
-        }
-        const userBot = this.currentState[this.userId];
-        if (!userBot) {
-            return;
-        }
-        return processListOfMaybePromises(null, portals, (portal) => {
-            const dimension = userBot.values[portal];
-            let hasChange = false;
-            if (hasValue(dimension)) {
-                if (newBots && newBots.length > 0) {
-                    for (let [_, newBot] of newBots) {
-                        if (isBotInDimension(null, newBot, dimension)) {
-                            hasChange = true;
-                            break;
-                        }
-                    }
-                }
-                if (!hasChange && removedBots && removedBots.length > 0) {
-                    for (let bot of removedBots) {
-                        if (bot) {
-                            if (isBotInDimension(null, bot, dimension)) {
-                                hasChange = true;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            if (!hasChange && updates && updates.length > 0) {
-                for (let update of updates) {
-                    if (hasValue(dimension)) {
-                        if (update.tags.includes(dimension)) {
-                            hasChange = true;
-                            break;
-                        }
-                    }
-                    if (update.bot.id === this.userId &&
-                        update.tags.includes(portal)) {
-                        hasChange = true;
-                        break;
-                    }
-                    if (this._portalBots.get(portal) === update.bot.id) {
-                        hasChange = true;
-                        break;
-                    }
-                }
-            }
-            if (hasChange) {
-                const watchers = this._globalContext.getWatchersForPortal(portal);
-                return processListOfMaybePromises(null, watchers, (watcher) => {
-                    const generator = watcher.handler();
-                    if (isGenerator(generator)) {
-                        return this._processGenerator(generator);
-                    }
-                });
-            }
-        });
-    }
-    _addBotsToState(bots, nextUpdate) {
-        var _a;
-        let newBots = [];
-        let newBotIDs = new Set();
-        for (let bot of bots) {
-            const existing = this._compiledState[bot.id];
-            if (!!existing) {
-                removeFromContext(this._globalContext, [existing.script], false);
-                delete this._compiledState[bot.id];
-                const index = newBots.findIndex(([b]) => b === existing);
-                if (index >= 0) {
-                    newBots.splice(index, 1);
-                    nextUpdate.addedBots.splice(index, 1);
-                }
-            }
-            let newBot = this._createCompiledBot(bot, false);
-            if (!!existing) {
-                const changes = existing.script.changes;
-                const maskChanges = existing.script.maskChanges;
-                for (let key in changes) {
-                    newBot.tags[key] =
-                        newBot.values[key] =
-                            newBot.script.changes[key] =
-                                changes[key];
-                }
-                let maskTags = new Set();
-                for (let space of TAG_MASK_SPACE_PRIORITIES) {
-                    const masks = maskChanges[space];
-                    let newMasks;
-                    let addNewMasks = false;
-                    let hasNewMasks = false;
-                    if (!((_a = newBot === null || newBot === void 0 ? void 0 : newBot.masks) === null || _a === void 0 ? void 0 : _a[space])) {
-                        addNewMasks = true;
-                        newMasks = {};
-                    }
-                    else {
-                        newMasks = newBot.masks[space];
-                    }
-                    if (masks) {
-                        if (!newBot.script.maskChanges[space]) {
-                            newBot.script.maskChanges[space] = {};
-                        }
-                        for (let key in masks) {
-                            hasNewMasks = true;
-                            maskTags.add(key);
-                            const value = (newMasks[key] =
-                                newBot.script.maskChanges[space][key] =
-                                    masks[key]);
-                            if (!maskTags.has(key)) {
-                                newBot.values[key] = value;
-                            }
-                        }
-                    }
-                    if (addNewMasks && hasNewMasks) {
-                        if (!newBot.masks) {
-                            newBot.masks = {};
-                        }
-                        newBot.masks[space] = newMasks;
-                    }
-                }
-                existing.script[REPLACE_BOT_SYMBOL](newBot.script);
-            }
-            let precalculated = {
-                id: bot.id,
-                precalculated: true,
-                tags: bot.tags,
-                values: {},
-            };
-            if (hasValue(bot.space)) {
-                newBot.space = bot.space;
-                precalculated.space = bot.space;
-            }
-            if (hasValue(bot.signatures)) {
-                precalculated.signatures = bot.signatures;
-            }
-            if (hasValue(newBot.masks)) {
-                precalculated.masks = newBot.masks;
-            }
-            newBots.push([newBot, precalculated]);
-            newBotIDs.add(newBot.id);
-            nextUpdate.state[bot.id] = precalculated;
-            nextUpdate.addedBots.push(bot.id);
-        }
-        for (let [bot, precalculated] of newBots) {
-            let tags = Object.keys(bot.values);
-            for (let tag of tags) {
-                precalculated.values[tag] = convertToCopiableValue(bot.values[tag]);
-            }
-        }
-        return {
-            newBotIDs,
-            newBots,
-        };
-    }
-    _removeBotsFromState(botIds, nextUpdate) {
-        let removedBots = [];
-        for (let id of botIds) {
-            const bot = this._compiledState[id];
-            if (bot) {
-                removeFromContext(this._globalContext, [bot.script]);
-                for (let breakpoint of bot.breakpoints) {
-                    this._interpreter.removeBreakpointById(breakpoint.id);
-                    this._breakpoints.delete(breakpoint.id);
-                }
-            }
-            removedBots.push(bot);
-            delete this._compiledState[id];
-            const list = this._getFunctionNamesForBot(id, false);
-            if (list) {
-                for (let name of list) {
-                    this._functionMap.delete(name);
-                }
-                this._botFunctionMap.delete(id);
-            }
-            nextUpdate.state[id] = null;
-            nextUpdate.removedBots.push(id);
-        }
-        return removedBots;
-    }
-    _updateBotsWithState(update, updates, nextUpdate, newBotIds) {
-        var _a, _b;
-        for (let id of update.updatedBots) {
-            if (!id) {
-                continue;
-            }
-            const u = update.state[id];
-            // 1. get compiled bot
-            let compiled = this._compiledState[id];
-            if (!compiled) {
-                // buffer tag masks
-                if (u.masks) {
-                    const existing = this._existingMasks[id] || {};
-                    this._existingMasks[id] = merge(existing, u.masks);
-                }
-                continue;
-            }
-            let partial = {
-                tags: {},
-                values: {},
-            };
-            let updatedTags = new Set();
-            if (u.tags) {
-                for (let tag in u.tags) {
-                    const tagValue = u.tags[tag];
-                    if (hasValue(tagValue) || tagValue === null) {
-                        if (isTagEdit(tagValue)) {
-                            const originalValue = tag in compiled.originalTagEditValues
-                                ? compiled.originalTagEditValues[tag]
-                                : compiled.tags[tag];
-                            compiled.tags[tag] = applyTagEdit(originalValue, tagValue);
-                        }
-                        else {
-                            compiled.tags[tag] = tagValue;
-                        }
-                        delete compiled.originalTagEditValues[tag];
-                        partial.tags[tag] = tagValue;
-                        updatedTags.add(tag);
-                    }
-                }
-            }
-            if (u.masks) {
-                for (let space in u.masks) {
-                    const tags = u.masks[space];
-                    for (let tag in tags) {
-                        const tagValue = u.masks[space][tag];
-                        if (hasValue(tagValue) || tagValue === null) {
-                            if (!compiled.masks) {
-                                compiled.masks = {};
-                            }
-                            if (!compiled.masks[space]) {
-                                compiled.masks[space] = {};
-                            }
-                            if (!partial.masks) {
-                                partial.masks = {};
-                            }
-                            if (!partial.masks[space]) {
-                                partial.masks[space] = {};
-                            }
-                            if (tagValue === null) {
-                                delete compiled.masks[space][tag];
-                            }
-                            else if (isTagEdit(tagValue)) {
-                                const originalValue = compiled.originalTagMaskEditValues[space] &&
-                                    tag in
-                                        compiled.originalTagMaskEditValues[space]
-                                    ? compiled.originalTagMaskEditValues[space][tag]
-                                    : compiled.masks[space][tag];
-                                compiled.masks[space][tag] = applyTagEdit(originalValue, tagValue);
-                            }
-                            else {
-                                compiled.masks[space][tag] = tagValue;
-                            }
-                            (_a = compiled.originalTagMaskEditValues[space]) === null || _a === void 0 ? true : delete _a[tag];
-                            updatedTags.add(tag);
-                            partial.masks[space][tag] = tagValue;
-                        }
-                    }
-                }
-            }
-            for (let tag of updatedTags) {
-                let hasTag = false;
-                if (compiled.masks) {
-                    for (let space of TAG_MASK_SPACE_PRIORITIES) {
-                        const tagValue = (_b = compiled.masks[space]) === null || _b === void 0 ? void 0 : _b[tag];
-                        if (hasValue(tagValue)) {
-                            this._compileTagValue(compiled, tag, tagValue);
-                            hasTag = true;
-                            break;
-                        }
-                    }
-                }
-                if (!hasTag) {
-                    const tagValue = compiled.tags[tag];
-                    if (hasValue(tagValue) || tagValue === null) {
-                        this._compileTagValue(compiled, tag, tagValue);
-                        hasTag = true;
-                    }
-                }
-                if (!hasTag) {
-                    // no tag or tag mask has a value
-                    this._compileTagValue(compiled, tag, null);
-                }
-                const compiledValue = compiled.values[tag];
-                partial.values[tag] = convertToCopiableValue(hasValue(compiledValue) ? compiledValue : null);
-            }
-            for (let breakpoint of compiled.breakpoints) {
-                if (updatedTags.has(breakpoint.tag)) {
-                    // Update the breakpoint
-                    const func = compiled.listeners[breakpoint.tag];
-                    if (func) {
-                        this._compiler.setBreakpoint({
-                            id: breakpoint.id,
-                            func: func,
-                            interpreter: this._interpreter,
-                            lineNumber: breakpoint.lineNumber,
-                            columnNumber: breakpoint.columnNumber,
-                            states: breakpoint.states,
-                        });
-                    }
-                    else {
-                        this._interpreter.removeBreakpointById(breakpoint.id);
-                    }
-                }
-            }
-            if (u.signatures) {
-                if (!compiled.signatures) {
-                    compiled.signatures = {};
-                }
-                partial.signatures = {};
-                for (let sig in u.signatures) {
-                    const val = !!u.signatures
-                        ? u.signatures[sig] || null
-                        : null;
-                    const current = compiled.signatures[sig];
-                    compiled.signatures[sig] = val;
-                    partial.signatures[sig] = val;
-                    if (!val && current) {
-                        this._compileTag(compiled, current, compiled.tags[current]);
-                    }
-                    else if (val && !current) {
-                        this._compileTag(compiled, val, compiled.tags[val]);
-                    }
-                }
-            }
-            nextUpdate.state[id] = partial;
-            if (!newBotIds.has(id)) {
-                nextUpdate.updatedBots.push(id);
-            }
-        }
-    }
-    notifyChange() {
-        if (!this._batchPending && this._autoBatch) {
-            this._batchPending = true;
-            if (this.canTriggerBreakpoint) {
-                this._scheduleJob('notifyChange', () => {
-                    this._processBatch();
-                });
-                return;
-            }
-            queueMicrotask(() => {
-                this._processBatch();
-            });
-        }
-    }
-    notifyActionEnqueued(action) {
-        if (this._scriptActionEnqueuedListeners.length > 0) {
-            for (let listener of this._scriptActionEnqueuedListeners) {
-                try {
-                    listener(action);
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            }
-        }
-    }
-    createRuntimeBot(bot) {
-        const space = getBotSpace(bot);
-        const mode = this._editModeProvider.getEditMode(space);
-        if (mode === RealtimeEditMode.Immediate) {
-            const compiled = this._createCompiledBot(bot, true);
-            this._newBots.set(bot.id, bot);
-            return compiled.script;
-        }
-        return null;
-    }
-    destroyScriptBot(bot) {
-        const space = getBotSpace(bot);
-        const mode = this._editModeProvider.getEditMode(space);
-        if (mode === RealtimeEditMode.Immediate) {
-            delete this._compiledState[bot.id];
-        }
-        return mode;
-    }
-    _processBatch() {
-        this._batchPending = false;
-        // Send the batch once all the micro tasks are completed
-        // Grab any unbatched actions and errors.
-        // This can happen if an action is queued during a callback
-        // or promise.
-        const unbatchedActions = this._processUnbatchedActions();
-        const unbatchedErrors = this._processUnbatchedErrors();
-        const actions = this._actionBatch;
-        const errors = this._errorBatch;
-        this._processCore(unbatchedActions);
-        errors.push(...unbatchedErrors);
-        this._actionBatch = [];
-        this._errorBatch = [];
-        if (actions.length <= 0 && errors.length <= 0) {
-            return;
-        }
-        // Schedule a new micro task to
-        // run at a later time with the actions.
-        // This ensures that we don't block other flush operations
-        // due to handlers running synchronously.
-        queueMicrotask(() => {
-            this._onActions.next(actions);
-            this._onErrors.next(errors);
-        });
-        this._processErrors(errors);
-    }
-    _processErrors(errors) {
-        if (this._processingErrors) {
-            return;
-        }
-        try {
-            this._processingErrors = true;
-            if (errors.length > 0) {
-                const actions = [];
-                for (let e of errors) {
-                    if (e.tag === ON_ERROR) {
-                        continue;
-                    }
-                    if (e.bot && e.tag) {
-                        const b = this._compiledState[e.bot.id];
-                        if (b) {
-                            let currentCount = b.errorCounts[e.tag] || 0;
-                            if (currentCount === this.repeatedErrorLimit) {
-                                console.warn(`[AuxRuntime] Repeated error limit reached for tag on bot: ${e.bot.id}.${e.tag}`);
-                                console.warn(`[AuxRuntime] If this happens, then there is likely a bug in your inst that causes @onError and @${e.tag} to call each other infinitely.`);
-                            }
-                            currentCount = b.errorCounts[e.tag] =
-                                currentCount + 1;
-                            if (currentCount > this.repeatedErrorLimit) {
-                                continue;
-                            }
-                        }
-                    }
-                    actions.push(action(ON_ERROR, undefined, undefined, {
-                        bot: e.bot,
-                        tag: e.tag,
-                        error: e.error,
-                    }));
-                }
-                this.process(actions);
-            }
-        }
-        finally {
-            this._processingErrors = false;
-        }
-    }
-    _batchScriptResults(callback, batch, resetEnergy) {
-        const result = this._calculateScriptResults(callback, resetEnergy);
-        if (isRuntimePromise(result)) {
-            return markAsRuntimePromise(result.then((results) => {
-                if (batch) {
-                    this._actionBatch.push(...results.actions);
-                    this.notifyChange();
-                }
-                this._errorBatch.push(...results.errors);
-                return results;
-            }));
-        }
-        if (batch) {
-            this._actionBatch.push(...result.actions);
-        }
-        this._errorBatch.push(...result.errors);
-        return result;
-    }
-    _calculateScriptResults(callback, resetEnergy) {
-        this._globalContext.playerBot = this.userBot;
-        if (resetEnergy) {
-            this._globalContext.energy = DEFAULT_ENERGY;
-        }
-        const result = callback();
-        if (isRuntimePromise(result)) {
-            return markAsRuntimePromise(result.then((results) => {
-                const actions = this._processUnbatchedActions();
-                const errors = this._processUnbatchedErrors();
-                return {
-                    result: results,
-                    actions: actions,
-                    errors: errors,
-                };
-            }));
-        }
-        const actions = this._processUnbatchedActions();
-        const errors = this._processUnbatchedErrors();
-        return {
-            result: result,
-            actions: actions,
-            errors: errors,
-        };
-    }
-    _processUnbatchedErrors() {
-        // TODO: Improve to correctly handle when a non ScriptError object is added
-        // but contains symbol properties that reference the throwing bot and tag.
-        // The AuxRuntime should look for these error objects and create ScriptErrors for them.
-        return this._globalContext.dequeueErrors();
-    }
-    _processUnbatchedActions() {
-        const actions = this._globalContext.dequeueActions();
-        const updatedBots = [...this._updatedBots.values()];
-        for (let action of actions) {
-            if (action.type === 'add_bot') {
-                if (this._newBots.has(action.id)) {
-                    action.bot.tags = Object.assign({}, action.bot.tags);
-                }
-            }
-        }
-        let updates = [];
-        for (let bot of updatedBots) {
-            const hasTagChange = Object.keys(bot.changes).length > 0;
-            const hasMaskChange = Object.keys(bot.maskChanges).length > 0;
-            const hasChange = hasTagChange || hasMaskChange;
-            if (hasChange) {
-                const isNewBot = this._newBots.has(bot.id);
-                if (isNewBot) {
-                    // tag mask changes need to be handled here
-                    // because new bots don't share the same reference to the
-                    // bot in the add bot event (unlike normal bots)
-                    if (hasMaskChange) {
-                        const newBot = this._newBots.get(bot.id);
-                        newBot.masks = {};
-                        for (let space in bot.maskChanges) {
-                            newBot.masks[space] = Object.assign({}, bot.maskChanges[space]);
-                        }
-                    }
-                }
-                else {
-                    if (isInContext(this._globalContext, bot)) {
-                        let update = {};
-                        if (hasTagChange) {
-                            update.tags = Object.assign({}, bot.changes);
-                        }
-                        if (hasMaskChange) {
-                            update.masks = {};
-                            for (let space in bot.maskChanges) {
-                                update.masks[space] = Object.assign({}, bot.maskChanges[space]);
-                            }
-                        }
-                        updates.push(botUpdated(bot.id, update));
-                    }
-                }
-            }
-        }
-        for (let bot of updatedBots) {
-            bot[CLEAR_CHANGES_SYMBOL]();
-        }
-        const sortedUpdates = sortBy(updates, (u) => u.id);
-        this._updatedBots.clear();
-        this._newBots.clear();
-        actions.push(...sortedUpdates);
-        return actions;
-    }
-    _compileTags(tags, compiled, bot) {
-        let updates = [];
-        for (let tag of tags) {
-            updates.push(this._compileTagOrMask(compiled, bot, tag));
-        }
-        return updates;
-    }
-    _createCompiledBot(bot, fromFactory) {
-        var _a, _b;
-        let compiledBot = {
-            id: bot.id,
-            precalculated: true,
-            tags: fromFactory ? bot.tags : Object.assign({}, bot.tags),
-            listeners: {},
-            values: {},
-            script: null,
-            originalTagEditValues: {},
-            originalTagMaskEditValues: {},
-            breakpoints: [],
-            errorCounts: {},
-        };
-        if (BOT_SPACE_TAG in bot) {
-            compiledBot.space = bot.space;
-        }
-        if (hasValue(bot.signatures)) {
-            compiledBot.signatures = bot.signatures;
-        }
-        // Copy existing tag masks to the new bot
-        if (!fromFactory && this._existingMasks[bot.id]) {
-            const existing = this._existingMasks[bot.id];
-            delete this._existingMasks[bot.id];
-            for (let space in existing) {
-                if (!bot.masks) {
-                    bot.masks = {};
-                }
-                for (let tag in existing[space]) {
-                    if (hasValue((_b = (_a = bot.masks) === null || _a === void 0 ? void 0 : _a[space]) === null || _b === void 0 ? void 0 : _b[tag])) {
-                        continue;
-                    }
-                    if (!bot.masks[space]) {
-                        bot.masks[space] = {};
-                    }
-                    bot.masks[space][tag] = existing[space][tag];
-                }
-            }
-        }
-        // Copy the new bot tag masks to the compiled bot
-        if (hasValue(bot.masks)) {
-            compiledBot.masks = {};
-            for (let space in bot.masks) {
-                compiledBot.masks[space] = Object.assign({}, bot.masks[space]);
-            }
-        }
-        compiledBot.script = this._createRuntimeBot(compiledBot);
-        const tags = tagsOnBot(compiledBot);
-        this._compileTags(tags, compiledBot, bot);
-        if (!fromFactory) {
-            addToContext(this._globalContext, compiledBot.script);
-        }
-        this._compiledState[bot.id] = compiledBot;
-        return compiledBot;
-    }
-    _createRuntimeBot(bot) {
-        return createRuntimeBot(bot, this);
-    }
-    updateTag(bot, tag, newValue) {
-        if (isRuntimeBot(newValue)) {
-            throw new Error(`It is not possible to save bots as tag values. (Setting '${tag}' on ${bot.id})`);
-        }
-        const oldValue = bot.values[tag];
-        const space = getBotSpace(bot);
-        const mode = this._editModeProvider.getEditMode(space);
-        if (mode === RealtimeEditMode.Immediate) {
-            this._compileTag(bot, tag, newValue);
-        }
-        this._updatedBots.set(bot.id, bot.script);
-        this.notifyChange();
-        if (newValue instanceof DateTime) {
-            newValue = formatBotDate(newValue);
-        }
-        else if (newValue instanceof Vector2 || newValue instanceof Vector3) {
-            newValue = formatBotVector(newValue);
-        }
-        else if (newValue instanceof Rotation) {
-            newValue = formatBotRotation(newValue);
-        }
-        if (this._scriptUpdatedTagListeners.length > 0) {
-            for (let listener of this._scriptUpdatedTagListeners) {
-                try {
-                    listener({
-                        botId: bot.id,
-                        tag,
-                        oldValue,
-                        newValue,
-                    });
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            }
-        }
-        return {
-            mode,
-            changedValue: newValue,
-        };
-    }
-    getValue(bot, tag) {
-        return bot.values[tag];
-    }
-    getRawValue(bot, tag) {
-        return bot.tags[tag];
-    }
-    updateTagMask(bot, tag, spaces, value) {
-        if (isRuntimeBot(value)) {
-            throw new Error(`It is not possible to save bots as tag values. (Setting '${tag}' on ${bot.id})`);
-        }
-        let oldValuesAndSpaces = [];
-        let updated = false;
-        for (let space of spaces) {
-            const mode = this._editModeProvider.getEditMode(space);
-            if (mode === RealtimeEditMode.Immediate) {
-                if (!bot.masks) {
-                    bot.masks = {};
-                }
-                if (!bot.masks[space]) {
-                    bot.masks[space] = {};
-                }
-                let oldValue = bot.masks[space][tag];
-                if (isTagEdit(value)) {
-                    if (!bot.originalTagMaskEditValues[space]) {
-                        bot.originalTagMaskEditValues[space] = {};
-                    }
-                    if (!(tag in bot.originalTagMaskEditValues[space])) {
-                        bot.originalTagMaskEditValues[space][tag] =
-                            bot.masks[space][tag];
-                    }
-                    bot.masks[space][tag] = applyTagEdit(bot.masks[space][tag], value);
-                }
-                else {
-                    bot.masks[space][tag] = value;
-                }
-                updated = true;
-                oldValuesAndSpaces.push({
-                    space,
-                    oldValue,
-                });
-            }
-        }
-        if (updated) {
-            this._compileTagOrMask(bot, bot, tag);
-            this._updatedBots.set(bot.id, bot.script);
-            this.notifyChange();
-        }
-        if (value instanceof DateTime) {
-            value = formatBotDate(value);
-        }
-        else if (value instanceof Vector2 || value instanceof Vector3) {
-            value = formatBotVector(value);
-        }
-        else if (value instanceof Rotation) {
-            value = formatBotRotation(value);
-        }
-        if (updated && this._scriptUpdatedTagMaskListeners.length > 0) {
-            for (let listener of this._scriptUpdatedTagMaskListeners) {
-                for (let { oldValue, space } of oldValuesAndSpaces) {
-                    try {
-                        listener({
-                            botId: bot.id,
-                            tag,
-                            oldValue,
-                            newValue: value,
-                            space,
-                        });
-                    }
-                    catch (err) {
-                        console.error(err);
-                    }
-                }
-            }
-        }
-        return {
-            mode: RealtimeEditMode.Immediate,
-            changedValue: value,
-        };
-    }
-    getTagMask(bot, tag) {
-        var _a, _b;
-        for (let space of TAG_MASK_SPACE_PRIORITIES) {
-            const tagValue = (_b = (_a = bot.masks) === null || _a === void 0 ? void 0 : _a[space]) === null || _b === void 0 ? void 0 : _b[tag];
-            if (hasValue(tagValue)) {
-                return this._compileTagMaskValue(bot, tag, space, tagValue);
-            }
-        }
-        return undefined;
-    }
-    getListener(bot, tag) {
-        const listener = bot.listeners[tag];
-        if (listener) {
-            return listener;
-        }
-        this.getValue(bot, tag);
-        return bot.listeners[tag] || null;
-    }
-    getTagLink(bot, tag) {
-        const tagValue = bot.values[tag];
-        if (isBotLink(tagValue)) {
-            const links = parseBotLink(tagValue);
-            const bots = links.map((link) => this.context.state[link] || null);
-            if (bots.length === 1) {
-                return bots[0];
-            }
-            return bots;
-        }
-        return undefined;
-    }
-    getSignature(bot, signature) {
-        return !!bot.signatures ? bot.signatures[signature] : undefined;
-    }
-    _compileTagOrMask(bot, existingBot, tag) {
-        var _a, _b, _c;
-        let hadMask = false;
-        if (existingBot.masks) {
-            for (let space of TAG_MASK_SPACE_PRIORITIES) {
-                const tagValue = (_a = existingBot.masks[space]) === null || _a === void 0 ? void 0 : _a[tag];
-                if (hasValue(tagValue)) {
-                    if (!bot.masks) {
-                        bot.masks = {};
-                    }
-                    if (!bot.masks[space]) {
-                        bot.masks[space] = {};
-                    }
-                    bot.masks[space][tag] = tagValue;
-                    this._compileTagValue(bot, tag, tagValue);
-                    return [space, tag];
-                }
-                else if (hasValue((_c = (_b = bot.masks) === null || _b === void 0 ? void 0 : _b[space]) === null || _c === void 0 ? void 0 : _c[tag])) {
-                    // Indicate that there used to be a value for the tag mask
-                    // but it has been removed.
-                    hadMask = true;
-                    break;
-                }
-            }
-        }
-        const tagValue = existingBot.tags[tag];
-        if (hasValue(tagValue) || tagValue === null) {
-            bot.tags[tag] = tagValue;
-            this._compileTagValue(bot, tag, tagValue);
-            if (hadMask) {
-                return [undefined, tag];
-            }
-            else {
-                return [null, tag];
-            }
-        }
-        // Undefined means that a tag mask was removed.
-        return [undefined, tag];
-    }
-    _compileTag(bot, tag, tagValue) {
-        var _a;
-        if (bot.masks) {
-            for (let space of TAG_MASK_SPACE_PRIORITIES) {
-                if (hasValue((_a = bot.masks[space]) === null || _a === void 0 ? void 0 : _a[tag])) {
-                    return;
-                }
-            }
-        }
-        if (isTagEdit(tagValue)) {
-            if (!(tag in bot.originalTagEditValues)) {
-                bot.originalTagEditValues[tag] = bot.tags[tag];
-            }
-            tagValue = bot.tags[tag] = applyTagEdit(bot.tags[tag], tagValue);
-        }
-        else {
-            if (tag in bot.originalTagEditValues) {
-                delete bot.originalTagEditValues[tag];
-            }
-            if (hasValue(tagValue)) {
-                if (this._newBots.has(bot.id) &&
-                    (tagValue instanceof DateTime ||
-                        tagValue instanceof Vector2 ||
-                        tagValue instanceof Vector3 ||
-                        tagValue instanceof Rotation)) {
-                    bot.tags[tag] = convertToCopiableValue(tagValue);
-                }
-                else {
-                    bot.tags[tag] = tagValue;
-                }
-            }
-            else {
-                delete bot.tags[tag];
-            }
-        }
-        this._compileTagValue(bot, tag, tagValue);
-    }
-    _compileTagValue(bot, tag, tagValue) {
-        let { value, listener } = this._compileValue(bot, tag, tagValue);
-        if (listener) {
-            bot.listeners[tag] = listener;
-            this._globalContext.recordListenerPresense(bot.id, tag, true);
-        }
-        else if (!!bot.listeners[tag]) {
-            delete bot.listeners[tag];
-            this._globalContext.recordListenerPresense(bot.id, tag, false);
-        }
-        if (typeof value !== 'function') {
-            if (hasValue(value)) {
-                bot.values[tag] = value;
-            }
-            else {
-                delete bot.values[tag];
-            }
-        }
-        return value;
-    }
-    _compileValue(bot, tag, value) {
-        let listener;
-        if (isFormula(value)) {
-            const parsed = value.substring(DNA_TAG_PREFIX.length);
-            const transformed = replaceMacros(parsed);
-            try {
-                value = JSON.parse(transformed);
-            }
-            catch (ex) {
-                value = ex;
-            }
-        }
-        else if (isScript(value)) {
-            try {
-                listener = this._compile(bot, tag, value, {});
-            }
-            catch (ex) {
-                value = ex;
-            }
-        }
-        else if (isTaggedString(value)) {
-            value = parseTaggedString(value);
-        }
-        else if (isNumber(value)) {
-            value = parseNumber(value);
-        }
-        else if (isTaggedNumber(value)) {
-            // Tagged numbers that are not valid numbers
-            // should always be NaN.
-            value = NaN;
-        }
-        else if (value === 'true') {
-            value = true;
-        }
-        else if (value === 'false') {
-            value = false;
-        }
-        else if (isBotDate(value)) {
-            const result = parseBotDate(value);
-            if (result) {
-                value = result;
-            }
-        }
-        else if (isBotVector(value)) {
-            const result = parseBotVector(value);
-            if (result) {
-                value = result;
-            }
-        }
-        else if (isBotRotation(value)) {
-            const result = parseBotRotation(value);
-            if (result) {
-                value = result;
-            }
-        }
-        return { value, listener };
-    }
-    _compileTagMaskValue(bot, tag, space, value) {
-        let changedValue = false;
-        let newValue = value;
-        if (isFormula(value)) {
-            const parsed = value.substring(DNA_TAG_PREFIX.length);
-            const transformed = replaceMacros(parsed);
-            try {
-                newValue = JSON.parse(transformed);
-                changedValue = true;
-            }
-            catch (ex) {
-                newValue = ex;
-            }
-        }
-        if (isTaggedString(value)) {
-            newValue = parseTaggedString(value);
-            changedValue = true;
-        }
-        else if (isTaggedNumber(value)) {
-            const parsed = parseTaggedNumber(value);
-            if (isNumber(parsed)) {
-                newValue = parseNumber(parsed);
-                changedValue = true;
-            }
-        }
-        else if (isBotDate(value)) {
-            const result = parseBotDate(value);
-            if (result) {
-                newValue = result;
-                changedValue = true;
-            }
-        }
-        else if (isBotVector(value)) {
-            const result = parseBotVector(value);
-            if (result) {
-                newValue = result;
-                changedValue = true;
-            }
-        }
-        else if (isBotRotation(value)) {
-            const result = parseBotRotation(value);
-            if (result) {
-                newValue = result;
-                changedValue = true;
-            }
-        }
-        if (changedValue) {
-            bot.masks[space][tag] = newValue;
-            return newValue;
-        }
-        else {
-            return value;
-        }
-    }
-    _compile(bot, tag, script, options) {
-        if (this._forceSignedScripts) {
-            if (this._exemptSpaces.indexOf(bot.space) < 0) {
-                const hash = tagValueHash(bot.id, tag, script);
-                if (!bot.signatures || bot.signatures[hash] !== tag) {
-                    throw new Error('Unable to compile script. It is not signed with a valid certificate.');
-                }
-            }
-        }
-        script = replaceMacros(script);
-        let functionName;
-        let diagnosticFunctionName;
-        let fileName;
-        if (hasValue(bot)) {
-            this._functionNameCounter += 1;
-            functionName = '_' + this._functionNameCounter;
-            diagnosticFunctionName = tag;
-            fileName = `${bot.id}.${diagnosticFunctionName}`;
-        }
-        const constants = Object.assign(Object.assign({}, this._library.api), { tagName: tag, globalThis: this._globalObject });
-        const specifics = Object.assign({}, this._library.tagSpecificApi);
-        if (this._interpreter) {
-            delete constants.globalThis;
-            // if (this.canTriggerBreakpoint) {
-            Object.assign(constants, this._interpretedApi);
-            Object.assign(specifics, this._interpretedTagSpecificApi);
-            // }
-        }
-        const func = this._compiler.compile(script, {
-            // TODO: Support all the weird features
-            functionName: functionName,
-            diagnosticFunctionName: diagnosticFunctionName,
-            fileName: fileName,
-            forceSync: this._forceSyncScripts,
-            interpreter: this._interpreter,
-            context: {
-                bot,
-                tag,
-                creator: null,
-            },
-            before: (ctx) => {
-                ctx.creator = ctx.bot
-                    ? this._getRuntimeBot(ctx.bot.script.tags.creator)
-                    : null;
-                //  TODO: Determine whether to support this
-                // if (this._beforeScriptEnterListeners.length > 0) {
-                //     for (let listener of this._beforeScriptEnterListeners) {
-                //         try {
-                //             listener({
-                //                 botId: ctx.bot.id,
-                //                 tag: ctx.tag,
-                //                 enterType: 'call',
-                //             });
-                //         } catch (err) {
-                //             console.error(err);
-                //         }
-                //     }
-                // }
-            },
-            onError: (err, ctx, meta) => {
-                const data = this._handleError(err, ctx.bot, ctx.tag);
-                throw data;
-            },
-            constants: constants,
-            variables: Object.assign(Object.assign({}, specifics), { this: (ctx) => (ctx.bot ? ctx.bot.script : null), thisBot: (ctx) => (ctx.bot ? ctx.bot.script : null), bot: (ctx) => (ctx.bot ? ctx.bot.script : null), tags: (ctx) => (ctx.bot ? ctx.bot.script.tags : null), raw: (ctx) => (ctx.bot ? ctx.bot.script.raw : null), masks: (ctx) => (ctx.bot ? ctx.bot.script.masks : null), creatorBot: (ctx) => ctx.creator, configBot: () => this.context.playerBot, links: (ctx) => (ctx.bot ? ctx.bot.script.links : null) }),
-            arguments: [['that', 'data']],
-        });
-        if (hasValue(bot)) {
-            this._functionMap.set(functionName, func);
-            const botFunctionNames = this._getFunctionNamesForBot(bot.id);
-            botFunctionNames.add(functionName);
-        }
-        return func;
-    }
-    _handleError(err, bot, tag) {
-        if (err instanceof RanOutOfEnergyError) {
-            throw err;
-        }
-        let data = {
-            error: err,
-            bot: bot,
-            tag: tag,
-        };
-        if (err instanceof Error) {
-            try {
-                const newStack = this._compiler.calculateOriginalStackTrace(this._functionMap, err);
-                if (newStack) {
-                    err.oldStack = err.stack;
-                    err.stack = newStack;
-                }
-            }
-            catch (stackError) {
-                console.error('[AuxRuntime] Unable to transform error stack trace', stackError);
-            }
-        }
-        return data;
-    }
-    _getRuntimeBot(id) {
-        if (hasValue(id) && typeof id === 'string') {
-            const creator = this._compiledState[id];
-            if (creator) {
-                return creator.script;
-            }
-        }
-        return null;
-    }
-    /**
-     * 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.
-     */
-    _mapBotsToRuntimeBots(value) {
-        return this._mapBotsToRuntimeBotsCore(value, 0, new Map());
-    }
-    _mapBotsToRuntimeBotsCore(value, depth, map) {
-        if (depth > 1000) {
-            throw new DeepObjectError();
-        }
-        if (isBot(value)) {
-            return this._globalContext.state[value.id] || value;
-        }
-        else if (Array.isArray(value) && value.some(isBot)) {
-            let arr = value.map((b) => isBot(b) ? this._globalContext.state[b.id] || b : b);
-            arr[ORIGINAL_OBJECT] = value;
-            return arr;
-        }
-        else if (typeof value === 'string') {
-            if (isTaggedString(value)) {
-                return parseTaggedString(value);
-            }
-            else if (isTaggedNumber(value)) {
-                return parseNumber(value);
-            }
-            else if (isBotVector(value)) {
-                return parseBotVector(value);
-            }
-            else if (isBotDate(value)) {
-                return parseBotDate(value);
-            }
-            else if (isBotRotation(value)) {
-                return parseBotRotation(value);
-            }
-            else if (isBotLink(value)) {
-                const ids = parseBotLink(value);
-                if (ids && ids.length > 1) {
-                    return ids.map((id) => this._globalContext.state[id]);
-                }
-                else if (ids && ids.length > 0) {
-                    return this._globalContext.state[ids[0]];
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-        else {
-            if (map.has(value)) {
-                return map.get(value);
-            }
-            if (typeof value === 'object' &&
-                value !== null &&
-                value[UNMAPPABLE] === true) {
-                return value;
-            }
-            if (hasValue(value) &&
-                !Array.isArray(value) &&
-                !(value instanceof ArrayBuffer) &&
-                typeof value === 'object' &&
-                Object.getPrototypeOf(value) === Object.prototype) {
-                let result = {
-                    [ORIGINAL_OBJECT]: value,
-                };
-                map.set(value, result);
-                forOwn(value, (value, key, object) => {
-                    result[key] = this._mapBotsToRuntimeBotsCore(value, depth + 1, map);
-                });
-                return result;
-                // return transform(
-                //     value,
-                //     (result, value, key) =>
-                //         this._transformBotsToRuntimeBots(result, value, key),
-                //     { [ORIGINAL_OBJECT]: value }
-                // );
-            }
-            else if (hasValue(value) &&
-                Array.isArray(value) &&
-                !(value instanceof ArrayBuffer)) {
-                const result = [];
-                map.set(value, result);
-                result.push(...value.map((v) => this._mapBotsToRuntimeBotsCore(v, depth + 1, map)));
-                return result;
-            }
-        }
-        return value;
-    }
-    _getFunctionNamesForBot(botId, createIfDoesNotExist = true) {
-        let list = this._botFunctionMap.get(botId);
-        if (!list && createIfDoesNotExist) {
-            list = new Set();
-            this._botFunctionMap.set(botId, list);
-        }
-        return list;
-    }
-    setBreakpoint(breakpoint) {
-        const bot = this.currentState[breakpoint.botId];
-        const breakpointIndex = bot.breakpoints.findIndex((b) => b.id === breakpoint.id);
-        if (breakpointIndex >= 0) {
-            bot.breakpoints[breakpointIndex] = breakpoint;
-        }
-        else {
-            bot.breakpoints.push(breakpoint);
-        }
-        this._breakpoints.set(breakpoint.id, breakpoint);
-        const func = bot.listeners[breakpoint.tag];
-        if (func) {
-            this._compiler.setBreakpoint({
-                id: breakpoint.id,
-                func: func,
-                interpreter: this._interpreter,
-                lineNumber: breakpoint.lineNumber,
-                columnNumber: breakpoint.columnNumber,
-                states: breakpoint.states,
-            });
-        }
-    }
-    removeBreakpoint(breakpointId) {
-        const breakpoint = this._breakpoints.get(breakpointId);
-        if (breakpoint) {
-            this._breakpoints.delete(breakpointId);
-            const bot = this.currentState[breakpoint.botId];
-            const breakpointIndex = bot.breakpoints.findIndex((b) => b.id === breakpoint.id);
-            if (breakpointIndex >= 0) {
-                bot.breakpoints.splice(breakpointIndex, 1);
-            }
-            this._interpreter.removeBreakpointById(breakpoint.id);
-        }
-    }
-    continueAfterStop(stopId, continuation) {
-        const state = this._stopState;
-        if (!state || state.stopId !== stopId) {
-            return;
-        }
-        this._stopState = null;
-        this._globalContext.actions.push(...state.actions);
-        this._globalContext.errors.push(...state.errors);
-        this._executeGenerator(state.resolve, state.reject, state.generator, continuation);
-        // this._processGenerator(state.generator, continuation).then(state.resolve, state.reject);
-    }
-    _scheduleJob(queueName, job) {
-        if (this._interpreter) {
-            this._interpreter.realm.scope(() => {
-                this._interpreter.agent.queueJob(queueName, () => {
-                    job();
-                    return Value.undefined;
-                });
-            });
-        }
-    }
-    _scheduleJobQueueCheck() {
-        if (this._interpreter) {
-            // Increment the current job queue check count and save it.
-            // This is used to short-circuit job queue checks if future checks are scheduled
-            // before this one runs.
-            this._jobQueueCheckCount++;
-            const currentCheck = this._jobQueueCheckCount;
-            this._jobQueueCheckPending = true;
-            // Queue a microtask to fire before the current task finishes
-            queueMicrotask(() => {
-                // Short circuit if another check has been scheduled.
-                if (this._jobQueueCheckCount !== currentCheck) {
-                    return;
-                }
-                // Queue another microtask to ensure that the job queue gets processed
-                // after all current microtasks are executed.
-                // This allows _scheduleJobQueueCheck() to be scheduled before other microtasks are queued.
-                queueMicrotask(() => {
-                    // Short circuit if another check has been scheduled.
-                    if (this._jobQueueCheckCount !== currentCheck ||
-                        this._interpreter.agent.jobQueue.length <= 0) {
-                        return;
-                    }
-                    this._processJobQueueNow();
-                    if (this._interpreter.agent.jobQueue.length <= 0) {
-                        // Check to see if any more jobs have been added after the job queue has been processed
-                        // and trigger another job queue check if they have.
-                        this._scheduleJobQueueCheck();
-                    }
-                });
-            });
-        }
-    }
-    // private _processJobQueueMicrotask() {
-    //     queueMicrotask(() => {
-    //         this._processJobQueueNow();
-    //     });
-    // }
-    _processJobQueueNow() {
-        // TODO: Determine whether to support this
-        // let scriptJobs: { botId: string; tag: string }[] = [];
-        // for (let job of this._interpreter.agent.jobQueue) {
-        //     if (
-        //         job.callerScriptOrModule &&
-        //         FUNCTION_METADATA in job.callerScriptOrModule
-        //     ) {
-        //         const meta: AuxScriptMetadata = (
-        //             job.callerScriptOrModule as any
-        //         )[FUNCTION_METADATA] as AuxScriptMetadata;
-        //         const context = meta.context as {
-        //             bot: CompiledBot;
-        //             tag: string;
-        //         };
-        //         const botId = context.bot.id;
-        //         const tag = context.tag;
-        //         scriptJobs.push({
-        //             botId,
-        //             tag,
-        //         });
-        //     }
-        // }
-        // if (
-        //     scriptJobs.length > 0 &&
-        //     this._beforeScriptEnterListeners.length > 0
-        // ) {
-        //     for (let job of scriptJobs) {
-        //         for (let listener of this._beforeScriptEnterListeners) {
-        //             try {
-        //                 listener({
-        //                     enterType: 'task',
-        //                     botId: job.botId,
-        //                     tag: job.tag,
-        //                 });
-        //             } catch (err) {
-        //                 console.error(err);
-        //             }
-        //         }
-        //     }
-        // }
-        const queueGen = this._interpreter.runJobQueue();
-        while (true) {
-            const next = queueGen.next();
-            if (next.done) {
-                break;
-            }
-            else {
-                // TODO: Process breakpoint
-            }
-        }
-        this._jobQueueCheckPending = false;
-    }
-    processGenerator(generator) {
-        this._processGenerator(generator);
-    }
-    _processGenerator(generator, continuation) {
-        return markAsRuntimePromise(new Promise((resolve, reject) => {
-            this._executeGenerator(resolve, reject, generator, continuation);
-        }));
-    }
-    _executeGenerator(resolve, reject, generator, continuation) {
-        try {
-            let result;
-            while (true) {
-                const next = generator.next(continuation);
-                if (next.done === true) {
-                    result = next.value;
-                    break;
-                }
-                else {
-                    this._currentStopCount += 1;
-                    const actions = this._processUnbatchedActions();
-                    const errors = this._processUnbatchedErrors();
-                    const state = {
-                        stopId: this._currentStopCount,
-                        generator,
-                        resolve,
-                        reject,
-                        actions,
-                        errors,
-                    };
-                    this._stopState = state;
-                    let breakpoint = this._breakpoints.get(next.value.breakpoint.id);
-                    this._onRuntimeStop.next(Object.assign(Object.assign({}, next.value), { breakpoint, stopId: this._currentStopCount }));
-                    return;
-                }
-            }
-            this._scheduleJobQueueCheck();
-            resolve(result);
-        }
-        catch (err) {
-            reject(err);
-        }
-    }
-}
-/**
- * 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 function mapLibraryFunctions(library, map) {
-    let newLibrary = Object.assign({}, library);
-    newLibrary.api = mapFunctions(newLibrary.api, map);
-    return newLibrary;
-}
-function mapFunctions(obj, map) {
-    let newObj = Object.create(obj);
-    assignFunctions(obj, newObj, map);
-    return newObj;
-}
-function assignFunctions(obj, newObj, map) {
-    let descriptors = Object.getOwnPropertyDescriptors(obj);
-    for (let key in descriptors) {
-        let descriptor = descriptors[key];
-        if (descriptor.get || descriptor.set || !descriptor.enumerable) {
-            continue;
-        }
-        const val = descriptor.value;
-        if (typeof val === 'function') {
-            let newFunc = (newObj[key] = map(val, key));
-            if (newFunc) {
-                assignFunctions(val, newFunc, map);
-            }
-            continue;
-        }
-        if (typeof val !== 'object' ||
-            val === null ||
-            Object.getPrototypeOf(val).constructor !== Object) {
-            continue;
-        }
-        newObj[key] = mapFunctions(val, map);
-    }
-}
-// function wrapGeneratorFunc<T>(
-//     func: (...args: any[]) => T
-// ): (...args: any[]) => T {
-//     return (...args: any[]) => {
-//         let res = func(...args);
-//         if (isGenerator(res)) {
-//             return unwind(res);
-//         }
-//         return res;
-//     };
-// }
-/**
- * Processes the given list of items in a sequential manner, calling the given function for each item.
- * @param list The list of items to process.
- * @param func The function that should be called for each item.
- */
-function processListOfMaybePromises(promise, list, func) {
-    for (let item of list) {
-        if (!isRuntimePromise(promise)) {
-            const p = func(item);
-            if (isRuntimePromise(p)) {
-                promise = p;
-            }
-        }
-        else {
-            const copiedItem = item;
-            promise = promise.then(() => {
-                return func(copiedItem);
-            });
-        }
-    }
-    if (isPromise(promise)) {
-        return markAsRuntimePromise(promise);
-    }
-    return promise;
-}
-//# sourceMappingURL=AuxRuntime.js.map