@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/subsystems/scripting/ScriptEngine.js

@@ -1,1074 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "All your base are belong to us." - Zero Wing (1989)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-// and associated documentation files (the “Software”), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial
-// portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// -----------------------------------------------------------------------------------------------------------
-import LuaModule from './wasm/lua.browser.js';
-import LuaWasm from './wasm/lua.wasm';
-import * as msgpack from '@msgpack/msgpack';
-import moduleTemplate from './lualibs/moduleTemplate.lua';
-import eventHooksCode from './lualibs/eventhooks.lua';
-import lua_api_coroutine from "./lualibs/api/_coroutine.lua";
-import lua_api_internal from "./lualibs/api/_internal.lua";
-import lua_api_audio from "./lualibs/api/audio.lua";
-import lua_api_canvas from "./lualibs/api/canvas.lua";
-import lua_api_class from "./lualibs/api/class.lua";
-import lua_api_console from "./lualibs/api/console.lua";
-import lua_api_controllers from "./lualibs/api/controllers.lua";
-import lua_api_composer from './lualibs/api/composer.lua';
-import lua_api_data from "./lualibs/api/data.lua";
-import lua_api_data_color from "./lualibs/api/data/color.lua";
-import lua_api_data_list from "./lualibs/api/data/list.lua";
-import lua_api_data_set from "./lualibs/api/data/set.lua";
-import lua_api_datetime from "./lualibs/api/datetime.lua";
-import lua_api_entity from "./lualibs/api/behaviour.lua";
-import lua_api_events from './lualibs/api/events.lua';
-import lua_api_handle from "./lualibs/api/handle.lua";
-import lua_api_imgui from "./lualibs/api/imgui.lua";
-import lua_api_item from './lualibs/api/item.lua';
-import lua_api_items_material from './lualibs/api/items/material.lua';
-import lua_api_items_canvastexture from './lualibs/api/items/canvastexture.lua';
-import lua_api_items_font from './lualibs/api/items/font.lua';
-import lua_api_items_gridmap from './lualibs/api/items/gridmap.lua';
-import lua_api_items_mesh from './lualibs/api/items/mesh.lua';
-import lua_api_items_prefab from './lualibs/api/items/prefab.lua';
-import lua_api_items_texture from './lualibs/api/items/texture.lua';
-import lua_api_items_video from './lualibs/api/items/video.lua';
-import lua_api_json from "./lualibs/api/json.lua";
-import lua_api_json_jsondecoder from "./lualibs/api/json/jsondecoder.lua";
-import lua_api_json_jsonencoder from "./lualibs/api/json/jsonencoder.lua";
-import lua_api_keys from './lualibs/api/keys.lua';
-import lua_api_loader from './lualibs/api/loader.lua';
-import lua_api_math from "./lualibs/api/math.lua";
-import lua_api_math_complex from "./lualibs/api/math/complex.lua";
-import lua_api_math_matrix from "./lualibs/api/math/matrix.lua";
-import lua_api_math_quaternion from "./lualibs/api/math/quaternion.lua";
-import lua_api_math_transform from "./lualibs/api/math/transform.lua";
-import lua_api_math_vector2 from "./lualibs/api/math/vector2.lua";
-import lua_api_math_vector3 from "./lualibs/api/math/vector3.lua";
-import lua_api_math_vector4 from "./lualibs/api/math/vector4.lua";
-import lua_api_msgpack from "./lualibs/api/msgpack.lua";
-import lua_api_object from "./lualibs/api/object.lua";
-import lua_api_physics from "./lualibs/api/physics.lua";
-import lua_api_pointer from "./lualibs/api/pointer.lua";
-import lua_api_project from "./lualibs/api/project.lua";
-import lua_api_promise from "./lualibs/api/promise.lua";
-import lua_api_property from "./lualibs/api/property.lua";
-import lua_api_renderer from "./lualibs/api/renderer.lua";
-import lua_api_sceneentry from "./lualibs/api/sceneentry.lua";
-import lua_api_sceneobject from "./lualibs/api/sceneobject.lua";
-import lua_api_sceneobjects_audio from "./lualibs/api/sceneobjects/audio.lua";
-import lua_api_sceneobjects_audiolistener from "./lualibs/api/sceneobjects/audiolistener.lua";
-import lua_api_sceneobjects_billboard from "./lualibs/api/sceneobjects/billboard.lua";
-import lua_api_sceneobjects_box from "./lualibs/api/sceneobjects/box.lua";
-import lua_api_sceneobjects_camera from "./lualibs/api/sceneobjects/camera.lua";
-import lua_api_sceneobjects_circleshadow from "./lualibs/api/sceneobjects/circleshadow.lua";
-import lua_api_sceneobjects_cone from "./lualibs/api/sceneobjects/cone.lua";
-import lua_api_sceneobjects_cylinder from "./lualibs/api/sceneobjects/cylinder.lua";
-import lua_api_sceneobjects_gaussiansplats from "./lualibs/api/sceneobjects/gaussiansplats.lua";
-import lua_api_sceneobjects_gridmap from "./lualibs/api/sceneobjects/gridmap.lua";
-import lua_api_sceneobjects_group from "./lualibs/api/sceneobjects/group.lua";
-import lua_api_sceneobjects_lightsource from "./lualibs/api/sceneobjects/lightsource.lua";
-import lua_api_sceneobjects_mesh from "./lualibs/api/sceneobjects/mesh.lua";
-import lua_api_sceneobjects_navmesh from "./lualibs/api/sceneobjects/navmesh.lua";
-import lua_api_sceneobjects_plane from "./lualibs/api/sceneobjects/plane.lua";
-import lua_api_sceneobjects_points from "./lualibs/api/sceneobjects/points.lua";
-import lua_api_sceneobjects_positionalaudio from "./lualibs/api/sceneobjects/positionalaudio.lua";
-import lua_api_sceneobjects_prefab from "./lualibs/api/sceneobjects/prefab.lua";
-import lua_api_sceneobjects_ribbon from "./lualibs/api/sceneobjects/ribbon.lua";
-import lua_api_sceneobjects_ring from "./lualibs/api/sceneobjects/ring.lua";
-import lua_api_sceneobjects_scene from "./lualibs/api/sceneobjects/scene.lua";
-import lua_api_sceneobjects_scriptedmesh from './lualibs/api/sceneobjects/scriptedmesh.lua';
-import lua_api_sceneobjects_sky from "./lualibs/api/sceneobjects/sky.lua";
-import lua_api_sceneobjects_sphere from "./lualibs/api/sceneobjects/sphere.lua";
-import lua_api_sceneobjects_text from "./lualibs/api/sceneobjects/text.lua";
-import lua_api_sceneobjects_torus from "./lualibs/api/sceneobjects/torus.lua";
-import lua_api_sceneobjects_vehicle from "./lualibs/api/sceneobjects/vehicle.lua";
-import lua_api_sceneobjects_particles from "./lualibs/api/sceneobjects/particles.lua";
-import lua_api_storage from "./lualibs/api/storage.lua";
-import lua_api_system from "./lualibs/api/system.lua";
-import lua_api_tools from "./lualibs/api/tools.lua";
-import lua_api_variables from "./lualibs/api/variables.lua";
-import { LoaderException } from '@luminocity/lemonate-gateway';
-import { ScriptRuntime } from './ScriptRuntime';
-import tools from "../../Tools.js";
-const SE_DEBUG_LOG = false;
-export class ScriptEngine {
-    engine;
-    itemRepo;
-    lua = undefined;
-    initialized = false;
-    scriptRunners = new Map();
-    scripts = new Map();
-    eventListeners = new Map();
-    scriptRuntimeData;
-    scriptRuntime;
-    breakpointsMap = {};
-    // Library importing
-    // -------------------------------------------------------------------------------------------------
-    importedLibsPromises = {}; // stores any promises of importing libs so we don't need to import things twice
-    importedLibsMap = {};
-    // we lack the scriptId in JS_requireModule, so we keep track of the path<->scriptId pairs here
-    importedLibPathMap = {};
-    funcExistsMap = {};
-    scriptLocOffsets = {};
-    moduleTemplateCodeLineOffset = 0;
-    promises = new Map();
-    libs = {
-        "engine/_coroutine": lua_api_coroutine,
-        "engine/_internal": lua_api_internal,
-        "engine/audio": lua_api_audio,
-        "engine/canvas": lua_api_canvas,
-        "engine/class": lua_api_class,
-        "engine/console": lua_api_console,
-        "engine/controllers": lua_api_controllers,
-        "engine/composer": lua_api_composer,
-        "engine/data": lua_api_data,
-        "engine/data/color": lua_api_data_color,
-        "engine/data/set": lua_api_data_set,
-        "engine/data/list": lua_api_data_list,
-        "engine/datetime": lua_api_datetime,
-        "engine/entity": lua_api_entity,
-        "engine/events": lua_api_events,
-        "engine/handle": lua_api_handle,
-        "engine/imgui": lua_api_imgui,
-        "engine/item": lua_api_item,
-        "engine/items/material": lua_api_items_material,
-        "engine/items/canvastexture": lua_api_items_canvastexture,
-        "engine/items/font": lua_api_items_font,
-        "engine/items/gridmap": lua_api_items_gridmap,
-        "engine/items/mesh": lua_api_items_mesh,
-        "engine/items/prefab": lua_api_items_prefab,
-        "engine/items/texture": lua_api_items_texture,
-        "engine/items/video": lua_api_items_video,
-        "engine/json": lua_api_json,
-        "engine/json/jsonencoder": lua_api_json_jsonencoder,
-        "engine/json/jsondecoder": lua_api_json_jsondecoder,
-        "engine/keys": lua_api_keys,
-        "engine/loader": lua_api_loader,
-        "engine/math": lua_api_math,
-        "engine/math/vector2": lua_api_math_vector2,
-        "engine/math/vector3": lua_api_math_vector3,
-        "engine/math/vector4": lua_api_math_vector4,
-        "engine/math/quaternion": lua_api_math_quaternion,
-        "engine/math/transform": lua_api_math_transform,
-        "engine/math/matrix": lua_api_math_matrix,
-        "engine/math/complex": lua_api_math_complex,
-        "engine/msgpack": lua_api_msgpack,
-        "engine/object": lua_api_object,
-        "engine/physics": lua_api_physics,
-        "engine/pointer": lua_api_pointer,
-        "engine/project": lua_api_project,
-        "engine/promise": lua_api_promise,
-        "engine/property": lua_api_property,
-        "engine/renderer": lua_api_renderer,
-        "engine/sceneentry": lua_api_sceneentry,
-        "engine/sceneobject": lua_api_sceneobject,
-        "engine/sceneobjects/sgaudio": lua_api_sceneobjects_audio,
-        "engine/sceneobjects/sgaudiolistener": lua_api_sceneobjects_audiolistener,
-        "engine/sceneobjects/sgbillboard": lua_api_sceneobjects_billboard,
-        "engine/sceneobjects/sgbox": lua_api_sceneobjects_box,
-        "engine/sceneobjects/sgcamera": lua_api_sceneobjects_camera,
-        "engine/sceneobjects/sgcircleshadow": lua_api_sceneobjects_circleshadow,
-        "engine/sceneobjects/sgcone": lua_api_sceneobjects_cone,
-        "engine/sceneobjects/sgcylinder": lua_api_sceneobjects_cylinder,
-        "engine/sceneobjects/sggaussiansplats": lua_api_sceneobjects_gaussiansplats,
-        "engine/sceneobjects/sggridmap": lua_api_sceneobjects_gridmap,
-        "engine/sceneobjects/sggroup": lua_api_sceneobjects_group,
-        "engine/sceneobjects/sglightsource": lua_api_sceneobjects_lightsource,
-        "engine/sceneobjects/sgnavmesh": lua_api_sceneobjects_navmesh,
-        "engine/sceneobjects/sgmesh": lua_api_sceneobjects_mesh,
-        "engine/sceneobjects/sgplane": lua_api_sceneobjects_plane,
-        "engine/sceneobjects/sgpoints": lua_api_sceneobjects_points,
-        "engine/sceneobjects/sgpositionalaudio": lua_api_sceneobjects_positionalaudio,
-        "engine/sceneobjects/sgprefab": lua_api_sceneobjects_prefab,
-        "engine/sceneobjects/sgribbon": lua_api_sceneobjects_ribbon,
-        "engine/sceneobjects/sgring": lua_api_sceneobjects_ring,
-        "engine/sceneobjects/sgscene": lua_api_sceneobjects_scene,
-        "engine/sceneobjects/sgscriptedmesh": lua_api_sceneobjects_scriptedmesh,
-        "engine/sceneobjects/sgsky": lua_api_sceneobjects_sky,
-        "engine/sceneobjects/sgsphere": lua_api_sceneobjects_sphere,
-        "engine/sceneobjects/sgtext": lua_api_sceneobjects_text,
-        "engine/sceneobjects/sgtorus": lua_api_sceneobjects_torus,
-        "engine/sceneobjects/sgvehicle": lua_api_sceneobjects_vehicle,
-        "engine/sceneobjects/sgparticles": lua_api_sceneobjects_particles,
-        "engine/storage": lua_api_storage,
-        "engine/system": lua_api_system,
-        "engine/tools": lua_api_tools,
-        "engine/variables": lua_api_variables
-    };
-    api = {};
-    constructor(engine) {
-        this.engine = engine;
-        this.itemRepo = this.engine.itemRepo;
-        this.scriptRuntimeData = {
-            engine: this.engine,
-            scriptEngine: null
-        };
-        this.scriptRuntimeData.scriptEngine = this;
-        this.scriptRuntime = new ScriptRuntime(this.scriptRuntimeData);
-        this.moduleTemplateCodeLineOffset = this._calculateModuleTemplateCodeLineOffset();
-        this.api.JS_requireModule = (modname) => {
-            try {
-                const script = this.libs[modname];
-                if (script)
-                    return script;
-                const scriptId = this.importedLibPathMap[modname];
-                if (!scriptId) {
-                    console.error(`Could not resolve script path '${modname}' to item Id.`);
-                    return "";
-                }
-                const importedScript = this.importedLibsMap[scriptId];
-                if (importedScript)
-                    return importedScript;
-                console.error(`Script with Id '${scriptId}' for module '${modname}' not found. Maybe it failed to load previously!`);
-                return "";
-            }
-            catch (err) {
-                console.error("Error in JS_requireModule: ", err);
-                return "";
-            }
-        };
-    }
-    handlePromise(handle, promise) {
-        this.promises.set(handle, { promise: promise, reject: undefined, resolve: undefined });
-        promise.then((value) => {
-            // check if the promises map is empty. if so, the execution has stopped and we should omit the result
-            if (this.promises.size) {
-                this.callFunc("__promise", this.packMessage({
-                    type: "resolved",
-                    _handle: handle,
-                    value: value
-                }), false);
-            }
-            this.clearPromise(handle);
-            return value;
-        }).catch((err) => {
-            console.error(err);
-            // check if the promises map is empty. if so, the execution has stopped and we should omit the result
-            if (this.promises.size) {
-                this.callFunc("__promise", this.packMessage({
-                    type: "rejected",
-                    _handle: handle,
-                    error: err.toString()
-                }), false);
-            }
-            this.clearPromise(handle);
-        });
-    }
-    clearPromise(handle) {
-        this.promises.delete(handle);
-    }
-    message(target, payload, buffers, scriptId) {
-        let result;
-        result = this.getScriptRuntime().sendMessage(target, payload, buffers, scriptId);
-        // in case the function returned a promise, return a handle instead and wait for the promise in JS and trigger
-        // Lua with the result later
-        if (result instanceof Promise) {
-            const handle = tools.createGUID();
-            this.handlePromise(handle, result);
-            result = handle;
-        }
-        return result;
-    }
-    resetPromises() {
-        this.promises = new Map();
-    }
-    _debugLog(msg, ...args) {
-        if (!SE_DEBUG_LOG)
-            return;
-        console.log(`[SE] ${msg}`, ...args);
-    }
-    _debugErr(err, ...args) {
-        if (!SE_DEBUG_LOG)
-            return;
-        console.error(`[SE] ${err}`, ...args);
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        const lua = await LuaModule({
-            locateFile: () => {
-                return LuaWasm;
-            },
-            print: (msg) => {
-                const offsetMsg = this.correctScriptLocs(msg);
-                console.log(`[LUA]: ${offsetMsg}`);
-            },
-            printErr: (error) => {
-                const offsetError = this.correctScriptLocs(error);
-                //@ts-ignore
-                if (console.noTraceError) {
-                    //@ts-ignore
-                    console.noTraceError(`[LUA]: ${offsetError}`);
-                }
-                else
-                    console.log(`[LUA ERROR]: ${offsetError}`);
-            }
-        });
-        for (const func in this.api) {
-            lua[func] = this.api[func];
-        }
-        this.lua = lua;
-        this.resetScriptEngineState();
-        console.log("Scripting initialized");
-        this.initialized = true;
-        //this.doPerformanceTests();
-        return lua;
-    }
-    doPerformanceTests() {
-        /*
-        setInterval(() => {
-          console.log("WASM memory size:", lua.HEAPU8?.buffer.byteLength / 1024, "KB");
-        }, 1000);
-        */
-        /*
-        setInterval(() => {
-          const time = Date.now();
-          queueMicrotask(() => {
-            const interval = Date.now() - time;
-            console.log("Time to run microtask: " + interval);
-          });
-        }, 1000);
-        */
-        /*
-        setInterval(() => {
-          this.callFunc("__testmemory");
-        }, 1000);
-        */
-        /*
-        setTimeout(() => {
-          this.callFunc("__testperformance");
-        }, 1000);
-        */
-        {
-            const startTime = Date.now();
-            let calls = 0;
-            while (Date.now() < startTime + 1000) {
-                this.callFunc("__testperformance");
-                calls++;
-            }
-            console.log(`Lua Performance Test: ${calls} function calls were made.`);
-        }
-        {
-            const scriptItemId = "testId";
-            let result = this.lua.scriptitem_create(scriptItemId, "local Pointer = require 'engine/pointer'\n" +
-                "local e = {}\n" +
-                "function e:new()\n" +
-                "  return self\n" +
-                "end\n" +
-                "function e:testMethod()\n" +
-                "  Pointer.isLocked()\n" +
-                "end\n" +
-                "return e", 0, "testscript");
-            if (result !== 0) {
-                throw new Error("Script item could not be created!");
-            }
-            const scriptId = this.lua.script_create();
-            result = this.lua.script_load(scriptId, scriptItemId);
-            if (result !== 0) {
-                throw new Error("Script could not be created!");
-            }
-            const startTime = Date.now();
-            let calls = 0;
-            while (Date.now() < startTime + 1000) {
-                this.callMethod(scriptId, "testMethod");
-                calls++;
-            }
-            console.log(`Lua Performance Test: ${calls} method calls were made.`);
-            this.lua.script_delete(scriptId);
-            this.lua.scriptitem_delete(scriptItemId);
-        }
-    }
-    _createBuffer(size) {
-        const ptr = this.lua.buffer_create(size);
-        return { ptr: ptr, array: new Uint8Array(this.lua.HEAPU8.buffer, ptr, size), size: size };
-    }
-    _freeBuffer(buffer) {
-        if (buffer && buffer.ptr) {
-            this.lua.buffer_free(buffer.ptr);
-            buffer.ptr = null;
-        }
-    }
-    getScriptRuntime() {
-        return this.scriptRuntime;
-    }
-    getScriptRuntimeData() {
-        return this.scriptRuntimeData;
-    }
-    resetScriptEngineState() {
-        this.lua.script_engine_shutdown();
-        if (this.lua.script_engine_init(eventHooksCode) !== 0)
-            throw new Error("Script engine could not create a state!");
-    }
-    tick(deltaTimeMs) {
-        const payload = this.packMessage(deltaTimeMs);
-        return this.callFunc("__tick", payload);
-    }
-    packMessage(data) {
-        return msgpack.encode(data);
-    }
-    unpackMessage(data) {
-        return msgpack.decode(data);
-    }
-    reset() {
-        this.eventListeners.clear();
-        // This will clear any allocated buffers from the script engine
-        this.lua.script_engine_clear();
-        // make sure we clear all imports to force Lua to fetch the code again. it might have changed
-        this.lua.script_engine_clear_imports();
-        // dispose any objects the runtime might hold
-        this.scriptRuntime.dispose();
-        // clear all promises so no jumps into code will be made
-        this.resetPromises();
-        // dispose behaviours and initialize
-        this.callFunc("__clearBehaviours");
-        this.callFunc("__init");
-    }
-    async waitForLua() {
-        const _this = this;
-        return new Promise((resolve, reject) => {
-            if (_this.initialized)
-                resolve();
-            const handle = setInterval(function () {
-                if (_this.initialized) {
-                    clearInterval(handle);
-                    resolve();
-                }
-            }, 100);
-        });
-    }
-    destroy() {
-        if (!this.initialized)
-            return;
-        this.lua.script_engine_shutdown();
-        this.initialized = false;
-        this.lua = null;
-    }
-    debuggerEnable() {
-        this.lua.debugger_enable();
-    }
-    debuggerDisable() {
-        this.lua.debugger_disable();
-    }
-    debuggerContinue() {
-        this.engine.profiler.logCall('LUA debugger continue', () => {
-            try {
-                this.engine.player.resume(true);
-                const result = this.lua.debugger_continue();
-                this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine debugger continue error: `, err);
-            }
-        });
-    }
-    debuggerStepOver() {
-        this.engine.profiler.logCall('LUA debugger step over', () => {
-            try {
-                this.engine.player.resume(true);
-                const result = this.lua.debugger_step_over();
-                this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine debugger continue error: `, err);
-            }
-        });
-    }
-    debuggerStepInto() {
-        this.engine.profiler.logCall('LUA debugger step into', () => {
-            try {
-                this.engine.player.resume(true);
-                const result = this.lua.debugger_step_into();
-                this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine debugger step into error: `, err);
-            }
-        });
-    }
-    debuggerCaptureLocals(path, levels) {
-        const locals = this.lua.debugger_capture_locals(path || "", levels || 1);
-        this.engine.eventBus.$emit(path ? "player:localsPathed" : "player:localsGlobal", locals);
-        return locals;
-    }
-    debuggerCaptureUpvals(path, levels) {
-        const upvals = this.lua.debugger_capture_upvals(path || "", levels || 1);
-        this.engine.eventBus.$emit(path ? "player:upvalsPathed" : "player:upvalsGlobal", upvals);
-        return upvals;
-    }
-    debuggerCaptureTraceback() {
-        try {
-            return this.lua.debugger_capture_traceback() || "";
-        }
-        catch (err) {
-            console.error(err);
-            return null;
-        }
-    }
-    delete(scriptId) {
-        this.lua.script_delete(scriptId);
-        this.scriptRunners.delete(scriptId);
-        for (const listenersMap of this.eventListeners.values()) {
-            const listenerIdsToDelete = [];
-            // find all listener IDs that belong to the script being deleted
-            for (const [listenerId, listenerData] of listenersMap.entries()) {
-                if (listenerData.scriptId === scriptId) {
-                    listenerIdsToDelete.push(listenerId);
-                }
-            }
-            for (const listenerId of listenerIdsToDelete) {
-                listenersMap.delete(listenerId);
-            }
-        }
-    }
-    functionExists(scriptId, modname) {
-        if (!this.funcExistsMap[scriptId]) {
-            this.funcExistsMap[scriptId] = {};
-        }
-        let exists = this.funcExistsMap[scriptId][modname];
-        if (exists === undefined) {
-            exists = this.lua.script_function_exists(scriptId, modname);
-            this.funcExistsMap[scriptId][modname] = exists;
-        }
-        return exists;
-    }
-    methodExists(scriptId, modname) {
-        if (!this.funcExistsMap[scriptId]) {
-            this.funcExistsMap[scriptId] = {};
-        }
-        let exists = this.funcExistsMap[scriptId][modname];
-        if (exists === undefined) {
-            exists = this.lua.script_method_exists(scriptId, modname);
-            this.funcExistsMap[scriptId][modname] = exists;
-        }
-        return exists;
-    }
-    _payloadToBuffer(payload = undefined) {
-        if (payload) {
-            const buffer = this._createBuffer(payload.length);
-            for (let i = 0; i < payload.length; i++) {
-                buffer.array[i] = payload[i];
-            }
-            return buffer;
-        }
-        else {
-            return { ptr: null, array: undefined, size: 0 };
-        }
-    }
-    getStackDepth() {
-        try {
-            throw new Error();
-        }
-        catch (e) {
-            return e.stack.split("\n").length;
-        }
-    }
-    async handleCallResult(result) {
-        if (!result)
-            return;
-        let buffer;
-        try {
-            while (result) {
-                switch (result.type) {
-                    case 'call': {
-                        let retmsg;
-                        this.engine.profiler.logCall(result.function, () => {
-                            let payload;
-                            if (result.payload) {
-                                payload = this.unpackMessage(result.payload);
-                            }
-                            try {
-                                const ret = this.message(result.function, payload, result.buffers, result.scriptId);
-                                retmsg = this.packMessage(ret);
-                            }
-                            catch (err) {
-                                console.error(`Error calling '${result.function}' from Lua: `, err);
-                            }
-                        });
-                        buffer = this._payloadToBuffer(retmsg);
-                        result = this.lua.script_engine_resume(result.threadRef, buffer.ptr, buffer.size);
-                        this._freeBuffer(buffer);
-                        buffer = null;
-                        break;
-                    }
-                    case 'promise': {
-                        const promiseEntry = { promise: undefined, resolve: undefined, reject: undefined };
-                        // we have got a new promise, which is nothing but a nested coroutine. Resume it and handle its
-                        // result separately until it is finished.
-                        const executorPromise = new Promise((resolve, reject) => {
-                            try {
-                                // This inner promise is the actual promise that is now awaitable. The outer one is just for fully executing
-                                // the executor function before continuing
-                                promiseEntry.promise = new Promise((resolve, reject) => {
-                                    promiseEntry.resolve = resolve;
-                                    promiseEntry.reject = reject;
-                                });
-                                this.promises.set(result.handle, promiseEntry);
-                                // now execute the executor function
-                                const promiseResult = this.lua.script_engine_resume(result.promiseThreadRef, null, 0);
-                                this.handleCallResult(promiseResult).then(resolve).catch(reject);
-                            }
-                            catch (err) {
-                                reject(err);
-                            }
-                        });
-                        try {
-                            await executorPromise;
-                        }
-                        catch (err) {
-                            console.error("Awaiting lua promise executor errored: ", err);
-                        }
-                        // Promise has finished, now resume the actual thread again
-                        result = this.lua.script_engine_resume(result.threadRef, null, 0);
-                        break;
-                    }
-                    case 'promiseDone': {
-                        const promiseEntry = this.promises.get(result.handle);
-                        if (promiseEntry?.resolve) {
-                            promiseEntry.resolve();
-                        }
-                        else {
-                            console.warn("Got promise result but promise could not be found: ", result.handle);
-                        }
-                        result = this.lua.script_engine_resume(result.threadRef, null, 0);
-                        break;
-                    }
-                    case 'await': {
-                        const promiseEntry = this.promises.get(result.handle);
-                        if (promiseEntry) {
-                            await promiseEntry.promise;
-                            result = this.lua.script_engine_resume(result.threadRef, null, 0);
-                        }
-                        else {
-                            // promise does not exist. resume anyway!
-                            console.warn("Promise to await not found: ", result.handle);
-                            result = this.lua.script_engine_resume(result.threadRef, null, 0);
-                        }
-                        break;
-                    }
-                    case 'error': {
-                        const offsetError = this.correctScriptLocs(result.msg);
-                        // @ts-ignore
-                        if (console.noTraceError) {
-                            // @ts-ignore
-                            console.noTraceError(`[LUA]: ${offsetError}`);
-                        }
-                        else
-                            console.log(`[LUA ERROR]: ${offsetError}`);
-                        return;
-                    }
-                    case 'breakpoint': {
-                        this.engine.player.pause(true);
-                        this.engine.eventBus.$emit("debugger:break", {
-                            item: result.itemId,
-                            line: result.line
-                        });
-                        return;
-                    }
-                    default:
-                        // all okay, just return
-                        return;
-                }
-            }
-        }
-        catch (err) {
-            console.error("Error in handleResult: ", err);
-            return null;
-        }
-        finally {
-            this._freeBuffer(buffer);
-        }
-    }
-    async callFunc(name, payload = undefined, onMainThread = false) {
-        return this.engine.profiler.logCall(`LUA hook:${name}`, async () => {
-            let buffer;
-            try {
-                buffer = this._payloadToBuffer(payload);
-                const result = this.lua.script_engine_callfunc(name, buffer.ptr, buffer.size, !!onMainThread);
-                await this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine call hook '${name}'. Error: `, err);
-            }
-            finally {
-                this._freeBuffer(buffer);
-            }
-        });
-    }
-    async callFunction(scriptId, name, payload = undefined) {
-        return this.engine.profiler.logCall(`LUA func:${name}`, async () => {
-            let buffer;
-            try {
-                buffer = this._payloadToBuffer(payload);
-                const result = this.lua.script_function_call(scriptId, name, buffer.ptr, buffer.size);
-                await this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine call function '${name}' on script '${scriptId}'. Error: `, err);
-            }
-            finally {
-                this._freeBuffer(buffer);
-            }
-        });
-    }
-    async callFunctionWithObject(scriptId, name, payload = undefined) {
-        return this.engine.profiler.logCall(`LUA func+obj:${name}`, async () => {
-            let buffer;
-            try {
-                buffer = this._payloadToBuffer(payload);
-                const result = this.lua.script_function_call_with_object(scriptId, name, buffer.ptr, buffer.size);
-                await this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine call function '${name}' on script '${scriptId}' with object. Error: `, err);
-            }
-            finally {
-                this._freeBuffer(buffer);
-            }
-        });
-    }
-    async callMethod(scriptId, name, payload = undefined) {
-        return this.engine.profiler.logCall(`LUA method:${name}`, async () => {
-            let buffer;
-            try {
-                buffer = this._payloadToBuffer(payload);
-                const result = this.lua.script_method_call(scriptId, name, buffer.ptr, buffer.size);
-                await this.handleCallResult(result);
-            }
-            catch (err) {
-                console.error(`ScriptEngine call method '${name}' on script '${scriptId}'. Error: `, err);
-            }
-            finally {
-                this._freeBuffer(buffer);
-            }
-        });
-    }
-    getBreakpoints(scriptItemId) {
-        return this.breakpointsMap[scriptItemId];
-    }
-    toggleBreakpoint(scriptItemId, line) {
-        if (!this.breakpointsMap[scriptItemId]) {
-            this.breakpointsMap[scriptItemId] = {};
-        }
-        if (this.breakpointsMap[scriptItemId][line]) {
-            this.breakpointsMap[scriptItemId][line] = false;
-            this.lua.scriptitem_clear_breakpoint(scriptItemId, line);
-        }
-        else {
-            this.breakpointsMap[scriptItemId][line] = true;
-            this.lua.scriptitem_set_breakpoint(scriptItemId, line);
-        }
-        return this.breakpointsMap[scriptItemId][line];
-    }
-    async createScript(scriptItem) {
-        await this.waitForLua();
-        const scriptItemId = scriptItem.getId();
-        const scriptItemName = scriptItem.getName();
-        const scriptItemCode = scriptItem.getCode();
-        const injectedFields = scriptItem.getPublicFields();
-        await this._parseAndLoadImportedLibs(scriptItemCode, scriptItemId, scriptItemName);
-        const { preparedCode, breakpointsOffset } = this._prepareCode(scriptItemCode, scriptItemId, injectedFields);
-        const result = this.lua.scriptitem_create(scriptItemId, preparedCode, breakpointsOffset, scriptItemName);
-        if (result !== 0) {
-            console.error("Could not create script: " + scriptItemId);
-            return;
-        }
-        //console.log(`Performance Test after loading ${scriptItemName}`);
-        //this.doPerformanceTests();
-        this.funcExistsMap[scriptItemId] = new Map();
-        this.scripts.set(scriptItemId, true);
-        this.scriptLocOffsets[scriptItemName] = breakpointsOffset;
-    }
-    async updateScript(scriptItem) {
-        const scriptItemId = scriptItem.getId();
-        const scriptItemName = scriptItem.getName();
-        const scriptItemCode = scriptItem.getCode();
-        const injectedFields = scriptItem.getPublicFields();
-        await this._parseAndLoadImportedLibs(scriptItemCode, scriptItemId, scriptItemName);
-        const { preparedCode, breakpointsOffset } = this._prepareCode(scriptItemCode, scriptItemId, injectedFields);
-        const result = this.lua.scriptitem_update(scriptItemId, preparedCode, breakpointsOffset);
-        if (result !== 0) {
-            console.error("Could not update script: " + scriptItemId);
-        }
-        //console.log(`Performance Test after loading ${scriptItemName}`);
-        //this.doPerformanceTests();
-        this.funcExistsMap[scriptItemId] = new Map();
-        this.scriptLocOffsets[scriptItemName] = breakpointsOffset - 1;
-    }
-    deleteScript(scriptItem) {
-        if (!this.initialized)
-            return;
-        const id = scriptItem.getId();
-        const name = scriptItem.getName();
-        this.lua.scriptitem_delete(id);
-        this.scripts.delete(id);
-        delete this.scriptLocOffsets[name];
-    }
-    async create(scriptRunner) {
-        const scriptItemId = scriptRunner.getScriptItemId();
-        const scriptItemName = scriptRunner.getScriptItemName();
-        if (!this.scripts.has(scriptItemId)) {
-            throw "Script not found: " + scriptItemId;
-        }
-        const scriptId = this.lua.script_create();
-        this.scriptRunners.set(scriptId, scriptRunner);
-        const result = this.lua.script_load(scriptId, scriptItemId);
-        if (result !== 0) {
-            throw "Could not load script";
-        }
-        await this._injectValues(scriptId, scriptItemName, scriptRunner);
-        return scriptId;
-    }
-    async _parseAndLoadImportedLibs(code, scriptItemId, scriptItemName, level = 1) {
-        level = level || 1;
-        const padding = "".padEnd(level * 2, " ");
-        // get all import statement paths in double and single quotes
-        // ignore commented import statements
-        const importRegExp = /^(?!\s*--)\s*(?:(?:local\s+)?\w+\s*=\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
-        const imports = [];
-        let match;
-        while ((match = importRegExp.exec(code)) !== null) {
-            imports.push(match[1]);
-        }
-        if (imports.length)
-            this._debugLog(`${padding}[${scriptItemName}] Imported libs from here: [${imports.join(', ')}]`);
-        else
-            this._debugLog(`${padding}[${scriptItemName}] No libs imported from here.`);
-        const promises = imports.map(async (path) => {
-            try {
-                this._debugLog(`${padding} - [${scriptItemName}] Importing script: ${path}`);
-                const { item, script } = await this._importLib(scriptItemId, path, scriptItemName);
-                const code = script.getCode();
-                const key = `#${scriptItemId}#${path}`;
-                this._debugLog(`${padding} - [${scriptItemName}] Preparing code: ${path}`);
-                const preparedCode = this._prepareCode(code, item._id).preparedCode;
-                this.importedLibPathMap[key] = item._id;
-                this.importedLibsMap[item._id] = preparedCode;
-                await this._parseAndLoadImportedLibs(code, item._id, item.name, level + 1);
-            }
-            catch {
-                this._debugErr(`${padding} - [${scriptItemName}] Failed to load import script: ${path}`);
-            }
-        });
-        await Promise.all(promises);
-    }
-    async _importLib(scriptItemId, path, scriptItemName) {
-        const key = `#${scriptItemId}#${path}`;
-        // make sure we won't load things twice. If we're already trying to load a script item or
-        // finished loading it, just grab it from here.
-        if (this.importedLibsPromises[key])
-            return this.importedLibsPromises[key];
-        const promise = new Promise(async (resolve, reject) => {
-            let item;
-            try {
-                item = await this.itemRepo.loadItemByRelativePath(scriptItemId, path, { recursive: true });
-            }
-            catch (err) {
-                console.error(err);
-            }
-            if (!item) {
-                this._debugErr(`[${scriptItemName}/${path}] did not find script!`);
-                reject(new LoaderException(`Did not find script '${path}' relative to item ${scriptItemId}`));
-            }
-            this._debugLog(`[${scriptItemName}/${path}] loading script from cloud`);
-            const script = await this.engine.loadingManager.loadScript(scriptItemId, item, {
-                waitUntilFinished: true
-            });
-            const code = script.getCode() || "";
-            this._debugLog(`[${scriptItemName}/${path}] ${code.length} characters loaded. adding script to engine`);
-            if (code.length === 0) {
-                debugger;
-            }
-            this.engine.addScript(scriptItemId, script);
-            this._debugLog(`[${scriptItemName}/${path}] done.`);
-            resolve({ item, script });
-        });
-        this.importedLibsPromises[key] = promise;
-        this._debugLog(`[${scriptItemId}] Imported libs promises: `, this.importedLibsPromises);
-        return promise;
-    }
-    async _injectValues(scriptId, scriptItemName, scriptRunner) {
-        const injectedFieldsMap = scriptRunner.getInjectedFields();
-        for (const key in injectedFieldsMap) {
-            try {
-                if (injectedFieldsMap.hasOwnProperty(key)) {
-                    const entry = injectedFieldsMap[key];
-                    const value = entry.value;
-                    if (value !== null && value !== undefined) {
-                        let payload;
-                        if (entry.type === "String" && key === "node")
-                            payload = this.packMessage({ scriptName: scriptItemName, value: value, scriptId: scriptId });
-                        else
-                            payload = this.packMessage(value);
-                        const funcName = `__set_object_${key}`;
-                        if (this.functionExists(scriptId, funcName))
-                            await this.callFunctionWithObject(scriptId, funcName, payload);
-                    }
-                }
-            }
-            catch (err) {
-                console.error(err);
-            }
-        }
-    }
-    _prepareCode(code, scriptItemId, injectedFields = undefined) {
-        let varCode = "";
-        let injectedVarsNumLines = 0;
-        if (injectedFields) {
-            for (const field of injectedFields) {
-                switch (field.type) {
-                    case 'node':
-                        if (field.name === 'node')
-                            varCode += `function __set_object_${field.name}(object, data, len) object:_setNode(__api_internal.fetchAndUnpack(data, len)) end\n`;
-                        else
-                            varCode += `function __set_object_${field.name}(object, data, len) if type(object.${field.name}) == 'table' then object.${field.name}:set(__api_sceneobject:findById(__api_internal.fetchAndUnpack(data, len))) else object.${field.name} = __api_sceneobject:findById(__api_internal.fetchAndUnpack(data, len)) end end\n`;
-                        injectedVarsNumLines++;
-                        break;
-                    default:
-                        varCode += `function __set_object_${field.name}(object, data, len) if type(object.${field.name}) == 'table' then object.${field.name}:set(__api_internal.fetchAndUnpack(data, len)) else object.${field.name} = __api_internal.fetchAndUnpack(data, len) end end\n`;
-                        injectedVarsNumLines++;
-                        break;
-                }
-            }
-        }
-        const preparedCode = moduleTemplate.replace('--##CODE##', code).replaceAll('##SCRIPTITEMID##', scriptItemId).replace('--##INJECTEDVARS##', varCode);
-        const breakpointsOffset = this.moduleTemplateCodeLineOffset + injectedVarsNumLines + 1;
-        return {
-            preparedCode,
-            breakpointsOffset
-        };
-    }
-    _calculateModuleTemplateCodeLineOffset() {
-        const codeOffset = moduleTemplate.indexOf('--##CODE##');
-        let count = 0;
-        for (let i = 0; i < codeOffset; i++)
-            count += +(moduleTemplate[i] === '\n');
-        return count;
-    }
-    addEventListener(eventType, listenerId, isOnce, scriptId) {
-        // First we find the event within the event listeners
-        // ----------------------------------------------------------
-        let listenersMap = this.eventListeners.get(eventType);
-        if (!listenersMap) {
-            listenersMap = new Map();
-            this.eventListeners.set(eventType, listenersMap);
-        }
-        // Now we can add the listener to it
-        // ----------------------------------------------------------
-        listenersMap.set(listenerId, {
-            isOnce: !!isOnce,
-            scriptId: scriptId
-        });
-    }
-    removeEventListener(eventType, scriptId) {
-        const listenersMap = this.eventListeners.get(eventType);
-        if (!listenersMap) {
-            return;
-        }
-        const listenerIdsToDelete = [];
-        for (const [listenerId, listenerData] of listenersMap.entries()) {
-            if (listenerData.scriptId === scriptId) {
-                listenerIdsToDelete.push(listenerId);
-            }
-        }
-        for (const listenerId of listenerIdsToDelete) {
-            listenersMap.delete(listenerId);
-        }
-        if (listenersMap.size === 0) {
-            this.eventListeners.delete(eventType);
-        }
-    }
-    pushEvent(event) {
-        const scriptMap = this.eventListeners.get(event.type);
-        if (!scriptMap || !scriptMap.size)
-            return;
-        const keysToDelete = [];
-        for (const [listenerId, value] of scriptMap.entries()) {
-            try {
-                const eventMsg = this.packMessage({ event, listenerId });
-                this.callFunc("__event", eventMsg);
-                if (value.isOnce) {
-                    keysToDelete.push(listenerId);
-                }
-            }
-            catch (err) {
-                console.error(err);
-            }
-        }
-        for (const key of keysToDelete) {
-            scriptMap.delete(key);
-        }
-    }
-    correctScriptLocs(message) {
-        let correctedMessage = message;
-        for (const [scriptName, offset] of Object.entries(this.scriptLocOffsets)) {
-            correctedMessage = this.offsetScriptLocs(correctedMessage, scriptName, offset);
-        }
-        return correctedMessage;
-    }
-    // Offsets the lines of code (LOC) for logs in the format "<scriptName>::<scriptId>:<loc>:"
-    // to reflect the actual LOC as seen in the editor (counteracts injected code).
-    offsetScriptLocs(message, scriptName, offset) {
-        const regexp = new RegExp(`(${scriptName}::[a-f0-9]+):(\\d+)`, "g");
-        return message.replace(regexp, (match, scriptIdentifier, loc) => {
-            const newLoc = Number(loc) - offset;
-            const newLocWithInjection = `${newLoc}${newLoc <= 0 ? "(injected code)" : ""}`;
-            return `${scriptName}:${newLocWithInjection}`;
-        });
-    }
-    async getPublicProperties(code, scriptItemName, scriptItemId) {
-        this._debugLog(`[${scriptItemName}] Fetching properties for script ---------------------------------`);
-        await this._parseAndLoadImportedLibs(code, scriptItemId, scriptItemName);
-        const { preparedCode, breakpointsOffset } = this._prepareCode(code, scriptItemId, []);
-        this.scriptLocOffsets[scriptItemName] = breakpointsOffset;
-        this._debugLog(`[${scriptItemName}] Everything imported. Running code now for scanning...`);
-        const resultJson = this.lua.script_get_props(preparedCode, scriptItemName, scriptItemId);
-        if (!resultJson) {
-            this._debugLog(`[${scriptItemName}] Script has no result.`);
-            this._debugLog(`[${scriptItemName}] ---------------------------------------------------------------`);
-            return [];
-        }
-        const result = JSON.parse(resultJson);
-        if (result.error) {
-            this._debugErr(`[${scriptItemName}] Error in code:`, result.error);
-            this._debugLog(`[${scriptItemName}] ---------------------------------------------------------------`);
-            return [];
-        }
-        if (Array.isArray(result.props)) {
-            if (SE_DEBUG_LOG) {
-                this._debugLog(`[${scriptItemName}] Script has props: [${result.props.map(x => x.name).join(', ')}]`);
-                this._debugLog(`[${scriptItemName}] ---------------------------------------------------------------`);
-            }
-            return result.props;
-        }
-        else {
-            this._debugLog(`[${scriptItemName}] Script has no props.`);
-            this._debugLog(`[${scriptItemName}] ---------------------------------------------------------------`);
-            return [];
-        }
-    }
-}
-//# sourceMappingURL=ScriptEngine.js.map