@nodetool-ai/sandbox-runtime 0.0.0-stage → 0.8.9-bootstrap.0

package/vendor/quickjs/sandbox/provide/provideHttp.d.ts

@@ -0,0 +1,9 @@
+import type { IFs } from 'memfs';
+import type { QuickJSAsyncContext, QuickJSContext, Scope } from 'quickjs-emscripten-core';
+import type { RuntimeOptions } from '../../types/RuntimeOptions.js';
+/**
+ * Provide http related functions
+ */
+export declare const provideHttp: (ctx: QuickJSContext | QuickJSAsyncContext, scope: Scope, options: RuntimeOptions, input?: {
+    fs?: IFs | undefined;
+}) => void;

package/vendor/quickjs/sandbox/provide/provideHttp.js

@@ -0,0 +1,42 @@
+import { getDefaultFetchAdapter } from '../../adapter/fetch.js';
+import { expose } from '../expose/expose.js';
+/**
+ * Provide http related functions
+ */
+export const provideHttp = (ctx, scope, options, input) => {
+    const injectUnsupported = (name) => () => {
+        throw new Error(`Not supported: ${name} has been disabled for security reasons or is not supported by the runtime`);
+    };
+    let fetchFunction = Object.assign(injectUnsupported('fetch'), {
+        preconnect: async (_url, _options) => {
+            return;
+        },
+    });
+    if (options.allowFetch) {
+        const adapter = options.fetchAdapter ?? getDefaultFetchAdapter({ fs: input?.fs });
+        fetchFunction = Object.assign(adapter, {
+            preconnect: async (_url, _options) => {
+                return;
+            },
+        });
+    }
+    expose(ctx, scope, {
+        __parseURL: (input, base) => {
+            const url = new URL(input, base);
+            return {
+                href: url.href,
+                origin: url.origin,
+                protocol: url.protocol,
+                username: url.username,
+                password: url.password,
+                host: url.host,
+                hostname: url.hostname,
+                port: url.port,
+                pathname: url.pathname,
+                hash: url.hash,
+                search: url.search,
+            };
+        },
+        fetch: fetchFunction,
+    });
+};

package/vendor/quickjs/sandbox/provide/provideTimingFunctions.d.ts

@@ -0,0 +1,7 @@
+import { type QuickJSAsyncContext, type QuickJSContext } from 'quickjs-emscripten-core';
+export declare const provideTimingFunctions: (ctx: QuickJSContext | QuickJSAsyncContext, max: {
+    maxTimeoutCount: number;
+    maxIntervalCount: number;
+}) => {
+    dispose: () => void;
+};

package/vendor/quickjs/sandbox/provide/provideTimingFunctions.js

@@ -0,0 +1,119 @@
+import { Scope } from 'quickjs-emscripten-core';
+export const provideTimingFunctions = (ctx, max) => {
+    const scope = new Scope();
+    const timeouts = new Map();
+    let timeoutCounter = 0;
+    const immediates = new Map();
+    let immediateCounter = 0;
+    const intervals = new Map();
+    let intervalCounter = 0;
+    const _setTimeout = ctx.newFunction('setTimeout', (vmFnHandle, timeoutHandle) => {
+        const currentCounter = timeoutCounter++;
+        if (timeouts.size + 1 > max.maxTimeoutCount) {
+            throw new Error(`Client tries to use setTimeout, which exceeds the limit of max ${max.maxTimeoutCount} concurrent running timeout functions`);
+        }
+        const vmFnHandleCopy = vmFnHandle.dup();
+        scope.manage(vmFnHandleCopy);
+        const timeout = timeoutHandle ? ctx.dump(timeoutHandle) : undefined;
+        const timeoutID = setTimeout(() => {
+            const t = timeouts.get(currentCounter);
+            if (t) {
+                clearTimeout(t);
+                timeouts.delete(currentCounter);
+            }
+            ctx.callFunction(vmFnHandleCopy, ctx.undefined);
+        }, timeout);
+        timeouts.set(currentCounter, timeoutID);
+        return ctx.newNumber(currentCounter);
+    });
+    scope.manage(_setTimeout);
+    ctx.setProp(ctx.global, 'setTimeout', _setTimeout);
+    const _clearTimeout = ctx.newFunction('clearTimeout', timeoutHandle => {
+        const id = ctx.dump(timeoutHandle);
+        timeoutHandle.dispose();
+        const t = timeouts.get(id);
+        if (t) {
+            clearTimeout(t);
+            timeouts.delete(id);
+        }
+    });
+    scope.manage(_clearTimeout);
+    ctx.setProp(ctx.global, 'clearTimeout', _clearTimeout);
+    const _setImmediate = ctx.newFunction('setImmediate', vmFnHandle => {
+        const currentCounter = immediateCounter++;
+        if (timeouts.size + 1 > max.maxTimeoutCount) {
+            throw new Error(`Client tries to use setImmediate, which exceeds the limit of max ${max.maxTimeoutCount} concurrent running timeout functions`);
+        }
+        const vmFnHandleCopy = vmFnHandle.dup();
+        scope.manage(vmFnHandleCopy);
+        const timeoutID = setTimeout(() => {
+            const t = immediates.get(currentCounter);
+            if (t) {
+                clearTimeout(t);
+                immediates.delete(currentCounter);
+            }
+            ctx.callFunction(vmFnHandleCopy, ctx.undefined);
+        }, 0);
+        immediates.set(currentCounter, timeoutID);
+        return ctx.newNumber(currentCounter);
+    });
+    scope.manage(_setImmediate);
+    ctx.setProp(ctx.global, 'setImmediate', _setImmediate);
+    const _clearImmediate = ctx.newFunction('clearImmediate', idHandle => {
+        const id = ctx.dump(idHandle);
+        idHandle.dispose();
+        const t = immediates.get(id);
+        if (t) {
+            clearTimeout(t);
+            immediates.delete(id);
+        }
+    });
+    scope.manage(_clearImmediate);
+    ctx.setProp(ctx.global, 'clearImmediate', _clearImmediate);
+    const _setInterval = ctx.newFunction('setInterval', (vmFnHandle, intervalHandle) => {
+        const currentCounter = intervalCounter++;
+        if (intervals.size + 1 > max.maxIntervalCount) {
+            throw new Error(`Client tries to use setInterval, which exceeds the limit of max ${max.maxIntervalCount} concurrent running interval functions`);
+        }
+        const vmFnHandleCopy = vmFnHandle.dup();
+        scope.manage(vmFnHandleCopy);
+        const interval = ctx.dump(intervalHandle);
+        const intervalID = setInterval(() => {
+            ctx.callFunction(vmFnHandleCopy, ctx.undefined);
+        }, interval);
+        intervals.set(currentCounter, intervalID);
+        return ctx.newNumber(currentCounter);
+    });
+    scope.manage(_setInterval);
+    ctx.setProp(ctx.global, 'setInterval', _setInterval);
+    const _clearInterval = ctx.newFunction('clearInterval', intervalHandle => {
+        const id = ctx.dump(intervalHandle);
+        intervalHandle.dispose();
+        const t = intervals.get(id);
+        if (t) {
+            clearInterval(t);
+            intervals.delete(id);
+        }
+    });
+    scope.manage(_clearInterval);
+    ctx.setProp(ctx.global, 'clearInterval', _clearInterval);
+    const dispose = () => {
+        for (const [_key, value] of timeouts) {
+            clearTimeout(value);
+        }
+        timeouts.clear();
+        timeoutCounter = 0;
+        for (const [_key, value] of immediates) {
+            clearTimeout(value);
+        }
+        immediates.clear();
+        immediateCounter = 0;
+        for (const [_key, value] of intervals) {
+            clearInterval(value);
+        }
+        intervals.clear();
+        intervalCounter = 0;
+        scope.dispose();
+    };
+    return { dispose };
+};

package/vendor/quickjs/sandbox/setupFileSystem.d.ts

@@ -0,0 +1,3 @@
+import type { IFs } from 'memfs';
+import type { SandboxBaseOptions } from '../types/SandboxOptions.js';
+export declare const setupFileSystem: (runtimeOptions: SandboxBaseOptions) => IFs;

package/vendor/quickjs/sandbox/setupFileSystem.js

@@ -0,0 +1,13 @@
+import { createVirtualFileSystem } from '../createVirtualFileSystem.js';
+const isMountedFs = (input) => typeof input === 'object' &&
+    input !== null &&
+    'readFileSync' in input &&
+    typeof input.readFileSync === 'function' &&
+    'existsSync' in input &&
+    typeof input.existsSync === 'function';
+export const setupFileSystem = (runtimeOptions) => {
+    if (runtimeOptions.mountFs && isMountedFs(runtimeOptions.mountFs)) {
+        return runtimeOptions.mountFs;
+    }
+    return createVirtualFileSystem(runtimeOptions).fs;
+};

package/vendor/quickjs/sandbox/syncVersion/createEvalCodeFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Scope } from 'quickjs-emscripten-core';
+import type { CodeFunctionInput } from '../../types/CodeFunctionInput.js';
+import type { SandboxEvalCode } from '../../types/SandboxEvalCode.js';
+export declare const createEvalCodeFunction: (input: CodeFunctionInput, scope: Scope) => SandboxEvalCode;

package/vendor/quickjs/sandbox/syncVersion/createEvalCodeFunction.js

@@ -0,0 +1,76 @@
+import { createTimeInterval } from '../../createTimeInterval.js';
+import { rejectAndFlushPendingHostPromises } from '../expose/pendingHostPromises.js';
+import { getMaxIntervalAmount } from '../getMaxIntervalAmount.js';
+import { getMaxTimeoutAmount } from '../getMaxTimeoutAmount.js';
+import { handleEvalError } from '../handleEvalError.js';
+import { handleToNative } from '../handleToNative/handleToNative.js';
+import { provideTimingFunctions } from '../provide/provideTimingFunctions.js';
+export const createEvalCodeFunction = (input, scope) => {
+    const { ctx, sandboxOptions, transpileFile } = input;
+    return async (code, filename = '/src/index.js', evalOptions) => {
+        const eventLoopinterval = createTimeInterval(() => ctx.runtime.executePendingJobs(), 0);
+        const timeoutMs = sandboxOptions.executionTimeout ?? 0;
+        let timeoutId;
+        let nativePromise;
+        let timedOut = false;
+        const { dispose: disposeTimer } = provideTimingFunctions(ctx, {
+            maxTimeoutCount: getMaxTimeoutAmount(sandboxOptions),
+            maxIntervalCount: getMaxIntervalAmount(sandboxOptions),
+        });
+        const disposeStep = () => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            eventLoopinterval?.clear();
+            disposeTimer();
+        };
+        try {
+            const jsCode = transpileFile(code);
+            const evalResult = ctx.evalCode(jsCode, filename, {
+                strict: true,
+                strip: false,
+                backtraceBarrier: true,
+                ...evalOptions,
+                type: 'module',
+            });
+            const handle = scope.manage(ctx.unwrapResult(evalResult));
+            const native = handleToNative(ctx, handle, scope);
+            nativePromise = (async () => {
+                const res = await native;
+                return res.default;
+            })();
+            const result = await Promise.race([
+                nativePromise,
+                new Promise((_resolve, reject) => {
+                    if (timeoutMs > 0) {
+                        timeoutId = setTimeout(() => {
+                            timedOut = true;
+                            const err = new Error('The script execution has exceeded the maximum allowed time limit.');
+                            err.name = 'ExecutionTimeout';
+                            reject(err);
+                        }, timeoutMs);
+                    }
+                }),
+            ]);
+            return { ok: true, data: result };
+        }
+        catch (err) {
+            return handleEvalError(err);
+        }
+        finally {
+            if (timedOut && nativePromise) {
+                // Reject unresolved host-injected promises to avoid leaving QuickJS promises
+                // pending while disposing the runtime after timeout.
+                await rejectAndFlushPendingHostPromises(ctx);
+                // Force-fast interrupt handling and give pending guest jobs a short window to settle.
+                ctx.runtime.setInterruptHandler(() => true);
+                const cleanupWait = Math.min(Math.max(timeoutMs, 50), 1000);
+                await Promise.race([
+                    nativePromise.catch(() => undefined),
+                    new Promise(resolve => setTimeout(resolve, cleanupWait)),
+                ]);
+            }
+            disposeStep();
+        }
+    };
+};

package/vendor/quickjs/sandbox/syncVersion/createValidateCodeFunction.d.ts

@@ -0,0 +1,3 @@
+import type { CodeFunctionInput } from '../../types/CodeFunctionInput.js';
+import type { SandboxValidateCode } from '../../types/SandboxValidateCode.js';
+export declare const createValidateCodeFunction: (input: CodeFunctionInput) => SandboxValidateCode;

package/vendor/quickjs/sandbox/syncVersion/createValidateCodeFunction.js

@@ -0,0 +1,22 @@
+import { handleEvalError } from '../handleEvalError.js';
+export const createValidateCodeFunction = (input) => {
+    const { ctx } = input;
+    return async (code, filename = '/src/index.js', evalOptions) => {
+        try {
+            ctx
+                .unwrapResult(ctx.evalCode(code, filename, {
+                strict: true,
+                strip: true,
+                backtraceBarrier: true,
+                ...evalOptions,
+                type: 'module',
+                compileOnly: true,
+            }))
+                .dispose();
+            return { ok: true };
+        }
+        catch (err) {
+            return handleEvalError(err);
+        }
+    };
+};

package/vendor/quickjs/sandbox/syncVersion/executeSandboxFunction.d.ts

@@ -0,0 +1,12 @@
+import type { IFs } from 'memfs';
+import type { QuickJSContext, Scope } from 'quickjs-emscripten-core';
+import type { SandboxFunction } from '../../types/SandboxFunction.js';
+import type { SandboxOptions } from '../../types/SandboxOptions.js';
+export declare const executeSandboxFunction: <T>(input: {
+    ctx: QuickJSContext;
+    fs: IFs;
+    scope: Scope;
+    sandboxOptions: SandboxOptions;
+    sandboxedFunction: SandboxFunction<T>;
+    transpileFile: (input: string) => string;
+}) => Promise<T>;

package/vendor/quickjs/sandbox/syncVersion/executeSandboxFunction.js

@@ -0,0 +1,9 @@
+import { createEvalCodeFunction } from './createEvalCodeFunction.js';
+import { createValidateCodeFunction } from './createValidateCodeFunction.js';
+export const executeSandboxFunction = async (input) => {
+    const { ctx, sandboxOptions, sandboxedFunction, fs, transpileFile } = input;
+    const opt = { ctx, sandboxOptions, transpileFile };
+    const evalCode = createEvalCodeFunction(opt, input.scope);
+    const validateCode = createValidateCodeFunction(opt);
+    return await sandboxedFunction({ ctx, evalCode, validateCode, mountedFs: fs });
+};

package/vendor/quickjs/sandbox/syncVersion/getModuleLoader.d.ts

@@ -0,0 +1,4 @@
+import type { IFs } from 'memfs';
+import type { JSModuleLoader } from 'quickjs-emscripten-core';
+import type { RuntimeOptions } from '../../types/RuntimeOptions.js';
+export declare const getModuleLoader: (fs: IFs, _runtimeOptions: RuntimeOptions) => JSModuleLoader;

package/vendor/quickjs/sandbox/syncVersion/getModuleLoader.js

@@ -0,0 +1,30 @@
+import { join } from 'node:path';
+export const getModuleLoader = (fs, _runtimeOptions) => {
+    const moduleLoader = (inputName, _context) => {
+        let name = inputName;
+        // if it does not exist
+        if (!fs.existsSync(name)) {
+            // try to add the .js extension
+            if (fs.existsSync(`${name}.js`)) {
+                name = `${name}.js`;
+            }
+            else {
+                return { error: new Error(`Module '${inputName}' not installed or available`) };
+            }
+        }
+        // if it is a folder, we need to use the index.js file
+        if (fs.lstatSync(name).isDirectory()) {
+            name = join(name, 'index.js');
+            if (!fs.existsSync(name)) {
+                return { error: new Error(`Module '${inputName}' not installed or available`) };
+            }
+        }
+        // workaround: as we can not provide the real import.meta.url functionality, we replace it dynamically with the current value string
+        const value = fs.readFileSync(name)?.toString().replaceAll('import.meta.url', `'file://${name}'`);
+        if (!value) {
+            return { error: new Error(`Module '${name}' not installed or available`) };
+        }
+        return { value };
+    };
+    return moduleLoader;
+};

package/vendor/quickjs/sandbox/syncVersion/modulePathNormalizer.d.ts

@@ -0,0 +1,2 @@
+import type { JSModuleNormalizer } from 'quickjs-emscripten-core';
+export declare const modulePathNormalizer: JSModuleNormalizer;

package/vendor/quickjs/sandbox/syncVersion/modulePathNormalizer.js

@@ -0,0 +1,12 @@
+import { join, resolve } from 'node:path';
+export const modulePathNormalizer = (baseName, requestedName) => {
+    // relative import
+    if (requestedName.startsWith('.')) {
+        const parts = baseName.split('/');
+        parts.pop();
+        return resolve(`/${parts.join('/')}`, requestedName);
+    }
+    // module import
+    const moduleName = requestedName.replace('node:', '');
+    return join('/node_modules', moduleName);
+};

package/vendor/quickjs/sandbox/syncVersion/prepareNodeCompatibility.d.ts

@@ -0,0 +1,3 @@
+import type { QuickJSContext } from 'quickjs-emscripten-core';
+import type { SandboxOptions } from '../../types/SandboxOptions.js';
+export declare const prepareNodeCompatibility: (vm: QuickJSContext, sandboxOptions: SandboxOptions) => void;

package/vendor/quickjs/sandbox/syncVersion/prepareNodeCompatibility.js

@@ -0,0 +1,11 @@
+export const prepareNodeCompatibility = (vm, sandboxOptions) => {
+    vm.unwrapResult(vm.evalCode(`
+      import 'node:buffer';
+      import 'node:util';
+      import 'node:url';
+      import '@node_compatibility/headers';
+      import '@node_compatibility/request';
+      import '@node_compatibility/response';
+      ${sandboxOptions.enableTestUtils ? "import 'test'" : ''}
+      `, undefined, { type: 'module' })).dispose();
+};

package/vendor/quickjs/sandbox/syncVersion/prepareSandbox.d.ts

@@ -0,0 +1,4 @@
+import type { IFs } from 'memfs';
+import type { QuickJSContext, Scope } from 'quickjs-emscripten-core';
+import type { SandboxBaseOptions } from '../../types/SandboxOptions.js';
+export declare const prepareSandbox: (ctx: QuickJSContext, scope: Scope, sandboxOptions: SandboxBaseOptions, fs: IFs) => void;

package/vendor/quickjs/sandbox/syncVersion/prepareSandbox.js

@@ -0,0 +1,10 @@
+import { provideConsole } from './../provide/provideConsole.js';
+import { provideEnv } from '../provide/provideEnv.js';
+import { provideFs } from '../provide/provideFs.js';
+import { provideHttp } from '../provide/provideHttp.js';
+export const prepareSandbox = (ctx, scope, sandboxOptions, fs) => {
+    provideFs(ctx, scope, sandboxOptions, fs);
+    provideConsole(ctx, scope, sandboxOptions);
+    provideEnv(ctx, scope, sandboxOptions);
+    provideHttp(ctx, scope, sandboxOptions, { fs: sandboxOptions.allowFs ? fs : undefined });
+};

package/vendor/quickjs/types/CodeFunctionInput.d.ts

@@ -0,0 +1,12 @@
+import type { QuickJSAsyncContext, QuickJSContext } from 'quickjs-emscripten-core';
+import type { SandboxAsyncOptions, SandboxOptions } from './SandboxOptions.js';
+export type CodeFunctionInput = {
+    ctx: QuickJSContext;
+    sandboxOptions: SandboxOptions;
+    transpileFile: (input: string) => string;
+};
+export type CodeFunctionAsyncInput = {
+    ctx: QuickJSAsyncContext;
+    sandboxOptions: SandboxAsyncOptions;
+    transpileFile: (input: string) => string;
+};

package/vendor/quickjs/types/CodeFunctionInput.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/ErrorResponse.d.ts

@@ -0,0 +1,9 @@
+export type ErrorResponse = {
+    ok: false;
+    error: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    isSyntaxError?: boolean;
+};

package/vendor/quickjs/types/ErrorResponse.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/LoadQuickJsOptions.d.ts

@@ -0,0 +1,3 @@
+import type { QuickJSAsyncVariant, QuickJSSyncVariant } from 'quickjs-emscripten-core';
+export type LoadQuickJsOptions = QuickJSSyncVariant;
+export type LoadAsyncQuickJsOptions = QuickJSAsyncVariant;

package/vendor/quickjs/types/LoadQuickJsOptions.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/OkResponse.d.ts

@@ -0,0 +1,4 @@
+export type OkResponse<T = unknown> = {
+    ok: true;
+    data: T;
+};

package/vendor/quickjs/types/OkResponse.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/OkResponseCheck.d.ts

@@ -0,0 +1,3 @@
+export type OkResponseCheck = {
+    ok: true;
+};

package/vendor/quickjs/types/OkResponseCheck.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/Prettify.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/vendor/quickjs/types/Prettify.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/RuntimeOptions.d.ts

@@ -0,0 +1,87 @@
+import type { IFs, NestedDirectoryJSON } from 'memfs';
+export type RuntimeOptions = {
+    /**
+     * The maximum time in seconds a script can run.
+     * Unset or set to 0 for unlimited execution time.
+     */
+    executionTimeout?: number;
+    /**
+     * Mount a virtual file system
+     * @link https://github.com/streamich/memfs
+     */
+    mountFs?: NestedDirectoryJSON | IFs;
+    /**
+     * Mount custom node_modules in a virtual file system
+     * @link https://github.com/streamich/memfs
+     */
+    nodeModules?: NestedDirectoryJSON;
+    /**
+     * Enable file capabilities
+     * If enabled, the package node:fs becomes available
+     */
+    allowFs?: boolean;
+    /**
+     * Allow code to make http(s) calls.
+     * When enabled, the global fetch will be available
+     */
+    allowFetch?: boolean;
+    /**
+     * The custom fetch adapter provided as host function in the QuickJS runtime
+     */
+    fetchAdapter?: typeof fetch;
+    /**
+     * Includes test framework
+     * If enabled, the packages chai and mocha become available
+     * They are registered global
+     */
+    enableTestUtils?: boolean;
+    /**
+     * Per default, the console log inside of QuickJS is passed to the host console log.
+     * Here, you can customize the handling and provide your own logging methods.
+     */
+    console?: {
+        log?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        error?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        warn?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        info?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        debug?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        trace?: (message?: unknown, ...optionalParams: unknown[]) => void;
+        assert?: (condition?: boolean, ...data: unknown[]) => void;
+        count?: (label?: string) => void;
+        countReset?: (label?: string) => void;
+        dir?: (item?: unknown, options?: object) => void;
+        dirxml?: (...data: unknown[]) => void;
+        group?: (...label: unknown[]) => void;
+        groupCollapsed?: (...label: unknown[]) => void;
+        groupEnd?: () => void;
+        table?: (tabularData?: unknown, properties?: string[]) => void;
+        time?: (label?: string) => void;
+        timeEnd?: (label?: string) => void;
+        timeLog?: (label?: string, ...data: unknown[]) => void;
+        clear?: () => void;
+    };
+    /**
+     * Key-value list of ENV vars, which should be available in QuickJS
+     * It is not limited to primitives like string and numbers.
+     * Objects, arrays and functions can be provided as well.
+     *
+     * @example
+     * ```js
+     * // in config
+     * {
+     *   env: {
+     *     My_ENV: 'my var'
+     *   }
+     * }
+     *
+     * // inside of QuickJS
+     * console.log(env.My_ENV) // outputs: my var
+     * ```
+     */
+    env?: Record<string, unknown>;
+    /**
+     * The object is synchronized between host and guest system.
+     * This means, the values on the host, can be set by the guest system
+     */
+    dangerousSync?: Record<string, unknown>;
+};

package/vendor/quickjs/types/RuntimeOptions.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/SandboxEvalCode.d.ts

@@ -0,0 +1,5 @@
+import type { ContextEvalOptions } from 'quickjs-emscripten-core';
+import type { ErrorResponse } from './ErrorResponse.js';
+import type { OkResponse } from './OkResponse.js';
+import type { Prettify } from './Prettify.js';
+export type SandboxEvalCode<T = unknown> = (code: string, filename?: string, options?: Prettify<Omit<ContextEvalOptions, 'type'>>) => Promise<OkResponse<T> | ErrorResponse>;

package/vendor/quickjs/types/SandboxEvalCode.js

@@ -0,0 +1 @@
+export {};

package/vendor/quickjs/types/SandboxFunction.d.ts

@@ -0,0 +1,16 @@
+import type { IFs } from 'memfs';
+import type { QuickJSAsyncContext, QuickJSContext } from 'quickjs-emscripten-core';
+import type { SandboxEvalCode } from './SandboxEvalCode.js';
+import type { SandboxValidateCode } from './SandboxValidateCode.js';
+export type SandboxFunction<T = any> = (sandbox: {
+    ctx: QuickJSContext;
+    evalCode: SandboxEvalCode;
+    validateCode: SandboxValidateCode;
+    mountedFs: IFs;
+}) => Promise<T>;
+export type AsyncSandboxFunction<T = any> = (sandbox: {
+    ctx: QuickJSAsyncContext;
+    evalCode: SandboxEvalCode;
+    validateCode: SandboxValidateCode;
+    mountedFs: IFs;
+}) => Promise<T>;

package/vendor/quickjs/types/SandboxFunction.js

@@ -0,0 +1 @@
+export {};