@casual-simulation/aux-common 3.1.16 → 3.1.19

package/runtime/AuxRuntime.js

@@ -14,13 +14,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 { 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, 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 { RanOutOfEnergyError, } from './AuxResults';
 import { convertToCopiableValue, DeepObjectError, isPromise, isRuntimePromise, markAsRuntimePromise, } from './Utils';
 import { DefaultRealtimeEditModeProvider, } from './AuxRealtimeEditModeProvider';
 import { sortBy, forOwn, merge, union } from 'lodash';
@@ -33,6 +33,7 @@ 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;
@@ -102,6 +103,16 @@ export class AuxRuntime {
         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.
          */
@@ -281,9 +292,22 @@ export class AuxRuntime {
      * @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();
-        this._processCore(actions);
+        const result = this._processCore(actions);
         this._processBatch();
+        return result;
     }
     _getExecutingDebugger() {
         return this._currentDebugger;
@@ -296,7 +320,7 @@ export class AuxRuntime {
             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;
+            runtime._autoBatch = true;
             let idCount = 0;
             if (!(options === null || options === void 0 ? void 0 : options.useRealUUIDs)) {
                 runtime._globalContext.uuid = () => {
@@ -381,7 +405,38 @@ export class AuxRuntime {
                     const errors = runtime._processUnbatchedErrors();
                     allErrors.push(...errors);
                     return allErrors;
-                }, setPauseTrigger(b, tag, options) {
+                }, 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({
@@ -485,113 +540,7 @@ export class AuxRuntime {
                         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;
-                            }),
+                            callStack: runtime._mapCallStack(stop.stack),
                             trigger: {
                                 triggerId: stop.breakpoint.id,
                                 botId: stop.breakpoint.botId,
@@ -610,46 +559,193 @@ export class AuxRuntime {
                 [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 _this._processAction(action);
+                return processAction(action, false);
             });
             if (rejection.rejected) {
                 return;
             }
             if (promise) {
-                return markAsRuntimePromise(promise.then((p) => _this._processAction(action)));
+                return markAsRuntimePromise(promise.then((p) => processAction(action, true)));
             }
             else {
-                return _this._processAction(action);
+                return processAction(action, true);
             }
         }
-        return processListOfMaybePromises(null, actions, (action) => {
+        let promise = processListOfMaybePromises(null, actions, (action) => {
             let rejection = this._rejectAction(action);
+            let result;
             if (isRuntimePromise(rejection)) {
-                return markAsRuntimePromise(rejection.then((result) => handleRejection(action, result)));
+                result = markAsRuntimePromise(rejection.then((result) => handleRejection(action, result)));
             }
             else {
-                return handleRejection(action, rejection);
+                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)));
+                return markAsRuntimePromise(result
+                    .then((result) => this._processCore(result.actions))
+                    .then(() => result));
             }
             else {
-                return this._processCore(result.actions);
+                let promise = this._processCore(result.actions);
+                if (isRuntimePromise(promise)) {
+                    return markAsRuntimePromise(promise.then(() => result));
+                }
+                else {
+                    return result;
+                }
             }
         }
         else if (action.type === 'run_script') {
@@ -662,6 +758,7 @@ export class AuxRuntime {
                             if (hasValue(action.taskId)) {
                                 this._globalContext.resolveTask(action.taskId, result.result, false);
                             }
+                            return null;
                         });
                     }
                     else {
@@ -671,6 +768,7 @@ export class AuxRuntime {
                             }
                         }
                     }
+                    return null;
                 }));
             }
             else {
@@ -682,6 +780,7 @@ export class AuxRuntime {
                                 this._scheduleJobQueueCheck();
                             }
                         }
+                        return null;
                     }));
                 }
                 if (hasValue(action.taskId)) {
@@ -693,7 +792,13 @@ export class AuxRuntime {
         }
         else if (action.type === 'apply_state') {
             const events = breakIntoIndividualEvents(this.currentState, action);
-            return this._processCore(events);
+            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
@@ -752,12 +857,21 @@ export class AuxRuntime {
                 this._actionBatch.push(action);
             }
             if (hasValue(action.taskId)) {
-                return this._processCore([asyncResult(action.taskId, null)]);
+                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);
@@ -1211,7 +1325,7 @@ export class AuxRuntime {
             }
             let newBot = this._createCompiledBot(bot, false);
             if (!!existing) {
-                newBot.script.vars = existing.script.vars;
+                existing.script[REPLACE_BOT_SYMBOL](newBot.script);
             }
             let precalculated = {
                 id: bot.id,
@@ -1435,6 +1549,18 @@ export class AuxRuntime {
             });
         }
     }
+    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);
@@ -1673,6 +1799,7 @@ export class AuxRuntime {
         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) {
@@ -1689,6 +1816,21 @@ export class AuxRuntime {
         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,
@@ -1704,6 +1846,7 @@ export class AuxRuntime {
         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);
@@ -1714,6 +1857,7 @@ export class AuxRuntime {
                 if (!bot.masks[space]) {
                     bot.masks[space] = {};
                 }
+                let oldValue = bot.masks[space][tag];
                 if (isTagEdit(value)) {
                     if (!bot.originalTagMaskEditValues[space]) {
                         bot.originalTagMaskEditValues[space] = {};
@@ -1728,6 +1872,10 @@ export class AuxRuntime {
                     bot.masks[space][tag] = value;
                 }
                 updated = true;
+                oldValuesAndSpaces.push({
+                    space,
+                    oldValue,
+                });
             }
         }
         if (updated) {
@@ -1744,6 +1892,24 @@ export class AuxRuntime {
         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,
@@ -1979,6 +2145,20 @@ export class AuxRuntime {
                 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);
@@ -2087,6 +2267,11 @@ export class AuxRuntime {
             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) &&
@@ -2220,6 +2405,46 @@ export class AuxRuntime {
     //     });
     // }
     _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();