conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/module.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSWASMModule = exports.applyModuleEvalRuntimeOptions = exports.applyBaseRuntimeOptions = exports.QuickJSModuleCallbacks = void 0;
+const debug_1 = require("./debug");
+const errors_1 = require("./errors");
+const lifetime_1 = require("./lifetime");
+const runtime_1 = require("./runtime");
+const types_1 = require("./types");
+class QuickJSEmscriptenModuleCallbacks {
+    constructor(args) {
+        this.callFunction = args.callFunction;
+        this.shouldInterrupt = args.shouldInterrupt;
+        this.loadModuleSource = args.loadModuleSource;
+        this.normalizeModule = args.normalizeModule;
+    }
+}
+/**
+ * We use static functions per module to dispatch runtime or context calls from
+ * C to the host.  This class manages the indirection from a specific runtime or
+ * context pointer to the appropriate callback handler.
+ *
+ * @private
+ */
+class QuickJSModuleCallbacks {
+    constructor(module) {
+        this.contextCallbacks = new Map();
+        this.runtimeCallbacks = new Map();
+        this.suspendedCount = 0;
+        this.cToHostCallbacks = new QuickJSEmscriptenModuleCallbacks({
+            callFunction: (asyncify, ctx, this_ptr, argc, argv, fn_id) => this.handleAsyncify(asyncify, () => {
+                try {
+                    const vm = this.contextCallbacks.get(ctx);
+                    if (!vm) {
+                        throw new Error(`QuickJSContext(ctx = ${ctx}) not found for C function call "${fn_id}"`);
+                    }
+                    return vm.callFunction(ctx, this_ptr, argc, argv, fn_id);
+                }
+                catch (error) {
+                    console.error("[C to host error: returning null]", error);
+                    return 0;
+                }
+            }),
+            shouldInterrupt: (asyncify, rt) => this.handleAsyncify(asyncify, () => {
+                try {
+                    const vm = this.runtimeCallbacks.get(rt);
+                    if (!vm) {
+                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C interrupt`);
+                    }
+                    return vm.shouldInterrupt(rt);
+                }
+                catch (error) {
+                    console.error("[C to host interrupt: returning error]", error);
+                    return 1;
+                }
+            }),
+            loadModuleSource: (asyncify, rt, ctx, moduleName) => this.handleAsyncify(asyncify, () => {
+                try {
+                    const runtimeCallbacks = this.runtimeCallbacks.get(rt);
+                    if (!runtimeCallbacks) {
+                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`);
+                    }
+                    const loadModule = runtimeCallbacks.loadModuleSource;
+                    if (!loadModule) {
+                        throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`);
+                    }
+                    return loadModule(rt, ctx, moduleName);
+                }
+                catch (error) {
+                    console.error("[C to host module loader error: returning null]", error);
+                    return 0;
+                }
+            }),
+            normalizeModule: (asyncify, rt, ctx, moduleBaseName, moduleName) => this.handleAsyncify(asyncify, () => {
+                try {
+                    const runtimeCallbacks = this.runtimeCallbacks.get(rt);
+                    if (!runtimeCallbacks) {
+                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`);
+                    }
+                    const normalizeModule = runtimeCallbacks.normalizeModule;
+                    if (!normalizeModule) {
+                        throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`);
+                    }
+                    return normalizeModule(rt, ctx, moduleBaseName, moduleName);
+                }
+                catch (error) {
+                    console.error("[C to host module loader error: returning null]", error);
+                    return 0;
+                }
+            }),
+        });
+        this.module = module;
+        this.module.callbacks = this.cToHostCallbacks;
+    }
+    setRuntimeCallbacks(rt, callbacks) {
+        this.runtimeCallbacks.set(rt, callbacks);
+    }
+    deleteRuntime(rt) {
+        this.runtimeCallbacks.delete(rt);
+    }
+    setContextCallbacks(ctx, callbacks) {
+        this.contextCallbacks.set(ctx, callbacks);
+    }
+    deleteContext(ctx) {
+        this.contextCallbacks.delete(ctx);
+    }
+    handleAsyncify(asyncify, fn) {
+        if (asyncify) {
+            // We must always call asyncify.handleSync around our function.
+            // This allows asyncify to resume suspended execution on the second call.
+            // Asyncify internally can detect sync behavior, and avoid suspending.
+            return asyncify.handleSleep((done) => {
+                try {
+                    const result = fn();
+                    if (!(result instanceof Promise)) {
+                        (0, debug_1.debugLog)("asyncify.handleSleep: not suspending:", result);
+                        done(result);
+                        return;
+                    }
+                    // Is promise, we intend to suspend.
+                    if (this.suspended) {
+                        throw new errors_1.QuickJSAsyncifyError(`Already suspended at: ${this.suspended.stack}\nAttempted to suspend at:`);
+                    }
+                    else {
+                        this.suspended = new errors_1.QuickJSAsyncifySuspended(`(${this.suspendedCount++})`);
+                        (0, debug_1.debugLog)("asyncify.handleSleep: suspending:", this.suspended);
+                    }
+                    result.then((resolvedResult) => {
+                        this.suspended = undefined;
+                        (0, debug_1.debugLog)("asyncify.handleSleep: resolved:", resolvedResult);
+                        done(resolvedResult);
+                    }, (error) => {
+                        (0, debug_1.debugLog)("asyncify.handleSleep: rejected:", error);
+                        console.error("QuickJS: cannot handle error in suspended function", error);
+                        this.suspended = undefined;
+                    });
+                }
+                catch (error) {
+                    (0, debug_1.debugLog)("asyncify.handleSleep: error:", error);
+                    this.suspended = undefined;
+                    throw error;
+                }
+            });
+        }
+        // No asyncify - we should never return a promise.
+        const value = fn();
+        if (value instanceof Promise) {
+            throw new Error("Promise return value not supported in non-asyncify context.");
+        }
+        return value;
+    }
+}
+exports.QuickJSModuleCallbacks = QuickJSModuleCallbacks;
+/**
+ * Process RuntimeOptions and apply them to a QuickJSRuntime.
+ * @private
+ */
+function applyBaseRuntimeOptions(runtime, options) {
+    if (options.interruptHandler) {
+        runtime.setInterruptHandler(options.interruptHandler);
+    }
+    if (options.maxStackSizeBytes !== undefined) {
+        runtime.setMaxStackSize(options.maxStackSizeBytes);
+    }
+    if (options.memoryLimitBytes !== undefined) {
+        runtime.setMemoryLimit(options.memoryLimitBytes);
+    }
+}
+exports.applyBaseRuntimeOptions = applyBaseRuntimeOptions;
+/**
+ * Process ModuleEvalOptions and apply them to a QuickJSRuntime.
+ * @private
+ */
+function applyModuleEvalRuntimeOptions(runtime, options) {
+    if (options.moduleLoader) {
+        runtime.setModuleLoader(options.moduleLoader);
+    }
+    if (options.shouldInterrupt) {
+        runtime.setInterruptHandler(options.shouldInterrupt);
+    }
+    if (options.memoryLimitBytes !== undefined) {
+        runtime.setMemoryLimit(options.memoryLimitBytes);
+    }
+    if (options.maxStackSizeBytes !== undefined) {
+        runtime.setMaxStackSize(options.maxStackSizeBytes);
+    }
+}
+exports.applyModuleEvalRuntimeOptions = applyModuleEvalRuntimeOptions;
+/**
+ * This class presents a Javascript interface to QuickJS, a Javascript interpreter
+ * that supports EcmaScript 2020 (ES2020).
+ *
+ * It wraps a single WebAssembly module containing the QuickJS library and
+ * associated helper C code. WebAssembly modules are completely isolated from
+ * each other by the host's WebAssembly runtime. Separate WebAssembly modules
+ * have the most isolation guarantees possible with this library.
+ *
+ * The simplest way to start running code is {@link evalCode}. This shortcut
+ * method will evaluate Javascript safely and return the result as a native
+ * Javascript value.
+ *
+ * For more control over the execution environment, or to interact with values
+ * inside QuickJS, create a context with {@link newContext} or a runtime with
+ * {@link newRuntime}.
+ */
+class QuickJSWASMModule {
+    /** @private */
+    constructor(module, ffi) {
+        this.module = module;
+        this.ffi = ffi;
+        this.callbacks = new QuickJSModuleCallbacks(module);
+    }
+    /**
+     * Create a runtime.
+     * Use the runtime to set limits on CPU and memory usage and configure module
+     * loading for one or more [[QuickJSContext]]s inside the runtime.
+     */
+    newRuntime(options = {}) {
+        const rt = new lifetime_1.Lifetime(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
+            this.callbacks.deleteRuntime(rt_ptr);
+            this.ffi.QTS_FreeRuntime(rt_ptr);
+        });
+        const runtime = new runtime_1.QuickJSRuntime({
+            module: this.module,
+            callbacks: this.callbacks,
+            ffi: this.ffi,
+            rt,
+        });
+        applyBaseRuntimeOptions(runtime, options);
+        if (options.moduleLoader) {
+            runtime.setModuleLoader(options.moduleLoader);
+        }
+        return runtime;
+    }
+    /**
+     * A simplified API to create a new [[QuickJSRuntime]] and a
+     * [[QuickJSContext]] inside that runtime at the same time. The runtime will
+     * be disposed when the context is disposed.
+     */
+    newContext(options = {}) {
+        const runtime = this.newRuntime();
+        const context = runtime.newContext({
+            ...options,
+            ownedLifetimes: (0, types_1.concat)(runtime, options.ownedLifetimes),
+        });
+        runtime.context = context;
+        return context;
+    }
+    /**
+     * One-off evaluate code without needing to create a [[QuickJSRuntime]] or
+     * [[QuickJSContext]] explicitly.
+     *
+     * To protect against infinite loops, use the `shouldInterrupt` option. The
+     * [[shouldInterruptAfterDeadline]] function will create a time-based deadline.
+     *
+     * If you need more control over how the code executes, create a
+     * [[QuickJSRuntime]] (with [[newRuntime]]) or a [[QuickJSContext]] (with
+     * [[newContext]] or [[QuickJSRuntime.newContext]]), and use its
+     * [[QuickJSContext.evalCode]] method.
+     *
+     * Asynchronous callbacks may not run during the first call to `evalCode`. If
+     * you need to work with async code inside QuickJS, create a runtime and use
+     * [[QuickJSRuntime.executePendingJobs]].
+     *
+     * @returns The result is coerced to a native Javascript value using JSON
+     * serialization, so properties and values unsupported by JSON will be dropped.
+     *
+     * @throws If `code` throws during evaluation, the exception will be
+     * converted into a native Javascript value and thrown.
+     *
+     * @throws if `options.shouldInterrupt` interrupted execution, will throw a Error
+     * with name `"InternalError"` and  message `"interrupted"`.
+     */
+    evalCode(code, options = {}) {
+        return lifetime_1.Scope.withScope((scope) => {
+            const vm = scope.manage(this.newContext());
+            applyModuleEvalRuntimeOptions(vm.runtime, options);
+            const result = vm.evalCode(code, "eval.js");
+            if (options.memoryLimitBytes !== undefined) {
+                // Remove memory limit so we can dump the result without exceeding it.
+                vm.runtime.setMemoryLimit(-1);
+            }
+            if (result.error) {
+                const error = vm.dump(scope.manage(result.error));
+                throw error;
+            }
+            const value = vm.dump(scope.manage(result.value));
+            return value;
+        });
+    }
+    /**
+     * Get a low-level interface to the QuickJS functions in this WebAssembly
+     * module.
+     * @experimental
+     * @unstable No warranty is provided with this API. It could change at any time.
+     * @private
+     */
+    getFFI() {
+        return this.ffi;
+    }
+}
+exports.QuickJSWASMModule = QuickJSWASMModule;
+//# sourceMappingURL=module.js.map

package/web/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSAsyncRuntime = void 0;
+const _1 = require(".");
+const context_asyncify_1 = require("./context-asyncify");
+const runtime_1 = require("./runtime");
+const types_1 = require("./types");
+class QuickJSAsyncRuntime extends runtime_1.QuickJSRuntime {
+    /** @private */
+    constructor(args) {
+        super(args);
+    }
+    newContext(options = {}) {
+        if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) {
+            throw new Error("TODO: Custom intrinsics are not supported yet");
+        }
+        const ctx = new _1.Lifetime(this.ffi.QTS_NewContext(this.rt.value), undefined, (ctx_ptr) => {
+            this.contextMap.delete(ctx_ptr);
+            this.callbacks.deleteContext(ctx_ptr);
+            this.ffi.QTS_FreeContext(ctx_ptr);
+        });
+        const context = new context_asyncify_1.QuickJSAsyncContext({
+            module: this.module,
+            ctx,
+            ffi: this.ffi,
+            rt: this.rt,
+            ownedLifetimes: [],
+            runtime: this,
+            callbacks: this.callbacks,
+        });
+        this.contextMap.set(ctx.value, context);
+        return context;
+    }
+    setModuleLoader(moduleLoader, moduleNormalizer) {
+        super.setModuleLoader(moduleLoader, moduleNormalizer);
+    }
+    /**
+     * Set the max stack size for this runtime in bytes.
+     * To remove the limit, set to `0`.
+     *
+     * Setting this limit also adjusts the global `ASYNCIFY_STACK_SIZE` for the entire {@link QuickJSAsyncWASMModule}.
+     * See the [pull request](https://github.com/justjake/quickjs-emscripten/pull/114) for more details.
+     */
+    setMaxStackSize(stackSize) {
+        return super.setMaxStackSize(stackSize);
+    }
+}
+exports.QuickJSAsyncRuntime = QuickJSAsyncRuntime;
+//# sourceMappingURL=runtime-asyncify.js.map

package/web/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/runtime.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSRuntime = void 0;
+const asyncify_helpers_1 = require("./asyncify-helpers");
+const context_1 = require("./context");
+const debug_1 = require("./debug");
+const errors_1 = require("./errors");
+const lifetime_1 = require("./lifetime");
+const memory_1 = require("./memory");
+const types_1 = require("./types");
+/**
+ * A runtime represents a Javascript runtime corresponding to an object heap.
+ * Several runtimes can exist at the same time but they cannot exchange objects.
+ * Inside a given runtime, no multi-threading is supported.
+ *
+ * You can think of separate runtimes like different domains in a browser, and
+ * the contexts within a runtime like the different windows open to the same
+ * domain.
+ *
+ * Create a runtime via {@link QuickJSWASMModule.newRuntime}.
+ *
+ * You should create separate runtime instances for untrusted code from
+ * different sources for isolation. However, stronger isolation is also
+ * available (at the cost of memory usage), by creating separate WebAssembly
+ * modules to further isolate untrusted code.
+ * See {@link newQuickJSWASMModule}.
+ *
+ * Implement memory and CPU constraints with [[setInterruptHandler]]
+ * (called regularly while the interpreter runs), [[setMemoryLimit]], and
+ * [[setMaxStackSize]].
+ * Use [[computeMemoryUsage]] or [[dumpMemoryUsage]] to guide memory limit
+ * tuning.
+ *
+ * Configure ES module loading with [[setModuleLoader]].
+ */
+class QuickJSRuntime {
+    /** @private */
+    constructor(args) {
+        /** @private */
+        this.scope = new lifetime_1.Scope();
+        /** @private */
+        this.contextMap = new Map();
+        this.cToHostCallbacks = {
+            shouldInterrupt: (rt) => {
+                if (rt !== this.rt.value) {
+                    throw new Error("QuickJSContext instance received C -> JS interrupt with mismatched rt");
+                }
+                const fn = this.interruptHandler;
+                if (!fn) {
+                    throw new Error("QuickJSContext had no interrupt handler");
+                }
+                return fn(this) ? 1 : 0;
+            },
+            loadModuleSource: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, moduleName) {
+                const moduleLoader = this.moduleLoader;
+                if (!moduleLoader) {
+                    throw new Error("Runtime has no module loader");
+                }
+                if (rt !== this.rt.value) {
+                    throw new Error("Runtime pointer mismatch");
+                }
+                const context = this.contextMap.get(ctx) ??
+                    this.newContext({
+                        contextPointer: ctx,
+                    });
+                try {
+                    const result = yield* awaited(moduleLoader(moduleName, context));
+                    if (typeof result === "object" && "error" in result && result.error) {
+                        (0, debug_1.debugLog)("cToHostLoadModule: loader returned error", result.error);
+                        throw result.error;
+                    }
+                    const moduleSource = typeof result === "string" ? result : "value" in result ? result.value : result;
+                    return this.memory.newHeapCharPointer(moduleSource).value;
+                }
+                catch (error) {
+                    (0, debug_1.debugLog)("cToHostLoadModule: caught error", error);
+                    context.throw(error);
+                    return 0;
+                }
+            }),
+            normalizeModule: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, baseModuleName, moduleNameRequest) {
+                const moduleNormalizer = this.moduleNormalizer;
+                if (!moduleNormalizer) {
+                    throw new Error("Runtime has no module normalizer");
+                }
+                if (rt !== this.rt.value) {
+                    throw new Error("Runtime pointer mismatch");
+                }
+                const context = this.contextMap.get(ctx) ??
+                    this.newContext({
+                        /* TODO: Does this happen? Are we responsible for disposing? I don't think so */
+                        contextPointer: ctx,
+                    });
+                try {
+                    const result = yield* awaited(moduleNormalizer(baseModuleName, moduleNameRequest, context));
+                    if (typeof result === "object" && "error" in result && result.error) {
+                        (0, debug_1.debugLog)("cToHostNormalizeModule: normalizer returned error", result.error);
+                        throw result.error;
+                    }
+                    const name = typeof result === "string" ? result : result.value;
+                    return context.getMemory(this.rt.value).newHeapCharPointer(name).value;
+                }
+                catch (error) {
+                    (0, debug_1.debugLog)("normalizeModule: caught error", error);
+                    context.throw(error);
+                    return 0;
+                }
+            }),
+        };
+        args.ownedLifetimes?.forEach((lifetime) => this.scope.manage(lifetime));
+        this.module = args.module;
+        this.memory = new memory_1.ModuleMemory(this.module);
+        this.ffi = args.ffi;
+        this.rt = args.rt;
+        this.callbacks = args.callbacks;
+        this.scope.manage(this.rt);
+        this.callbacks.setRuntimeCallbacks(this.rt.value, this.cToHostCallbacks);
+        this.executePendingJobs = this.executePendingJobs.bind(this);
+    }
+    get alive() {
+        return this.scope.alive;
+    }
+    dispose() {
+        return this.scope.dispose();
+    }
+    newContext(options = {}) {
+        if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) {
+            throw new Error("TODO: Custom intrinsics are not supported yet");
+        }
+        const ctx = new lifetime_1.Lifetime(options.contextPointer || this.ffi.QTS_NewContext(this.rt.value), undefined, (ctx_ptr) => {
+            this.contextMap.delete(ctx_ptr);
+            this.callbacks.deleteContext(ctx_ptr);
+            this.ffi.QTS_FreeContext(ctx_ptr);
+        });
+        const context = new context_1.QuickJSContext({
+            module: this.module,
+            ctx,
+            ffi: this.ffi,
+            rt: this.rt,
+            ownedLifetimes: options.ownedLifetimes,
+            runtime: this,
+            callbacks: this.callbacks,
+        });
+        this.contextMap.set(ctx.value, context);
+        return context;
+    }
+    /**
+     * Set the loader for EcmaScript modules requested by any context in this
+     * runtime.
+     *
+     * The loader can be removed with [[removeModuleLoader]].
+     */
+    setModuleLoader(moduleLoader, moduleNormalizer) {
+        this.moduleLoader = moduleLoader;
+        this.moduleNormalizer = moduleNormalizer;
+        this.ffi.QTS_RuntimeEnableModuleLoader(this.rt.value, this.moduleNormalizer ? 1 : 0);
+    }
+    /**
+     * Remove the the loader set by [[setModuleLoader]]. This disables module loading.
+     */
+    removeModuleLoader() {
+        this.moduleLoader = undefined;
+        this.ffi.QTS_RuntimeDisableModuleLoader(this.rt.value);
+    }
+    // Runtime management -------------------------------------------------------
+    /**
+     * In QuickJS, promises and async functions create pendingJobs. These do not execute
+     * immediately and need to be run by calling [[executePendingJobs]].
+     *
+     * @return true if there is at least one pendingJob queued up.
+     */
+    hasPendingJob() {
+        return Boolean(this.ffi.QTS_IsJobPending(this.rt.value));
+    }
+    /**
+     * Set a callback which is regularly called by the QuickJS engine when it is
+     * executing code. This callback can be used to implement an execution
+     * timeout.
+     *
+     * The interrupt handler can be removed with [[removeInterruptHandler]].
+     */
+    setInterruptHandler(cb) {
+        const prevInterruptHandler = this.interruptHandler;
+        this.interruptHandler = cb;
+        if (!prevInterruptHandler) {
+            this.ffi.QTS_RuntimeEnableInterruptHandler(this.rt.value);
+        }
+    }
+    /**
+     * Remove the interrupt handler, if any.
+     * See [[setInterruptHandler]].
+     */
+    removeInterruptHandler() {
+        if (this.interruptHandler) {
+            this.ffi.QTS_RuntimeDisableInterruptHandler(this.rt.value);
+            this.interruptHandler = undefined;
+        }
+    }
+    /**
+     * Execute pendingJobs on the runtime until `maxJobsToExecute` jobs are
+     * executed (default all pendingJobs), the queue is exhausted, or the runtime
+     * encounters an exception.
+     *
+     * In QuickJS, promises and async functions *inside the runtime* create
+     * pendingJobs. These do not execute immediately and need to triggered to run.
+     *
+     * @param maxJobsToExecute - When negative, run all pending jobs. Otherwise execute
+     * at most `maxJobsToExecute` before returning.
+     *
+     * @return On success, the number of executed jobs. On error, the exception
+     * that stopped execution, and the context it occurred in. Note that
+     * executePendingJobs will not normally return errors thrown inside async
+     * functions or rejected promises. Those errors are available by calling
+     * [[resolvePromise]] on the promise handle returned by the async function.
+     */
+    executePendingJobs(maxJobsToExecute = -1) {
+        const ctxPtrOut = this.memory.newMutablePointerArray(1);
+        const valuePtr = this.ffi.QTS_ExecutePendingJob(this.rt.value, maxJobsToExecute ?? -1, ctxPtrOut.value.ptr);
+        const ctxPtr = ctxPtrOut.value.typedArray[0];
+        ctxPtrOut.dispose();
+        if (ctxPtr === 0) {
+            // No jobs executed.
+            this.ffi.QTS_FreeValuePointerRuntime(this.rt.value, valuePtr);
+            return { value: 0 };
+        }
+        const context = this.contextMap.get(ctxPtr) ??
+            this.newContext({
+                contextPointer: ctxPtr,
+            });
+        const resultValue = context.getMemory(this.rt.value).heapValueHandle(valuePtr);
+        const typeOfRet = context.typeof(resultValue);
+        if (typeOfRet === "number") {
+            const executedJobs = context.getNumber(resultValue);
+            resultValue.dispose();
+            return { value: executedJobs };
+        }
+        else {
+            const error = Object.assign(resultValue, { context });
+            return {
+                error,
+            };
+        }
+    }
+    /**
+     * Set the max memory this runtime can allocate.
+     * To remove the limit, set to `-1`.
+     */
+    setMemoryLimit(limitBytes) {
+        if (limitBytes < 0 && limitBytes !== -1) {
+            throw new Error("Cannot set memory limit to negative number. To unset, pass -1");
+        }
+        this.ffi.QTS_RuntimeSetMemoryLimit(this.rt.value, limitBytes);
+    }
+    /**
+     * Compute memory usage for this runtime. Returns the result as a handle to a
+     * JSValue object. Use [[QuickJSContext.dump]] to convert to a native object.
+     * Calling this method will allocate more memory inside the runtime. The information
+     * is accurate as of just before the call to `computeMemoryUsage`.
+     * For a human-digestible representation, see [[dumpMemoryUsage]].
+     */
+    computeMemoryUsage() {
+        const serviceContextMemory = this.getSystemContext().getMemory(this.rt.value);
+        return serviceContextMemory.heapValueHandle(this.ffi.QTS_RuntimeComputeMemoryUsage(this.rt.value, serviceContextMemory.ctx.value));
+    }
+    /**
+     * @returns a human-readable description of memory usage in this runtime.
+     * For programmatic access to this information, see [[computeMemoryUsage]].
+     */
+    dumpMemoryUsage() {
+        return this.memory.consumeHeapCharPointer(this.ffi.QTS_RuntimeDumpMemoryUsage(this.rt.value));
+    }
+    /**
+     * Set the max stack size for this runtime, in bytes.
+     * To remove the limit, set to `0`.
+     */
+    setMaxStackSize(stackSize) {
+        if (stackSize < 0) {
+            throw new Error("Cannot set memory limit to negative number. To unset, pass 0.");
+        }
+        this.ffi.QTS_RuntimeSetMaxStackSize(this.rt.value, stackSize);
+    }
+    /**
+     * Assert that `handle` is owned by this runtime.
+     * @throws QuickJSWrongOwner if owned by a different runtime.
+     */
+    assertOwned(handle) {
+        if (handle.owner && handle.owner.rt !== this.rt) {
+            throw new errors_1.QuickJSWrongOwner(`Handle is not owned by this runtime: ${handle.owner.rt.value} != ${this.rt.value}`);
+        }
+    }
+    getSystemContext() {
+        if (!this.context) {
+            // We own this context and should dispose of it.
+            this.context = this.scope.manage(this.newContext());
+        }
+        return this.context;
+    }
+}
+exports.QuickJSRuntime = QuickJSRuntime;
+//# sourceMappingURL=runtime.js.map

package/web/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvalFlags = exports.assertSync = void 0;
+function assertSync(fn) {
+    return function mustBeSync(...args) {
+        const result = fn(...args);
+        if (result && typeof result === "object" && result instanceof Promise) {
+            throw new Error("Function unexpectedly returned a Promise");
+        }
+        return result;
+    };
+}
+exports.assertSync = assertSync;
+/** Bitfield options for JS_Eval() C function. */
+exports.EvalFlags = {
+    /** global code (default) */
+    JS_EVAL_TYPE_GLOBAL: 0 << 0,
+    /** module code */
+    JS_EVAL_TYPE_MODULE: 1 << 0,
+    /** direct call (internal use) */
+    JS_EVAL_TYPE_DIRECT: 2 << 0,
+    /** indirect call (internal use) */
+    JS_EVAL_TYPE_INDIRECT: 3 << 0,
+    JS_EVAL_TYPE_MASK: 3 << 0,
+    /** force 'strict' mode */
+    JS_EVAL_FLAG_STRICT: 1 << 3,
+    /** force 'strip' mode */
+    JS_EVAL_FLAG_STRIP: 1 << 4,
+    /**
+     * compile but do not run. The result is an object with a
+     * JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
+     * with JS_EvalFunction().
+     */
+    JS_EVAL_FLAG_COMPILE_ONLY: 1 << 5,
+    /** don't include the stack frames before this eval in the Error() backtraces */
+    JS_EVAL_FLAG_BACKTRACE_BARRIER: 1 << 6,
+};
+//# sourceMappingURL=types-ffi.js.map