@casual-simulation/aux-common 3.1.8 → 3.1.9-alpha.3340590989

package/runtime/AuxRuntime.js

@@ -5,14 +5,23 @@
 // 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, } from '../bots';
 import { Subject, Subscription } from 'rxjs';
-import { AuxCompiler } from './AuxCompiler';
+import { AuxCompiler, getInterpretableFunction, isInterpretableFunction, } from './AuxCompiler';
 import { addToContext, MemoryGlobalContext, removeFromContext, isInContext, } from './AuxGlobalContext';
 import { createDefaultLibrary, } from './AuxLibrary';
 import { createRuntimeBot, RealtimeEditMode, } from './RuntimeBot';
 import { RanOutOfEnergyError } from './AuxResults';
-import { convertToCopiableValue, DeepObjectError, } from './Utils';
+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';
@@ -21,6 +30,41 @@ 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';
+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.
  *
@@ -33,11 +77,16 @@ export class AuxRuntime {
      * @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) {
+    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 = {
@@ -47,6 +96,8 @@ export class AuxRuntime {
         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 = [];
@@ -70,7 +121,8 @@ export class AuxRuntime {
         this._forceSyncScripts = false;
         this._currentDebugger = null;
         this._libraryFactory = libraryFactory;
-        this._globalContext = new MemoryGlobalContext(version, device, this, this);
+        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), {
@@ -86,6 +138,7 @@ export class AuxRuntime {
         this._exemptSpaces = exemptSpaces;
         this._onActions = new Subject();
         this._onErrors = new Subject();
+        this._onRuntimeStop = new Subject();
         let sub = (this._sub = new Subscription(() => {
             this._globalContext.cancelAllBotTimers();
         }));
@@ -137,6 +190,24 @@ export class AuxRuntime {
             },
         });
         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);
+                }
+            }
+        }
     }
     get forceSignedScripts() {
         return this._forceSignedScripts;
@@ -150,6 +221,9 @@ export class AuxRuntime {
     get globalObject() {
         return this._globalObject;
     }
+    get canTriggerBreakpoint() {
+        return !!this._interpreter && this._interpreter.debugging;
+    }
     getShoutTimers() {
         return {};
     }
@@ -196,6 +270,12 @@ export class AuxRuntime {
     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.
@@ -209,85 +289,408 @@ export class AuxRuntime {
         return this._currentDebugger;
     }
     _createDebugger(options) {
-        const runtime = new AuxRuntime(this._globalContext.version, this._globalContext.device, this._libraryFactory, this._editModeProvider, this._forceSignedScripts, this._exemptSpaces, !(options === null || options === void 0 ? void 0 : options.allowAsynchronousScripts));
-        runtime._autoBatch = false;
-        let idCount = 0;
-        if (!(options === null || options === void 0 ? void 0 : options.useRealUUIDs)) {
-            runtime._globalContext.uuid = () => {
-                idCount += 1;
-                return `uuid-${idCount}`;
+        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 = false;
+            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');
             };
-        }
-        let allActions = [];
-        let allErrors = [];
-        let create = runtime._library.tagSpecificApi.create({
-            bot: null,
-            config: null,
-            creator: null,
-            tag: null,
+            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;
+                }, 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: stop.stack.map((s) => {
+                                const callSite = s.callSite;
+                                const funcName = callSite.getFunctionName();
+                                let funcLocation = {};
+                                if (funcName) {
+                                    const f = runtime._functionMap.get(funcName);
+                                    if (f) {
+                                        funcLocation.name =
+                                            f.metadata.diagnosticFunctionName;
+                                        const location = runtime._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;
+                            }),
+                            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);
+                },
+                create });
+            runtime._currentDebugger = debug;
+            this._scheduleJobQueueCheck();
+            return debug;
         });
-        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 debug = Object.assign(Object.assign({}, runtime._library.api), { getAllActions, getCommonActions: () => {
-                return getAllActions().filter(isCommonAction);
-            }, getBotActions: () => {
-                return getAllActions().filter((a) => !isCommonAction(a));
-            }, getErrors: () => {
-                const errors = runtime._processUnbatchedErrors();
-                allErrors.push(...errors);
-                return allErrors;
-            }, create });
-        runtime._currentDebugger = debug;
-        return debug;
     }
     _processCore(actions) {
-        for (let action of actions) {
-            let { rejected, newActions } = this._rejectAction(action);
-            for (let newAction of newActions) {
-                this._processAction(newAction);
+        const _this = this;
+        function handleRejection(action, rejection) {
+            let promise = processListOfMaybePromises(null, rejection.newActions, (action) => {
+                return _this._processAction(action);
+            });
+            if (rejection.rejected) {
+                return;
             }
-            if (rejected) {
-                continue;
+            if (promise) {
+                return markAsRuntimePromise(promise.then((p) => _this._processAction(action)));
+            }
+            else {
+                return _this._processAction(action);
             }
-            this._processAction(action);
         }
+        return processListOfMaybePromises(null, actions, (action) => {
+            let rejection = this._rejectAction(action);
+            if (isRuntimePromise(rejection)) {
+                return markAsRuntimePromise(rejection.then((result) => handleRejection(action, result)));
+            }
+            else {
+                return handleRejection(action, rejection);
+            }
+        });
     }
     _processAction(action) {
         if (action.type === 'action') {
             const result = this._shout(action.eventName, action.botIds, action.argument, false);
-            this._processCore(result.actions);
+            if (isRuntimePromise(result)) {
+                return markAsRuntimePromise(result.then((result) => this._processCore(result.actions)));
+            }
+            else {
+                return this._processCore(result.actions);
+            }
         }
         else if (action.type === 'run_script') {
             const result = this._execute(action.script, false, false);
-            this._processCore(result.actions);
-            if (hasValue(action.taskId)) {
-                this._globalContext.resolveTask(action.taskId, result.result, 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);
+                            }
+                        });
+                    }
+                    else {
+                        if (hasValue(action.taskId)) {
+                            if (this._globalContext.resolveTask(action.taskId, result.result, false)) {
+                                this._scheduleJobQueueCheck();
+                            }
+                        }
+                    }
+                }));
+            }
+            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();
+                            }
+                        }
+                    }));
+                }
+                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);
-            this._processCore(events);
+            return this._processCore(events);
         }
         else if (action.type === 'async_result') {
             const value = action.mapBotsInResult === true
@@ -296,21 +699,33 @@ export class AuxRuntime {
             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);
@@ -330,7 +745,7 @@ export class AuxRuntime {
                 this._actionBatch.push(action);
             }
             if (hasValue(action.taskId)) {
-                this._processCore([asyncResult(action.taskId, null)]);
+                return this._processCore([asyncResult(action.taskId, null)]);
             }
         }
         else {
@@ -342,35 +757,76 @@ export class AuxRuntime {
         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: () => {
-                    const botId = this._portalBots.get(portalId);
-                    if (hasValue(botId)) {
-                        return this.context.state[botId];
-                    }
-                    else {
-                        return undefined;
-                    }
-                },
+                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);
-        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;
+        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 { rejected, newActions: result.actions };
+        return (this._currentPromise = func());
     }
     /**
      * Executes a shout with the given event name on the given bot IDs with the given argument.
@@ -380,25 +836,64 @@ export class AuxRuntime {
      * @param arg The argument to include in the shout.
      */
     shout(eventName, botIds, arg) {
-        return this._shout(eventName, botIds, arg, true);
+        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, actions, errors } = this._batchScriptResults(() => {
-            const results = hasValue(botIds)
-                ? this._library.api.whisper(botIds, eventName, arg)
-                : this._library.api.shout(eventName, arg);
-            return results;
+        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,
-            errors,
-            results: result,
+            actions: result.actions,
+            errors: result.errors,
+            results: result.result,
             listeners: [],
         };
     }
@@ -407,7 +902,9 @@ export class AuxRuntime {
      * @param script The script to run.
      */
     execute(script) {
-        return this._execute(script, true, true);
+        return this._wrapWithCurrentPromise(() => {
+            return this._execute(script, true, true);
+        });
     }
     _execute(script, batch, resetEnergy) {
         let fn;
@@ -491,8 +988,8 @@ export class AuxRuntime {
     _sendOnBotsAddedShouts(newBots, nextUpdate) {
         if (newBots && nextUpdate.addedBots.length > 0) {
             try {
-                this._shout(ON_BOT_ADDED_ACTION_NAME, nextUpdate.addedBots, undefined, true, false);
-                this._shout(ON_ANY_BOTS_ADDED_ACTION_NAME, null, {
+                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);
             }
@@ -509,15 +1006,47 @@ export class AuxRuntime {
     _sendOnBotsRemovedShouts(botIds) {
         if (botIds.length > 0) {
             try {
+                let promise;
                 for (let bot of botIds) {
                     const watchers = this._globalContext.getWatchersForBot(bot);
-                    for (let watcher of watchers) {
-                        watcher.handler();
+                    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);
+                            }
+                        }));
                     }
                 }
-                this._shout(ON_ANY_BOTS_REMOVED_ACTION_NAME, null, {
-                    botIDs: botIds,
-                }, true, false);
             }
             catch (err) {
                 if (!(err instanceof RanOutOfEnergyError)) {
@@ -532,19 +1061,52 @@ export class AuxRuntime {
     _sendOnBotsChangedShouts(updates) {
         if (updates && updates.length > 0) {
             try {
-                for (let update of updates) {
+                let promise = processListOfMaybePromises(null, updates, (update) => {
                     if (!update) {
-                        continue;
+                        return;
                     }
-                    this._shout(ON_BOT_CHANGED_ACTION_NAME, [update.bot.id], {
+                    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);
-                    for (let watcher of watchers) {
-                        watcher.handler();
+                    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;
                     }
                 }
-                this._shout(ON_ANY_BOTS_CHANGED_ACTION_NAME, null, updates, true, false);
             }
             catch (err) {
                 if (!(err instanceof RanOutOfEnergyError)) {
@@ -573,7 +1135,7 @@ export class AuxRuntime {
         if (!userBot) {
             return;
         }
-        for (let portal of portals) {
+        return processListOfMaybePromises(null, portals, (portal) => {
             const dimension = userBot.values[portal];
             let hasChange = false;
             if (hasValue(dimension)) {
@@ -617,11 +1179,14 @@ export class AuxRuntime {
             }
             if (hasChange) {
                 const watchers = this._globalContext.getWatchersForPortal(portal);
-                for (let watcher of watchers) {
-                    watcher.handler();
-                }
+                return processListOfMaybePromises(null, watchers, (watcher) => {
+                    const generator = watcher.handler();
+                    if (isGenerator(generator)) {
+                        return this._processGenerator(generator);
+                    }
+                });
             }
-        }
+        });
     }
     _addBotsToState(bots, nextUpdate) {
         let newBots = [];
@@ -679,6 +1244,10 @@ export class AuxRuntime {
             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];
@@ -800,6 +1369,25 @@ export class AuxRuntime {
                 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 = {};
@@ -829,6 +1417,12 @@ export class AuxRuntime {
     notifyChange() {
         if (!this._batchPending && this._autoBatch) {
             this._batchPending = true;
+            if (this.canTriggerBreakpoint) {
+                this._scheduleJob('notifyChange', () => {
+                    this._processBatch();
+                });
+                return;
+            }
             queueMicrotask(() => {
                 this._processBatch();
             });
@@ -901,12 +1495,22 @@ export class AuxRuntime {
         }
     }
     _batchScriptResults(callback, batch, resetEnergy) {
-        const results = this._calculateScriptResults(callback, 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(...results.actions);
+            this._actionBatch.push(...result.actions);
         }
-        this._errorBatch.push(...results.errors);
-        return results;
+        this._errorBatch.push(...result.errors);
+        return result;
     }
     _calculateScriptResults(callback, resetEnergy) {
         this._globalContext.playerBot = this.userBot;
@@ -914,6 +1518,17 @@ export class AuxRuntime {
             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 {
@@ -994,6 +1609,7 @@ export class AuxRuntime {
             script: null,
             originalTagEditValues: {},
             originalTagMaskEditValues: {},
+            breakpoints: [],
         };
         if (BOT_SPACE_TAG in bot) {
             compiledBot.space = bot.space;
@@ -1211,7 +1827,16 @@ export class AuxRuntime {
                 delete bot.originalTagEditValues[tag];
             }
             if (hasValue(tagValue)) {
-                bot.tags[tag] = 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];
@@ -1315,12 +1940,22 @@ export class AuxRuntime {
             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,
@@ -1335,8 +1970,8 @@ export class AuxRuntime {
                 const data = this._handleError(err, ctx.bot, ctx.tag);
                 throw data;
             },
-            constants: Object.assign(Object.assign({}, this._library.api), { tagName: tag, globalThis: this._globalObject }),
-            variables: Object.assign(Object.assign({}, this._library.tagSpecificApi), { 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) }),
+            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)) {
@@ -1477,5 +2112,228 @@ export class AuxRuntime {
         }
         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() {
+        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