@nodetool-ai/sandbox-runtime 0.0.0-stage → 0.8.9-beta.2

package/vendor/quickjs/sandbox/handleToNative/handleToNative.js

@@ -0,0 +1,153 @@
+import { Scope, } from 'quickjs-emscripten-core';
+import { getHandle } from '../expose/expose.js';
+import { call } from '../helper.js';
+import { getSerializer } from './serializer/index.js';
+/**
+ * Serialize data from guest to host
+ *
+ * @param ctx The sandbox context
+ * @param handle The QuickJS handle to serialize
+ * @returns
+ */
+export const handleToNative = (ctx, handle, rootScope) => {
+    const ty = ctx.typeof(handle);
+    if (ty === 'undefined') {
+        return undefined;
+    }
+    if (ty === 'null') {
+        return null;
+    }
+    if (ty === 'number' || ty === 'string' || ty === 'boolean' || ty === 'bigint') {
+        return ctx.dump(handle);
+    }
+    if (ty === 'symbol') {
+        const desc = ctx.getString(ctx.getProp(handle, 'description'));
+        return Symbol(desc);
+    }
+    const asPromiseState = ctx.getPromiseState(handle);
+    if (asPromiseState.type && !asPromiseState.notAPromise) {
+        return ctx.resolvePromise(handle).then(val => {
+            if (val.error) {
+                const error = handleToNative(ctx, val.error, rootScope);
+                val.error.dispose();
+                return Promise.reject(error);
+            }
+            const value = handleToNative(ctx, val.value, rootScope);
+            val.value.dispose();
+            return Promise.resolve(value);
+        });
+    }
+    // biome-ignore lint/complexity/noBannedTypes: ok here
+    const setProperties = (obj, h) => {
+        ctx
+            .newFunction('', (key, value) => {
+            const keyName = handleToNative(ctx, key, rootScope);
+            if (typeof keyName !== 'string' && typeof keyName !== 'number' && typeof keyName !== 'symbol')
+                return;
+            const desc = [
+                ['value', true],
+                ['get', true],
+                ['set', true],
+                ['configurable', false],
+                ['enumerable', false],
+                ['writable', false],
+            ].reduce((desc, [key, unmarshable]) => {
+                const h = ctx.getProp(value, key);
+                const t = ctx.typeof(h);
+                if (t === 'undefined')
+                    return desc;
+                if (!unmarshable && t === 'boolean') {
+                    desc[key] = ctx.dump(h);
+                    return desc;
+                }
+                desc[key] = handleToNative(ctx, h, rootScope);
+                h.dispose();
+                return desc;
+            }, {});
+            Object.defineProperty(obj, keyName, desc);
+        })
+            .consume(f => {
+            call(ctx, 'internal/serializer/setProperties.js', `(o, fn) => {
+						const descs = Object.getOwnPropertyDescriptors(o);
+						Object.entries(descs).forEach(([k, v]) => fn(k, v));
+						Object.getOwnPropertySymbols(descs).forEach(k => fn(k, descs[k]));
+					}`, undefined, h, f).dispose();
+        });
+    };
+    if (ty === 'function') {
+        if (!rootScope)
+            throw new Error('Missing root scope');
+        const cpHandle = rootScope.manage(handle.dup());
+        const f = function (...args) {
+            const scope = new Scope();
+            const thisHandle = getHandle(scope, ctx, '', this);
+            const argHandles = args.map(a => getHandle(scope, ctx, '', a));
+            if (new.target) {
+                const instance = handleToNative(ctx, call(ctx, 'internal/serializer/newClass.js', '(Cls, ...args) => new Cls(...args)', thisHandle, cpHandle, ...argHandles), rootScope);
+                Object.defineProperties(this, Object.getOwnPropertyDescriptors(instance));
+                scope.dispose();
+                return this;
+            }
+            try {
+                const resultHandle = scope.manage(ctx.unwrapResult(ctx.callFunction(cpHandle, thisHandle, ...argHandles)));
+                const res = handleToNative(ctx, resultHandle, rootScope);
+                return res;
+            }
+            finally {
+                scope.dispose();
+            }
+        };
+        setProperties(f, handle);
+        return f;
+    }
+    if (ty === 'object') {
+        const isNull = call(ctx, 'internal/serializer/isNull.js', 'a => a === null', undefined, handle).consume(r => ctx.dump(r));
+        if (isNull)
+            return null;
+        // Check for Error instances
+        const errorType = call(ctx, 'internal/serializer/detectErrorType.js', `(o) => {
+				try {
+					const tag = Object.prototype.toString.call(o)
+					if (tag.startsWith('[object ') && tag.endsWith(']')) {
+						const type = tag.slice(8, -1)
+						if (type.endsWith('Error')) return type
+					}
+				} catch {}
+				if (typeof o?.name === 'string' && typeof o?.message === 'string') return 'Error'
+				return undefined
+			}`, undefined, handle).consume(r => ctx.dump(r));
+        if (typeof errorType === 'string') {
+            const s = getSerializer(errorType);
+            if (s) {
+                const ret = s(ctx, handle, rootScope);
+                if (ret) {
+                    return ret;
+                }
+            }
+            const messageHandle = ctx.getProp(handle, 'message');
+            const stackHandle = ctx.getProp(handle, 'stack');
+            const message = ctx.dump(messageHandle) ?? '';
+            const stack = ctx.dump(stackHandle);
+            messageHandle.dispose();
+            stackHandle.dispose();
+            const e = new Error(message);
+            e.name = errorType;
+            if (typeof stack === 'string')
+                e.stack = stack;
+            return e;
+        }
+        const isArray = call(ctx, 'internal/serializer/isArray.js', 'Array.isArray', undefined, handle).consume(r => ctx.dump(r));
+        const obj = isArray ? [] : {};
+        const constructorName = call(ctx, 'internal/serializer/getConstructorName.js', `o => typeof o?.constructor?.name === 'string' ? o.constructor.name : undefined`, undefined, handle).consume(r => ctx.dump(r));
+        const serializer = getSerializer(constructorName);
+        if (serializer) {
+            const ret = serializer(ctx, handle, rootScope);
+            if (ret) {
+                return ret;
+            }
+        }
+        setProperties(obj, handle);
+        return obj;
+    }
+    throw new TypeError(`Failed to serialize ${ty}`);
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/index.d.ts

@@ -0,0 +1,10 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializer: Map<string, Serializer>;
+/**
+ * Add a new Serializer
+ */
+export declare const addSerializer: (name: string, fn: Serializer) => Map<string, Serializer>;
+/**
+ * Get a Serializer by constructor name
+ */
+export declare const getSerializer: (name: string) => Serializer | undefined;

package/vendor/quickjs/sandbox/handleToNative/serializer/index.js

@@ -0,0 +1,36 @@
+import { serializeArrayBuffer } from './serializeArrayBuffer.js';
+import { serializeBuffer } from './serializeBuffer.js';
+import { serializeDate } from './serializeDate.js';
+import { serializeError } from './serializeError.js';
+import { serializeHeaders } from './serializeHeaders.js';
+import { serializeMap } from './serializeMap.js';
+import { serializeSet } from './serializeSet.js';
+import { serializeURLSearchParams } from './serializeURLSearchParams.js';
+import { serializeUrl } from './serializeUrl.js';
+export const serializer = new Map();
+/**
+ * Add a new Serializer
+ */
+export const addSerializer = (name, fn) => serializer.set(name, fn);
+/**
+ * Get a Serializer by constructor name
+ */
+export const getSerializer = (name) => serializer.get(name);
+addSerializer('Buffer', serializeBuffer);
+addSerializer('ArrayBuffer', serializeArrayBuffer);
+addSerializer('Map', serializeMap);
+addSerializer('Set', serializeSet);
+addSerializer('Date', serializeDate);
+addSerializer('Headers', serializeHeaders);
+addSerializer('URL', serializeUrl);
+addSerializer('URLSearchParams', serializeURLSearchParams);
+// Errors
+addSerializer('AssertionError', serializeError);
+addSerializer('Error', serializeError);
+addSerializer('EvalError', serializeError);
+addSerializer('RangeError', serializeError);
+addSerializer('ReferenceError', serializeError);
+addSerializer('SyntaxError', serializeError);
+addSerializer('SystemError', serializeError);
+addSerializer('TypeError', serializeError);
+addSerializer('URIError', serializeError);

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeArrayBuffer.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeArrayBuffer: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeArrayBuffer.js

@@ -0,0 +1,4 @@
+export const serializeArrayBuffer = (ctx, handle, _rootScope) => {
+    const b = ctx.getArrayBuffer(handle);
+    return Uint8Array.from(b.value);
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeBuffer.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeBuffer: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeBuffer.js

@@ -0,0 +1,16 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeBuffer = (ctx, handle, rootScope) => {
+    let b;
+    ctx
+        .newFunction('', value => {
+        const v = handleToNative(ctx, value, rootScope);
+        b = Buffer.from(v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeBuffer.js', `(b,fn) => {
+                  fn(b.buffer)
+                }`, undefined, handle, f).dispose();
+    });
+    return b;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeDate.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeDate: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeDate.js

@@ -0,0 +1,16 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeDate = (ctx, handle, rootScope) => {
+    const d = new Date();
+    ctx
+        .newFunction('', value => {
+        const v = handleToNative(ctx, value, rootScope);
+        d.setTime(v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeDate.js', `(d,fn) => {
+                  fn(d.getTime())
+                }`, undefined, handle, f).dispose();
+    });
+    return d;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeError.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeError: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeError.js

@@ -0,0 +1,18 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeError = (ctx, handle, rootScope) => {
+    const d = new Error();
+    ctx
+        .newFunction('serializeError', (value, name) => {
+        const v = handleToNative(ctx, value, rootScope);
+        const n = handleToNative(ctx, name, rootScope);
+        Object.defineProperties(d, v);
+        d.name = n;
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeError.js', `(d,fn) => {
+          fn(Object.getOwnPropertyDescriptors(d),d.name)
+        }`, undefined, handle, f).dispose();
+    });
+    return d;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeHeaders.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeHeaders: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeHeaders.js

@@ -0,0 +1,17 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeHeaders = (ctx, handle, rootScope) => {
+    const h = new Headers();
+    ctx
+        .newFunction('', (value, name) => {
+        const v = handleToNative(ctx, value, rootScope);
+        const n = handleToNative(ctx, name, rootScope);
+        h.append(n, v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeHeaders.js', `(h, fn) => {
+          h.forEach(fn)
+        }`, undefined, handle, f).dispose();
+    });
+    return h;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeMap.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeMap: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeMap.js

@@ -0,0 +1,18 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeMap = (ctx, handle, rootScope) => {
+    const m = new Map();
+    ctx
+        .newFunction('', (key, value) => {
+        const k = handleToNative(ctx, key, rootScope);
+        const v = handleToNative(ctx, value, rootScope);
+        m.set(k, v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeMap.js', `(m,fn) => {
+            for(const [key,value] of m.entries())
+              fn(key,value)
+          }`, undefined, handle, f).dispose();
+    });
+    return m;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeSet.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeSet: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeSet.js

@@ -0,0 +1,16 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeSet = (ctx, handle, rootScope) => {
+    const s = new Set();
+    ctx
+        .newFunction('', value => {
+        const v = handleToNative(ctx, value, rootScope);
+        s.add(v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeSet.js', `(s,fn) => {
+            s.forEach(fn)
+          }`, undefined, handle, f).dispose();
+    });
+    return s;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeURLSearchParams.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeURLSearchParams: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeURLSearchParams.js

@@ -0,0 +1,17 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeURLSearchParams = (ctx, handle, rootScope) => {
+    const h = new URLSearchParams();
+    ctx
+        .newFunction('', (value, name) => {
+        const v = handleToNative(ctx, value, rootScope);
+        const n = handleToNative(ctx, name, rootScope);
+        h.append(n, v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeUrlSearchParams.js', `(h, fn) => {
+          h.forEach(fn)
+        }`, undefined, handle, f).dispose();
+    });
+    return h;
+};

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeUrl.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from '../../../types/Serializer.js';
+export declare const serializeUrl: Serializer;

package/vendor/quickjs/sandbox/handleToNative/serializer/serializeUrl.js

@@ -0,0 +1,17 @@
+import { call } from '../../helper.js';
+import { handleToNative } from '../handleToNative.js';
+export const serializeUrl = (ctx, handle, rootScope) => {
+    let d;
+    ctx
+        .newFunction('', value => {
+        const v = handleToNative(ctx, value, rootScope);
+        d = new URL(v);
+    })
+        .consume(f => {
+        call(ctx, 'internal/serializer/serializeUrl.js', `(d,fn) => {
+           fn(d.toJSON())
+        }`, undefined, handle, f).dispose();
+    });
+    return d;
+};
+URLSearchParams;

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

@@ -0,0 +1,2 @@
+import type { QuickJSAsyncContext, QuickJSContext, QuickJSHandle } from 'quickjs-emscripten-core';
+export declare const call: (ctx: QuickJSContext | QuickJSAsyncContext, fileName: string, code: string, that: QuickJSHandle | undefined, ...args: QuickJSHandle[]) => QuickJSHandle;

package/vendor/quickjs/sandbox/helper.js

@@ -0,0 +1,14 @@
+export const call = (ctx, fileName, code, that, ...args) => {
+    const fnHandle = ctx.unwrapResult(ctx.evalCode(code, fileName));
+    try {
+        const callHandle = ctx.unwrapResult(ctx.callFunction(fnHandle, that || ctx.undefined, ...args));
+        fnHandle.dispose();
+        return callHandle;
+    }
+    catch (error) {
+        console.error(error);
+        const e = new Error(error.message ?? 'Function call failed in serialization');
+        e.cause = error;
+        throw e;
+    }
+};

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

@@ -0,0 +1,6 @@
+import type { QuickJSAsyncContext, QuickJSContext, Scope } from 'quickjs-emscripten-core';
+import type { RuntimeOptions } from '../../types/RuntimeOptions.js';
+/**
+ * Provide all Node.js console methods
+ */
+export declare const provideConsole: (ctx: QuickJSContext | QuickJSAsyncContext, scope: Scope, options: RuntimeOptions) => void;

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

@@ -0,0 +1,53 @@
+import { expose } from '../expose/expose.js';
+/**
+ * Provide all Node.js console methods
+ */
+export const provideConsole = (ctx, scope, options) => {
+    const logger = {
+        log: (...params) => console.log(...params),
+        error: (...params) => console.error(...params),
+        warn: (...params) => console.warn(...params),
+        info: (...params) => console.info(...params),
+        debug: (...params) => console.debug(...params),
+        trace: (...params) => console.trace(...params),
+        assert: (...params) => console.assert(...params),
+        count: (...params) => console.count(...params),
+        countReset: (...params) => console.countReset(...params),
+        dir: (...params) => console.dir(...params),
+        dirxml: (...params) => console.dirxml(...params),
+        group: (...params) => console.group(...params),
+        groupCollapsed: (...params) => console.groupCollapsed(...params),
+        groupEnd: () => console.groupEnd(),
+        table: (...params) => console.table(...params),
+        time: (...params) => console.time(...params),
+        timeEnd: (...params) => console.timeEnd(...params),
+        timeLog: (...params) => console.timeLog(...params),
+        clear: () => {
+            throw new Error('console.clear is disabled for security reasons by default');
+        },
+        ...options.console,
+    };
+    expose(ctx, scope, {
+        console: {
+            log: logger.log,
+            error: logger.error,
+            warn: logger.warn,
+            info: logger.info,
+            debug: logger.debug,
+            trace: logger.trace,
+            assert: logger.assert,
+            count: logger.count,
+            countReset: logger.countReset,
+            dir: logger.dir,
+            dirxml: logger.dirxml,
+            group: logger.group,
+            groupCollapsed: logger.groupCollapsed,
+            groupEnd: logger.groupEnd,
+            table: logger.table,
+            time: logger.time,
+            timeEnd: logger.timeEnd,
+            timeLog: logger.timeLog,
+            clear: logger.clear,
+        },
+    });
+};

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

@@ -0,0 +1,3 @@
+import type { QuickJSAsyncContext, QuickJSContext, Scope } from 'quickjs-emscripten-core';
+import type { RuntimeOptions } from '../../types/RuntimeOptions.js';
+export declare const provideEnv: (ctx: QuickJSContext | QuickJSAsyncContext, scope: Scope, options: RuntimeOptions) => void;

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

@@ -0,0 +1,10 @@
+import { expose } from '../expose/expose.js';
+export const provideEnv = (ctx, scope, options) => {
+    expose(ctx, scope, {
+        env: options.env ?? {},
+        process: {
+            env: options.env ?? { NODE_DEBUG: 'true' },
+            cwd: () => '/',
+        },
+    });
+};

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

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

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

@@ -0,0 +1,159 @@
+import { expose } from '../expose/expose.js';
+export const provideFs = (ctx, scope, runtimeOptions, fs) => {
+    const disabledFn = (..._params) => {
+        throw new Error('File access is disabled');
+    };
+    const enabledFileSystem = {
+        access: (...params) => fs.access(...params),
+        accessSync: (...params) => fs.accessSync(...params),
+        appendFile: (...params) => fs.appendFile(...params),
+        appendFileSync: (...params) => fs.appendFileSync(...params),
+        chmod: (...params) => fs.chmod(...params),
+        chmodSync: (...params) => fs.chmodSync(...params),
+        chown: (...params) => fs.chown(...params),
+        chownSync: (...params) => fs.chownSync(...params),
+        close: (...params) => fs.close(...params),
+        closeSync: (...params) => fs.closeSync(...params),
+        copyFile: (...params) => fs.copyFile(...params),
+        copyFileSync: (...params) => fs.copyFileSync(...params),
+        createReadStream: (...params) => fs.createReadStream(...params),
+        createWriteStream: (...params) => fs.createWriteStream(...params),
+        exists: (...params) => fs.exists(...params),
+        existsSync: (...params) => fs.existsSync(...params),
+        fchmod: (...params) => fs.fchmod(...params),
+        fchmodSync: (...params) => fs.fchmodSync(...params),
+        fchown: (...params) => fs.fchown(...params),
+        fchownSync: (...params) => fs.fchownSync(...params),
+        fdatasync: (...params) => fs.fdatasync(...params),
+        fdatasyncSync: (...params) => fs.fdatasyncSync(...params),
+        fstat: (...params) => fs.fstat(...params),
+        fstatSync: (...params) => fs.fstatSync(...params),
+        fsync: (...params) => fs.fsync(...params),
+        fsyncSync: (...params) => fs.fsyncSync(...params),
+        ftruncate: (...params) => fs.ftruncate(...params),
+        ftruncateSync: (...params) => fs.ftruncateSync(...params),
+        futimes: (...params) => fs.futimes(...params),
+        futimesSync: (...params) => fs.futimesSync(...params),
+        lchmod: (...params) => fs.lchmod(...params),
+        lchmodSync: (...params) => fs.lchmodSync(...params),
+        lchown: (...params) => fs.lchown(...params),
+        lchownSync: (...params) => fs.lchownSync(...params),
+        link: (...params) => fs.link(...params),
+        linkSync: (...params) => fs.linkSync(...params),
+        lstat: (...params) => fs.lstat(...params),
+        lstatSync: (...params) => fs.lstatSync(...params),
+        mkdir: (...params) => fs.mkdir(...params),
+        mkdirSync: (...params) => fs.mkdirSync(...params),
+        mkdtemp: (...params) => fs.mkdtemp(...params),
+        mkdtempSync: (...params) => fs.mkdtempSync(...params),
+        open: (...params) => fs.open(...params),
+        openSync: (...params) => fs.openSync(...params),
+        readdir: (...params) => fs.readdir(...params),
+        readdirSync: (...params) => fs.readdirSync(...params),
+        read: (...params) => fs.read(...params),
+        readSync: (...params) => fs.readSync(...params),
+        readFile: (...params) => fs.readFile(...params),
+        readFileSync: (...params) => fs.readFileSync(...params).toString(),
+        readlink: (...params) => fs.readlink(...params),
+        readlinkSync: (...params) => fs.readlinkSync(...params),
+        realpath: (...params) => fs.realpath(...params),
+        realpathSync: (...params) => fs.realpathSync(...params),
+        rename: (...params) => fs.rename(...params),
+        renameSync: (...params) => fs.renameSync(...params),
+        rmdir: (...params) => fs.rmdir(...params),
+        rmdirSync: (...params) => fs.rmdirSync(...params),
+        stat: (...params) => fs.stat(...params),
+        statSync: (...params) => fs.statSync(...params),
+        symlink: (...params) => fs.symlink(...params),
+        symlinkSync: (...params) => fs.symlinkSync(...params),
+        truncate: (...params) => fs.truncate(...params),
+        truncateSync: (...params) => fs.truncateSync(...params),
+        unlink: (...params) => fs.unlink(...params),
+        unlinkSync: (...params) => fs.unlinkSync(...params),
+        utimes: (...params) => fs.utimes(...params),
+        utimesSync: (...params) => fs.utimesSync(...params),
+        write: (...params) => fs.write(...params),
+        writeSync: (...params) => fs.writeSync(...params),
+        writeFile: (...params) => fs.writeFile(...params),
+        writeFileSync: (...params) => {
+            fs.writeFileSync(...params);
+        },
+    };
+    const disabledFileSystem = {
+        access: disabledFn,
+        accessSync: disabledFn,
+        appendFile: disabledFn,
+        appendFileSync: disabledFn,
+        chmod: disabledFn,
+        chmodSync: disabledFn,
+        chown: disabledFn,
+        chownSync: disabledFn,
+        close: disabledFn,
+        closeSync: disabledFn,
+        copyFile: disabledFn,
+        copyFileSync: disabledFn,
+        createReadStream: disabledFn,
+        createWriteStream: disabledFn,
+        exists: disabledFn,
+        existsSync: disabledFn,
+        fchmod: disabledFn,
+        fchmodSync: disabledFn,
+        fchown: disabledFn,
+        fchownSync: disabledFn,
+        fdatasync: disabledFn,
+        fdatasyncSync: disabledFn,
+        fstat: disabledFn,
+        fstatSync: disabledFn,
+        fsync: disabledFn,
+        fsyncSync: disabledFn,
+        ftruncate: disabledFn,
+        ftruncateSync: disabledFn,
+        futimes: disabledFn,
+        futimesSync: disabledFn,
+        lchmod: disabledFn,
+        lchmodSync: disabledFn,
+        lchown: disabledFn,
+        lchownSync: disabledFn,
+        link: disabledFn,
+        linkSync: disabledFn,
+        lstat: disabledFn,
+        lstatSync: disabledFn,
+        mkdir: disabledFn,
+        mkdirSync: disabledFn,
+        mkdtemp: disabledFn,
+        mkdtempSync: disabledFn,
+        open: disabledFn,
+        openSync: disabledFn,
+        readdir: disabledFn,
+        readdirSync: disabledFn,
+        read: disabledFn,
+        readSync: disabledFn,
+        readFile: disabledFn,
+        readFileSync: disabledFn,
+        readlink: disabledFn,
+        readlinkSync: disabledFn,
+        realpath: disabledFn,
+        realpathSync: disabledFn,
+        rename: disabledFn,
+        renameSync: disabledFn,
+        rmdir: disabledFn,
+        rmdirSync: disabledFn,
+        stat: disabledFn,
+        statSync: disabledFn,
+        symlink: disabledFn,
+        symlinkSync: disabledFn,
+        truncate: disabledFn,
+        truncateSync: disabledFn,
+        unlink: disabledFn,
+        unlinkSync: disabledFn,
+        utimes: disabledFn,
+        utimesSync: disabledFn,
+        write: disabledFn,
+        writeSync: disabledFn,
+        writeFile: disabledFn,
+        writeFileSync: disabledFn,
+    };
+    expose(ctx, scope, {
+        __fs: runtimeOptions.allowFs ? enabledFileSystem : disabledFileSystem,
+    });
+};