@secure-exec/nodejs 0.2.0-rc.1

package/dist/bridge/fs.js

@@ -0,0 +1,3307 @@
+// fs polyfill module for the sandbox
+// This module runs inside the isolate and provides Node.js fs API compatibility
+// It communicates with the host via the _fs Reference object
+import { Buffer } from "buffer";
+const O_RDONLY = 0;
+const O_WRONLY = 1;
+const O_RDWR = 2;
+const O_CREAT = 64;
+const O_EXCL = 128;
+const O_TRUNC = 512;
+const O_APPEND = 1024;
+// Stats class
+class Stats {
+    dev;
+    ino;
+    mode;
+    nlink;
+    uid;
+    gid;
+    rdev;
+    size;
+    blksize;
+    blocks;
+    atimeMs;
+    mtimeMs;
+    ctimeMs;
+    birthtimeMs;
+    atime;
+    mtime;
+    ctime;
+    birthtime;
+    constructor(init) {
+        this.dev = init.dev ?? 0;
+        this.ino = init.ino ?? 0;
+        this.mode = init.mode;
+        this.nlink = init.nlink ?? 1;
+        this.uid = init.uid ?? 0;
+        this.gid = init.gid ?? 0;
+        this.rdev = init.rdev ?? 0;
+        this.size = init.size;
+        this.blksize = init.blksize ?? 4096;
+        this.blocks = init.blocks ?? Math.ceil(init.size / 512);
+        this.atimeMs = init.atimeMs ?? Date.now();
+        this.mtimeMs = init.mtimeMs ?? Date.now();
+        this.ctimeMs = init.ctimeMs ?? Date.now();
+        this.birthtimeMs = init.birthtimeMs ?? Date.now();
+        this.atime = new Date(this.atimeMs);
+        this.mtime = new Date(this.mtimeMs);
+        this.ctime = new Date(this.ctimeMs);
+        this.birthtime = new Date(this.birthtimeMs);
+    }
+    isFile() {
+        return (this.mode & 61440) === 32768;
+    }
+    isDirectory() {
+        return (this.mode & 61440) === 16384;
+    }
+    isSymbolicLink() {
+        return (this.mode & 61440) === 40960;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+// Dirent class for readdir with withFileTypes
+class Dirent {
+    name;
+    parentPath;
+    path; // Deprecated alias for parentPath
+    _isDir;
+    constructor(name, isDir, parentPath = "") {
+        this.name = name;
+        this._isDir = isDir;
+        this.parentPath = parentPath;
+        this.path = parentPath;
+    }
+    isFile() {
+        return !this._isDir;
+    }
+    isDirectory() {
+        return this._isDir;
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+// Dir class for opendir — async-iterable directory handle
+class Dir {
+    path;
+    _entries = null;
+    _index = 0;
+    _closed = false;
+    constructor(dirPath) {
+        this.path = dirPath;
+    }
+    _load() {
+        if (this._entries === null) {
+            this._entries = fs.readdirSync(this.path, { withFileTypes: true });
+        }
+        return this._entries;
+    }
+    readSync() {
+        if (this._closed)
+            throw new Error("Directory handle was closed");
+        const entries = this._load();
+        if (this._index >= entries.length)
+            return null;
+        return entries[this._index++];
+    }
+    async read() {
+        return this.readSync();
+    }
+    closeSync() {
+        this._closed = true;
+    }
+    async close() {
+        this.closeSync();
+    }
+    async *[Symbol.asyncIterator]() {
+        const entries = this._load();
+        for (const entry of entries) {
+            if (this._closed)
+                return;
+            yield entry;
+        }
+        this._closed = true;
+    }
+}
+const FILE_HANDLE_READ_CHUNK_BYTES = 64 * 1024;
+const FILE_HANDLE_READ_BUFFER_BYTES = 16 * 1024;
+const FILE_HANDLE_MAX_READ_BYTES = 2 ** 31 - 1;
+function createAbortError(reason) {
+    const error = new Error("The operation was aborted");
+    error.name = "AbortError";
+    error.code = "ABORT_ERR";
+    if (reason !== undefined) {
+        error.cause = reason;
+    }
+    return error;
+}
+function validateAbortSignal(signal) {
+    if (signal === undefined) {
+        return undefined;
+    }
+    if (signal === null ||
+        typeof signal !== "object" ||
+        typeof signal.aborted !== "boolean" ||
+        typeof signal.addEventListener !== "function" ||
+        typeof signal.removeEventListener !== "function") {
+        const error = new TypeError('The "signal" argument must be an instance of AbortSignal');
+        error.code = "ERR_INVALID_ARG_TYPE";
+        throw error;
+    }
+    return signal;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal.reason);
+    }
+}
+function waitForNextTick() {
+    return new Promise((resolve) => process.nextTick(resolve));
+}
+function createInternalAssertionError(message) {
+    const error = new Error(message);
+    error.code = "ERR_INTERNAL_ASSERTION";
+    return error;
+}
+function createOutOfRangeError(name, range, received) {
+    const error = new RangeError(`The value of "${name}" is out of range. It must be ${range}. Received ${String(received)}`);
+    error.code = "ERR_OUT_OF_RANGE";
+    return error;
+}
+function formatInvalidArgReceived(actual) {
+    if (actual === null) {
+        return "Received null";
+    }
+    if (actual === undefined) {
+        return "Received undefined";
+    }
+    if (typeof actual === "string") {
+        return `Received type string ('${actual}')`;
+    }
+    if (typeof actual === "number") {
+        return `Received type number (${String(actual)})`;
+    }
+    if (typeof actual === "boolean") {
+        return `Received type boolean (${String(actual)})`;
+    }
+    if (typeof actual === "bigint") {
+        return `Received type bigint (${actual.toString()}n)`;
+    }
+    if (typeof actual === "symbol") {
+        return `Received type symbol (${String(actual)})`;
+    }
+    if (typeof actual === "function") {
+        return actual.name ? `Received function ${actual.name}` : "Received function";
+    }
+    if (Array.isArray(actual)) {
+        return "Received an instance of Array";
+    }
+    if (actual && typeof actual === "object") {
+        const constructorName = actual.constructor?.name;
+        if (constructorName) {
+            return `Received an instance of ${constructorName}`;
+        }
+    }
+    return `Received type ${typeof actual} (${String(actual)})`;
+}
+function createInvalidArgTypeError(name, expected, actual) {
+    const error = new TypeError(`The "${name}" argument must be ${expected}. ${formatInvalidArgReceived(actual)}`);
+    error.code = "ERR_INVALID_ARG_TYPE";
+    return error;
+}
+function createInvalidArgValueError(name, message) {
+    const error = new TypeError(`The argument '${name}' ${message}`);
+    error.code = "ERR_INVALID_ARG_VALUE";
+    return error;
+}
+function createInvalidEncodingError(encoding) {
+    const printable = typeof encoding === "string"
+        ? `'${encoding}'`
+        : encoding === undefined
+            ? "undefined"
+            : encoding === null
+                ? "null"
+                : String(encoding);
+    const error = new TypeError(`The argument 'encoding' is invalid encoding. Received ${printable}`);
+    error.code = "ERR_INVALID_ARG_VALUE";
+    return error;
+}
+function toUint8ArrayChunk(chunk, encoding) {
+    if (typeof chunk === "string") {
+        return Buffer.from(chunk, encoding ?? "utf8");
+    }
+    if (Buffer.isBuffer(chunk)) {
+        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    }
+    if (chunk instanceof Uint8Array) {
+        return chunk;
+    }
+    if (ArrayBuffer.isView(chunk)) {
+        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    }
+    throw createInvalidArgTypeError("data", "a string, Buffer, TypedArray, or DataView", chunk);
+}
+async function* iterateWriteChunks(data, encoding) {
+    if (typeof data === "string" || ArrayBuffer.isView(data)) {
+        yield toUint8ArrayChunk(data, encoding);
+        return;
+    }
+    if (data && typeof data[Symbol.asyncIterator] === "function") {
+        for await (const chunk of data) {
+            yield toUint8ArrayChunk(chunk, encoding);
+        }
+        return;
+    }
+    if (data && typeof data[Symbol.iterator] === "function") {
+        for (const chunk of data) {
+            yield toUint8ArrayChunk(chunk, encoding);
+        }
+        return;
+    }
+    throw createInvalidArgTypeError("data", "a string, Buffer, TypedArray, DataView, or Iterable", data);
+}
+class FileHandle {
+    _fd;
+    _closing = false;
+    _closed = false;
+    _listeners = new Map();
+    constructor(fd) {
+        this._fd = fd;
+    }
+    static _assertHandle(handle) {
+        if (!(handle instanceof FileHandle)) {
+            throw createInternalAssertionError("handle must be an instance of FileHandle");
+        }
+        return handle;
+    }
+    _emitCloseOnce() {
+        if (this._closed) {
+            this._fd = -1;
+            this.emit("close");
+            return;
+        }
+        this._closed = true;
+        this._fd = -1;
+        this.emit("close");
+    }
+    _resolvePath() {
+        if (this._fd < 0) {
+            return null;
+        }
+        return _fdGetPath.applySync(undefined, [this._fd]);
+    }
+    get fd() {
+        return this._fd;
+    }
+    get closed() {
+        return this._closed;
+    }
+    on(event, listener) {
+        const listeners = this._listeners.get(event) ?? [];
+        listeners.push(listener);
+        this._listeners.set(event, listeners);
+        return this;
+    }
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+        wrapper._originalListener = listener;
+        return this.on(event, wrapper);
+    }
+    off(event, listener) {
+        const listeners = this._listeners.get(event);
+        if (!listeners) {
+            return this;
+        }
+        const index = listeners.findIndex((candidate) => candidate === listener ||
+            candidate._originalListener === listener);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    emit(event, ...args) {
+        const listeners = this._listeners.get(event);
+        if (!listeners || listeners.length === 0) {
+            return false;
+        }
+        for (const listener of listeners.slice()) {
+            listener(...args);
+        }
+        return true;
+    }
+    async close() {
+        const handle = FileHandle._assertHandle(this);
+        if (handle._closing || handle._closed) {
+            if (handle._fd < 0) {
+                throw createFsError("EBADF", "EBADF: bad file descriptor, close", "close");
+            }
+        }
+        handle._closing = true;
+        try {
+            fs.closeSync(handle._fd);
+            handle._emitCloseOnce();
+        }
+        finally {
+            handle._closing = false;
+        }
+    }
+    async stat() {
+        const handle = FileHandle._assertHandle(this);
+        return fs.fstatSync(handle.fd);
+    }
+    async sync() {
+        const handle = FileHandle._assertHandle(this);
+        fs.fsyncSync(handle.fd);
+    }
+    async datasync() {
+        return this.sync();
+    }
+    async truncate(len) {
+        const handle = FileHandle._assertHandle(this);
+        fs.ftruncateSync(handle.fd, len);
+    }
+    async chmod(mode) {
+        const handle = FileHandle._assertHandle(this);
+        const path = handle._resolvePath();
+        if (!path) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "chmod");
+        }
+        fs.chmodSync(path, mode);
+    }
+    async chown(uid, gid) {
+        const handle = FileHandle._assertHandle(this);
+        const path = handle._resolvePath();
+        if (!path) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "chown");
+        }
+        fs.chownSync(path, uid, gid);
+    }
+    async utimes(atime, mtime) {
+        const handle = FileHandle._assertHandle(this);
+        const path = handle._resolvePath();
+        if (!path) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "utimes");
+        }
+        fs.utimesSync(path, atime, mtime);
+    }
+    async read(buffer, offset, length, position) {
+        const handle = FileHandle._assertHandle(this);
+        let target = buffer;
+        if (target === null) {
+            target = Buffer.alloc(FILE_HANDLE_READ_BUFFER_BYTES);
+        }
+        if (!ArrayBuffer.isView(target)) {
+            throw createInvalidArgTypeError("buffer", "an instance of ArrayBufferView", target);
+        }
+        const readOffset = offset ?? 0;
+        const readLength = length ?? (target.byteLength - readOffset);
+        const bytesRead = fs.readSync(handle.fd, target, readOffset, readLength, position ?? null);
+        return { bytesRead, buffer: target };
+    }
+    async write(buffer, offsetOrPosition, lengthOrEncoding, position) {
+        const handle = FileHandle._assertHandle(this);
+        if (typeof buffer === "string") {
+            const encoding = typeof lengthOrEncoding === "string" ? lengthOrEncoding : "utf8";
+            if (encoding === "hex" && buffer.length % 2 !== 0) {
+                throw createInvalidArgValueError("encoding", `is invalid for data of length ${buffer.length}`);
+            }
+            const bytesWritten = fs.writeSync(handle.fd, Buffer.from(buffer, encoding), 0, undefined, offsetOrPosition ?? null);
+            return { bytesWritten, buffer };
+        }
+        if (!ArrayBuffer.isView(buffer)) {
+            throw createInvalidArgTypeError("buffer", "a string, Buffer, TypedArray, or DataView", buffer);
+        }
+        const offset = offsetOrPosition ?? 0;
+        const length = typeof lengthOrEncoding === "number" ? lengthOrEncoding : undefined;
+        const bytesWritten = fs.writeSync(handle.fd, buffer, offset, length, position ?? null);
+        return { bytesWritten, buffer };
+    }
+    async readFile(options) {
+        const handle = FileHandle._assertHandle(this);
+        const normalized = typeof options === "string" ? { encoding: options } : (options ?? undefined);
+        const signal = validateAbortSignal(normalized?.signal);
+        const encoding = normalized?.encoding ?? undefined;
+        const stats = await handle.stat();
+        if (stats.size > FILE_HANDLE_MAX_READ_BYTES) {
+            const error = new RangeError("File size is greater than 2 GiB");
+            error.code = "ERR_FS_FILE_TOO_LARGE";
+            throw error;
+        }
+        await waitForNextTick();
+        throwIfAborted(signal);
+        const chunks = [];
+        let totalLength = 0;
+        while (true) {
+            throwIfAborted(signal);
+            const chunk = Buffer.alloc(FILE_HANDLE_READ_CHUNK_BYTES);
+            const { bytesRead } = await handle.read(chunk, 0, chunk.byteLength, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            chunks.push(chunk.subarray(0, bytesRead));
+            totalLength += bytesRead;
+            if (totalLength > FILE_HANDLE_MAX_READ_BYTES) {
+                const error = new RangeError("File size is greater than 2 GiB");
+                error.code = "ERR_FS_FILE_TOO_LARGE";
+                throw error;
+            }
+            await waitForNextTick();
+        }
+        const result = Buffer.concat(chunks, totalLength);
+        return encoding ? result.toString(encoding) : result;
+    }
+    async writeFile(data, options) {
+        const handle = FileHandle._assertHandle(this);
+        const normalized = typeof options === "string" ? { encoding: options } : (options ?? undefined);
+        const signal = validateAbortSignal(normalized?.signal);
+        const encoding = normalized?.encoding ?? undefined;
+        await waitForNextTick();
+        throwIfAborted(signal);
+        for await (const chunk of iterateWriteChunks(data, encoding)) {
+            throwIfAborted(signal);
+            await handle.write(chunk, 0, chunk.byteLength, undefined);
+            await waitForNextTick();
+        }
+    }
+    async appendFile(data, options) {
+        return this.writeFile(data, options);
+    }
+    createReadStream(options) {
+        FileHandle._assertHandle(this);
+        return new ReadStream(null, { ...(options ?? {}), fd: this });
+    }
+    createWriteStream(options) {
+        FileHandle._assertHandle(this);
+        return new WriteStream(null, { ...(options ?? {}), fd: this });
+    }
+}
+function isArrayBufferView(value) {
+    return ArrayBuffer.isView(value);
+}
+function createInvalidPropertyTypeError(propertyPath, actual) {
+    let received;
+    if (actual === null) {
+        received = "Received null";
+    }
+    else if (typeof actual === "string") {
+        received = `Received type string ('${actual}')`;
+    }
+    else {
+        received = `Received type ${typeof actual} (${String(actual)})`;
+    }
+    const error = new TypeError(`The "${propertyPath}" property must be of type function. ${received}`);
+    error.code = "ERR_INVALID_ARG_TYPE";
+    return error;
+}
+function validateCallback(callback, name = "cb") {
+    if (typeof callback !== "function") {
+        throw createInvalidArgTypeError(name, "of type function", callback);
+    }
+}
+function validateEncodingValue(encoding) {
+    if (encoding === undefined || encoding === null) {
+        return;
+    }
+    if (typeof encoding !== "string" || !Buffer.isEncoding(encoding)) {
+        throw createInvalidEncodingError(encoding);
+    }
+}
+function validateEncodingOption(options) {
+    if (typeof options === "string") {
+        validateEncodingValue(options);
+        return;
+    }
+    if (options && typeof options === "object" && "encoding" in options) {
+        validateEncodingValue(options.encoding);
+    }
+}
+function normalizePathLike(path, name = "path") {
+    if (typeof path === "string") {
+        return path;
+    }
+    if (Buffer.isBuffer(path)) {
+        return path.toString("utf8");
+    }
+    if (path instanceof URL) {
+        if (path.protocol === "file:") {
+            return path.pathname;
+        }
+        throw createInvalidArgTypeError(name, "of type string or an instance of Buffer or URL", path);
+    }
+    throw createInvalidArgTypeError(name, "of type string or an instance of Buffer or URL", path);
+}
+function tryNormalizeExistsPath(path) {
+    try {
+        return normalizePathLike(path);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNumberArgument(name, value, options = {}) {
+    const { min = 0, max = 0x7fffffff, allowNegativeOne = false } = options;
+    if (typeof value !== "number") {
+        throw createInvalidArgTypeError(name, "of type number", value);
+    }
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw createOutOfRangeError(name, "an integer", value);
+    }
+    if ((allowNegativeOne && value === -1) || (value >= min && value <= max)) {
+        return value;
+    }
+    throw createOutOfRangeError(name, `>= ${min} && <= ${max}`, value);
+}
+function normalizeModeArgument(mode, name = "mode") {
+    if (typeof mode === "string") {
+        if (!/^[0-7]+$/.test(mode)) {
+            throw createInvalidArgValueError(name, "must be a 32-bit unsigned integer or an octal string. Received '" + mode + "'");
+        }
+        return parseInt(mode, 8);
+    }
+    return normalizeNumberArgument(name, mode, { min: 0, max: 0xffffffff });
+}
+function normalizeOpenModeArgument(mode) {
+    if (mode === undefined || mode === null) {
+        return undefined;
+    }
+    return normalizeModeArgument(mode);
+}
+function validateWriteStreamStartOption(options) {
+    if (options?.start === undefined) {
+        return;
+    }
+    if (typeof options.start !== "number") {
+        throw createInvalidArgTypeError("start", "of type number", options.start);
+    }
+    if (!Number.isFinite(options.start) || !Number.isInteger(options.start) || options.start < 0) {
+        throw createOutOfRangeError("start", ">= 0", options.start);
+    }
+}
+function validateBooleanOption(name, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw createInvalidArgTypeError(name, "of type boolean", value);
+    }
+    return value;
+}
+function validateAbortSignalOption(name, signal) {
+    if (signal === undefined) {
+        return undefined;
+    }
+    if (signal === null ||
+        typeof signal !== "object" ||
+        typeof signal.aborted !== "boolean" ||
+        typeof signal.addEventListener !== "function" ||
+        typeof signal.removeEventListener !== "function") {
+        const error = new TypeError(`The "${name}" property must be an instance of AbortSignal. ${formatInvalidArgReceived(signal)}`);
+        error.code = "ERR_INVALID_ARG_TYPE";
+        throw error;
+    }
+    return signal;
+}
+function createUnsupportedWatcherError(api) {
+    return new Error(`fs.${api} is not supported in sandbox — use polling`);
+}
+function normalizeWatchOptions(options, allowString) {
+    let normalized;
+    if (options === undefined || options === null) {
+        normalized = {};
+    }
+    else if (typeof options === "string") {
+        if (!allowString) {
+            throw createInvalidArgTypeError("options", "of type object", options);
+        }
+        validateEncodingValue(options);
+        normalized = { encoding: options };
+    }
+    else if (typeof options === "object") {
+        normalized = options;
+    }
+    else {
+        throw createInvalidArgTypeError("options", allowString ? "one of type string or object" : "of type object", options);
+    }
+    validateBooleanOption("options.persistent", normalized.persistent);
+    validateBooleanOption("options.recursive", normalized.recursive);
+    validateEncodingOption(normalized);
+    const signal = validateAbortSignalOption("options.signal", normalized.signal);
+    return {
+        persistent: normalized.persistent,
+        recursive: normalized.recursive,
+        encoding: normalized.encoding,
+        signal,
+    };
+}
+function normalizeWatchArguments(path, optionsOrListener, listener) {
+    normalizePathLike(path);
+    let options = optionsOrListener;
+    let resolvedListener = listener;
+    if (typeof optionsOrListener === "function") {
+        options = undefined;
+        resolvedListener = optionsOrListener;
+    }
+    if (resolvedListener !== undefined && typeof resolvedListener !== "function") {
+        throw createInvalidArgTypeError("listener", "of type function", resolvedListener);
+    }
+    return normalizeWatchOptions(options, true);
+}
+function normalizeWatchFileArguments(path, optionsOrListener, listener) {
+    normalizePathLike(path);
+    let options = {};
+    let resolvedListener = listener;
+    if (typeof optionsOrListener === "function") {
+        resolvedListener = optionsOrListener;
+    }
+    else if (optionsOrListener === undefined || optionsOrListener === null) {
+        options = {};
+    }
+    else if (typeof optionsOrListener === "object") {
+        options = optionsOrListener;
+    }
+    else {
+        throw createInvalidArgTypeError("listener", "of type function", optionsOrListener);
+    }
+    if (typeof resolvedListener !== "function") {
+        throw createInvalidArgTypeError("listener", "of type function", resolvedListener);
+    }
+    if (options.interval !== undefined && typeof options.interval !== "number") {
+        throw createInvalidArgTypeError("interval", "of type number", options.interval);
+    }
+}
+async function* createUnsupportedPromisesWatchIterator(path, options) {
+    const normalized = normalizeWatchOptions(options, false);
+    normalizePathLike(path);
+    throwIfAborted(normalized.signal);
+    throw createUnsupportedWatcherError("promises.watch");
+}
+function isReadWriteOptionsObject(value) {
+    return value === null || value === undefined || (typeof value === "object" && !Array.isArray(value));
+}
+function normalizeOptionalPosition(value) {
+    if (value === undefined || value === null || value === -1) {
+        return null;
+    }
+    if (typeof value === "bigint") {
+        return Number(value);
+    }
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw createInvalidArgTypeError("position", "an integer", value);
+    }
+    return value;
+}
+function normalizeOffsetLength(bufferByteLength, offsetValue, lengthValue) {
+    const offset = offsetValue ?? 0;
+    if (typeof offset !== "number" || !Number.isInteger(offset)) {
+        throw createInvalidArgTypeError("offset", "an integer", offset);
+    }
+    if (offset < 0 || offset > bufferByteLength) {
+        throw createOutOfRangeError("offset", `>= 0 && <= ${bufferByteLength}`, offset);
+    }
+    const defaultLength = bufferByteLength - offset;
+    const length = lengthValue ?? defaultLength;
+    if (typeof length !== "number" || !Number.isInteger(length)) {
+        throw createInvalidArgTypeError("length", "an integer", length);
+    }
+    if (length < 0 || length > 0x7fffffff) {
+        throw createOutOfRangeError("length", ">= 0 && <= 2147483647", length);
+    }
+    if (offset + length > bufferByteLength) {
+        throw createOutOfRangeError("length", `>= 0 && <= ${bufferByteLength - offset}`, length);
+    }
+    return { offset, length };
+}
+function normalizeReadSyncArgs(buffer, offsetOrOptions, length, position) {
+    if (!isArrayBufferView(buffer)) {
+        throw createInvalidArgTypeError("buffer", "an instance of Buffer, TypedArray, or DataView", buffer);
+    }
+    if (length === undefined &&
+        position === undefined &&
+        isReadWriteOptionsObject(offsetOrOptions)) {
+        const options = (offsetOrOptions ?? {});
+        const { offset, length } = normalizeOffsetLength(buffer.byteLength, options.offset, options.length);
+        return {
+            buffer,
+            offset,
+            length,
+            position: normalizeOptionalPosition(options.position),
+        };
+    }
+    const { offset, length: normalizedLength } = normalizeOffsetLength(buffer.byteLength, offsetOrOptions, length);
+    return {
+        buffer,
+        offset,
+        length: normalizedLength,
+        position: normalizeOptionalPosition(position),
+    };
+}
+function normalizeWriteSyncArgs(buffer, offsetOrPosition, lengthOrEncoding, position) {
+    if (typeof buffer === "string") {
+        if (lengthOrEncoding === undefined &&
+            position === undefined &&
+            isReadWriteOptionsObject(offsetOrPosition)) {
+            const options = (offsetOrPosition ?? {});
+            const encoding = typeof options.encoding === "string" ? options.encoding : undefined;
+            return {
+                buffer,
+                offset: 0,
+                length: Buffer.byteLength(buffer, encoding),
+                position: normalizeOptionalPosition(options.position),
+                encoding,
+            };
+        }
+        if (offsetOrPosition !== undefined &&
+            offsetOrPosition !== null &&
+            typeof offsetOrPosition !== "number") {
+            throw createInvalidArgTypeError("position", "an integer", offsetOrPosition);
+        }
+        return {
+            buffer,
+            offset: 0,
+            length: Buffer.byteLength(buffer, typeof lengthOrEncoding === "string" ? lengthOrEncoding : undefined),
+            position: normalizeOptionalPosition(offsetOrPosition),
+            encoding: typeof lengthOrEncoding === "string" ? lengthOrEncoding : undefined,
+        };
+    }
+    if (!isArrayBufferView(buffer)) {
+        throw createInvalidArgTypeError("buffer", "a string, Buffer, TypedArray, or DataView", buffer);
+    }
+    if (lengthOrEncoding === undefined &&
+        position === undefined &&
+        isReadWriteOptionsObject(offsetOrPosition)) {
+        const options = (offsetOrPosition ?? {});
+        const { offset, length } = normalizeOffsetLength(buffer.byteLength, options.offset, options.length);
+        return {
+            buffer,
+            offset,
+            length,
+            position: normalizeOptionalPosition(options.position),
+        };
+    }
+    const { offset, length } = normalizeOffsetLength(buffer.byteLength, offsetOrPosition, typeof lengthOrEncoding === "number" ? lengthOrEncoding : undefined);
+    return {
+        buffer,
+        offset,
+        length,
+        position: normalizeOptionalPosition(position),
+    };
+}
+function normalizeFdInteger(fd) {
+    return normalizeNumberArgument("fd", fd);
+}
+function normalizeIoVectorBuffers(buffers) {
+    if (!Array.isArray(buffers)) {
+        throw createInvalidArgTypeError("buffers", "an ArrayBufferView[]", buffers);
+    }
+    for (const buffer of buffers) {
+        if (!isArrayBufferView(buffer)) {
+            throw createInvalidArgTypeError("buffers", "an ArrayBufferView[]", buffers);
+        }
+    }
+    return buffers;
+}
+function validateStreamFsOverride(streamFs, required) {
+    if (streamFs === undefined) {
+        return undefined;
+    }
+    if (streamFs === null || typeof streamFs !== "object") {
+        throw createInvalidArgTypeError("options.fs", "an object", streamFs);
+    }
+    const typed = streamFs;
+    for (const key of required) {
+        if (typeof typed[key] !== "function") {
+            throw createInvalidPropertyTypeError(`options.fs.${String(key)}`, typed[key]);
+        }
+    }
+    return typed;
+}
+function normalizeStreamFd(fd) {
+    if (fd === undefined) {
+        return undefined;
+    }
+    if (fd instanceof FileHandle) {
+        return fd;
+    }
+    return normalizeNumberArgument("fd", fd);
+}
+function normalizeStreamPath(pathValue, fd) {
+    if (pathValue === null) {
+        if (fd === undefined) {
+            throw createInvalidArgTypeError("path", "of type string or an instance of Buffer or URL", pathValue);
+        }
+        return null;
+    }
+    if (typeof pathValue === "string" || Buffer.isBuffer(pathValue)) {
+        return pathValue;
+    }
+    if (pathValue instanceof URL) {
+        if (pathValue.protocol === "file:") {
+            return pathValue.pathname;
+        }
+        throw createInvalidArgTypeError("path", "of type string or an instance of Buffer or URL", pathValue);
+    }
+    throw createInvalidArgTypeError("path", "of type string or an instance of Buffer or URL", pathValue);
+}
+function normalizeStreamStartEnd(options) {
+    const start = options?.start;
+    const end = options?.end;
+    if (start !== undefined && typeof start !== "number") {
+        throw createInvalidArgTypeError("start", "of type number", start);
+    }
+    if (end !== undefined && typeof end !== "number") {
+        throw createInvalidArgTypeError("end", "of type number", end);
+    }
+    const normalizedStart = start;
+    const normalizedEnd = end;
+    if (normalizedStart !== undefined && (!Number.isFinite(normalizedStart) || normalizedStart < 0)) {
+        throw createOutOfRangeError("start", ">= 0", start);
+    }
+    if (normalizedEnd !== undefined && (!Number.isFinite(normalizedEnd) || normalizedEnd < 0)) {
+        throw createOutOfRangeError("end", ">= 0", end);
+    }
+    if (normalizedStart !== undefined &&
+        normalizedEnd !== undefined &&
+        normalizedStart > normalizedEnd) {
+        throw createOutOfRangeError("start", `<= "end" (here: ${normalizedEnd})`, normalizedStart);
+    }
+    const highWaterMarkCandidate = options?.highWaterMark ?? options?.bufferSize;
+    const highWaterMark = typeof highWaterMarkCandidate === "number" && Number.isFinite(highWaterMarkCandidate) && highWaterMarkCandidate > 0
+        ? Math.floor(highWaterMarkCandidate)
+        : 65536;
+    return {
+        start: normalizedStart,
+        end: normalizedEnd,
+        highWaterMark,
+        autoClose: options?.autoClose !== false,
+    };
+}
+class ReadStream {
+    _options;
+    bytesRead = 0;
+    path;
+    pending = true;
+    readable = true;
+    readableAborted = false;
+    readableDidRead = false;
+    readableEncoding = null;
+    readableEnded = false;
+    readableFlowing = null;
+    readableHighWaterMark = 65536;
+    readableLength = 0;
+    readableObjectMode = false;
+    destroyed = false;
+    closed = false;
+    errored = null;
+    fd = null;
+    autoClose = true;
+    start;
+    end;
+    _listeners = new Map();
+    _started = false;
+    _reading = false;
+    _readScheduled = false;
+    _opening = false;
+    _remaining = null;
+    _position = null;
+    _fileHandle = null;
+    _streamFs;
+    _signal;
+    _handleCloseListener;
+    constructor(filePath, _options) {
+        this._options = _options;
+        const fdOption = normalizeStreamFd(_options?.fd);
+        const optionsRecord = (_options ?? {});
+        const streamState = normalizeStreamStartEnd(optionsRecord);
+        this.path = filePath;
+        this.start = streamState.start;
+        this.end = streamState.end;
+        this.autoClose = streamState.autoClose;
+        this.readableHighWaterMark = streamState.highWaterMark;
+        this.readableEncoding = _options?.encoding ?? null;
+        this._position = this.start ?? null;
+        this._remaining =
+            this.end !== undefined ? this.end - (this.start ?? 0) + 1 : null;
+        this._signal = validateAbortSignal(_options?.signal);
+        if (fdOption instanceof FileHandle) {
+            if (_options?.fs !== undefined) {
+                const error = new Error("The FileHandle with fs method is not implemented");
+                error.code = "ERR_METHOD_NOT_IMPLEMENTED";
+                throw error;
+            }
+            this._fileHandle = fdOption;
+            this.fd = fdOption.fd;
+            this.pending = false;
+            this._handleCloseListener = () => {
+                if (!this.closed) {
+                    this.closed = true;
+                    this.destroyed = true;
+                    this.readable = false;
+                    this.emit("close");
+                }
+            };
+            this._fileHandle.on("close", this._handleCloseListener);
+        }
+        else {
+            this._streamFs = validateStreamFsOverride(_options?.fs, ["open", "read", "close"]);
+            if (typeof fdOption === "number") {
+                this.fd = fdOption;
+                this.pending = false;
+            }
+        }
+        if (this._signal) {
+            if (this._signal.aborted) {
+                queueMicrotask(() => {
+                    void this._abort(this._signal?.reason);
+                });
+            }
+            else {
+                this._signal.addEventListener("abort", () => {
+                    void this._abort(this._signal?.reason);
+                });
+            }
+        }
+        if (this.fd === null) {
+            queueMicrotask(() => {
+                void this._openIfNeeded();
+            });
+        }
+    }
+    _emitOpen(fd) {
+        this.fd = fd;
+        this.pending = false;
+        this.emit("open", fd);
+        if (this._started || this.readableFlowing) {
+            this._scheduleRead();
+        }
+    }
+    async _openIfNeeded() {
+        if (this.fd !== null || this._opening || this.destroyed || this.closed) {
+            return;
+        }
+        const pathStr = typeof this.path === "string"
+            ? this.path
+            : this.path instanceof Buffer
+                ? this.path.toString()
+                : null;
+        if (!pathStr) {
+            this._handleStreamError(createFsError("EBADF", "EBADF: bad file descriptor", "read"));
+            return;
+        }
+        this._opening = true;
+        const opener = (this._streamFs?.open ?? fs.open).bind(this._streamFs ?? fs);
+        opener(pathStr, "r", 0o666, (error, fd) => {
+            this._opening = false;
+            if (error || typeof fd !== "number") {
+                this._handleStreamError(error ?? createFsError("EBADF", "EBADF: bad file descriptor", "open"));
+                return;
+            }
+            this._emitOpen(fd);
+        });
+    }
+    async _closeUnderlying() {
+        if (this._fileHandle) {
+            if (!this._fileHandle.closed) {
+                await this._fileHandle.close();
+            }
+            return;
+        }
+        if (this.fd !== null && this.fd >= 0) {
+            const fd = this.fd;
+            const closer = (this._streamFs?.close ?? fs.close).bind(this._streamFs ?? fs);
+            await new Promise((resolve) => {
+                closer(fd, () => resolve());
+            });
+            this.fd = -1;
+        }
+    }
+    _scheduleRead() {
+        if (this._readScheduled || this._reading || this.readableFlowing === false || this.destroyed || this.closed) {
+            return;
+        }
+        this._readScheduled = true;
+        queueMicrotask(() => {
+            this._readScheduled = false;
+            void this._readNextChunk();
+        });
+    }
+    async _readNextChunk() {
+        if (this._reading || this.destroyed || this.closed || this.readableFlowing === false) {
+            return;
+        }
+        throwIfAborted(this._signal);
+        if (this.fd === null) {
+            await this._openIfNeeded();
+            return;
+        }
+        if (this._remaining === 0) {
+            await this._finishReadable();
+            return;
+        }
+        const nextLength = this._remaining === null
+            ? this.readableHighWaterMark
+            : Math.min(this.readableHighWaterMark, this._remaining);
+        const target = Buffer.alloc(nextLength);
+        this._reading = true;
+        const onRead = async (error, bytesRead = 0) => {
+            this._reading = false;
+            if (error) {
+                this._handleStreamError(error);
+                return;
+            }
+            if (bytesRead === 0) {
+                await this._finishReadable();
+                return;
+            }
+            this.bytesRead += bytesRead;
+            this.readableDidRead = true;
+            if (typeof this._position === "number") {
+                this._position += bytesRead;
+            }
+            if (this._remaining !== null) {
+                this._remaining -= bytesRead;
+            }
+            const chunk = target.subarray(0, bytesRead);
+            this.emit("data", this.readableEncoding ? chunk.toString(this.readableEncoding) : Buffer.from(chunk));
+            if (this._remaining === 0) {
+                await this._finishReadable();
+                return;
+            }
+            this._scheduleRead();
+        };
+        if (this._fileHandle) {
+            try {
+                const result = await this._fileHandle.read(target, 0, nextLength, this._position);
+                await onRead(null, result.bytesRead);
+            }
+            catch (error) {
+                await onRead(error);
+            }
+            return;
+        }
+        const reader = (this._streamFs?.read ?? fs.read).bind(this._streamFs ?? fs);
+        reader(this.fd, target, 0, nextLength, this._position, (error, bytesRead) => {
+            void onRead(error, bytesRead ?? 0);
+        });
+    }
+    async _finishReadable() {
+        if (this.readableEnded) {
+            return;
+        }
+        this.readable = false;
+        this.readableEnded = true;
+        this.emit("end");
+        if (this.autoClose) {
+            this.destroy();
+        }
+    }
+    _handleStreamError(error) {
+        if (this.closed) {
+            return;
+        }
+        this.errored = error;
+        this.emit("error", error);
+        if (this.autoClose) {
+            this.destroy();
+        }
+        else {
+            this.readable = false;
+        }
+    }
+    async _abort(reason) {
+        if (this.closed || this.destroyed) {
+            return;
+        }
+        this.readableAborted = true;
+        this.errored = createAbortError(reason);
+        this.emit("error", this.errored);
+        if (this._fileHandle) {
+            this.destroyed = true;
+            this.readable = false;
+            this.closed = true;
+            this.emit("close");
+            return;
+        }
+        if (this.autoClose) {
+            this.destroy();
+            return;
+        }
+        this.closed = true;
+        this.emit("close");
+    }
+    async _readAllContent() {
+        const chunks = [];
+        let totalLength = 0;
+        const savedFlowing = this.readableFlowing;
+        this.readableFlowing = false;
+        while (this._remaining !== 0) {
+            if (this.fd === null) {
+                await this._openIfNeeded();
+            }
+            if (this.fd === null) {
+                break;
+            }
+            const nextLength = this._remaining === null
+                ? FILE_HANDLE_READ_CHUNK_BYTES
+                : Math.min(FILE_HANDLE_READ_CHUNK_BYTES, this._remaining);
+            const target = Buffer.alloc(nextLength);
+            let bytesRead = 0;
+            if (this._fileHandle) {
+                bytesRead = (await this._fileHandle.read(target, 0, nextLength, this._position)).bytesRead;
+            }
+            else {
+                bytesRead = fs.readSync(this.fd, target, 0, nextLength, this._position);
+            }
+            if (bytesRead === 0) {
+                break;
+            }
+            const chunk = target.subarray(0, bytesRead);
+            chunks.push(chunk);
+            totalLength += bytesRead;
+            if (typeof this._position === "number") {
+                this._position += bytesRead;
+            }
+            if (this._remaining !== null) {
+                this._remaining -= bytesRead;
+            }
+        }
+        this.readableFlowing = savedFlowing;
+        return Buffer.concat(chunks, totalLength);
+    }
+    on(event, listener) {
+        const listeners = this._listeners.get(event) ?? [];
+        listeners.push(listener);
+        this._listeners.set(event, listeners);
+        if (event === "data") {
+            this._started = true;
+            this.readableFlowing = true;
+            this._scheduleRead();
+        }
+        return this;
+    }
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+        wrapper._originalListener = listener;
+        return this.on(event, wrapper);
+    }
+    off(event, listener) {
+        const listeners = this._listeners.get(event);
+        if (!listeners) {
+            return this;
+        }
+        const index = listeners.findIndex((fn) => fn === listener || fn._originalListener === listener);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (event === undefined) {
+            this._listeners.clear();
+        }
+        else {
+            this._listeners.delete(event);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const listeners = this._listeners.get(event);
+        if (!listeners?.length) {
+            return false;
+        }
+        listeners.slice().forEach((listener) => listener(...args));
+        return true;
+    }
+    read() {
+        return null;
+    }
+    pipe(destination, _options) {
+        this.on("data", (chunk) => {
+            destination.write(chunk);
+        });
+        this.on("end", () => {
+            destination.end?.();
+        });
+        this.resume();
+        return destination;
+    }
+    unpipe(_destination) {
+        return this;
+    }
+    pause() {
+        this.readableFlowing = false;
+        return this;
+    }
+    resume() {
+        this._started = true;
+        this.readableFlowing = true;
+        this._scheduleRead();
+        return this;
+    }
+    setEncoding(encoding) {
+        this.readableEncoding = encoding;
+        return this;
+    }
+    destroy(error) {
+        if (this.destroyed) {
+            return this;
+        }
+        this.destroyed = true;
+        this.readable = false;
+        if (error) {
+            this.errored = error;
+            this.emit("error", error);
+        }
+        queueMicrotask(() => {
+            void this._closeUnderlying().then(() => {
+                if (!this.closed) {
+                    this.closed = true;
+                    this.emit("close");
+                }
+            });
+        });
+        return this;
+    }
+    close(callback) {
+        this.destroy();
+        if (callback) {
+            queueMicrotask(() => callback(null));
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        const content = await this._readAllContent();
+        yield this.readableEncoding ? content.toString(this.readableEncoding) : content;
+    }
+}
+const MAX_WRITE_STREAM_BYTES = 16 * 1024 * 1024;
+class WriteStream {
+    _options;
+    bytesWritten = 0;
+    path;
+    pending = false;
+    writable = true;
+    writableAborted = false;
+    writableEnded = false;
+    writableFinished = false;
+    writableHighWaterMark = 16384;
+    writableLength = 0;
+    writableObjectMode = false;
+    writableCorked = 0;
+    destroyed = false;
+    closed = false;
+    errored = null;
+    writableNeedDrain = false;
+    fd = null;
+    autoClose = true;
+    _chunks = [];
+    _listeners = new Map();
+    _fileHandle = null;
+    _streamFs;
+    constructor(filePath, _options) {
+        this._options = _options;
+        const fdOption = normalizeStreamFd(_options?.fd);
+        this.path = filePath;
+        this.autoClose = _options?.autoClose !== false;
+        this._streamFs = validateStreamFsOverride(_options?.fs, ["open", "close", "write"]);
+        if (_options?.fs !== undefined) {
+            validateStreamFsOverride(_options?.fs, ["writev"]);
+        }
+        if (fdOption instanceof FileHandle) {
+            this._fileHandle = fdOption;
+            this.fd = fdOption.fd;
+            return;
+        }
+        if (typeof fdOption === "number") {
+            this.fd = fdOption;
+            return;
+        }
+        const pathStr = typeof this.path === "string"
+            ? this.path
+            : this.path instanceof Buffer
+                ? this.path.toString()
+                : null;
+        if (!pathStr) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "write");
+        }
+        this.fd = fs.openSync(pathStr, _options?.flags ?? "w", _options?.mode);
+        queueMicrotask(() => {
+            if (this.fd !== null && this.fd >= 0) {
+                this.emit("open", this.fd);
+            }
+        });
+    }
+    async _closeUnderlying() {
+        if (this._fileHandle) {
+            if (!this._fileHandle.closed) {
+                await this._fileHandle.close();
+            }
+            return;
+        }
+        if (this.fd !== null && this.fd >= 0) {
+            const fd = this.fd;
+            const closer = (this._streamFs?.close ?? fs.close).bind(this._streamFs ?? fs);
+            await new Promise((resolve) => {
+                closer(fd, () => resolve());
+            });
+            this.fd = -1;
+        }
+    }
+    close(callback) {
+        queueMicrotask(() => {
+            void this._closeUnderlying().then(() => {
+                if (!this.closed) {
+                    this.closed = true;
+                    this.writable = false;
+                    this.emit("close");
+                }
+                callback?.(null);
+            });
+        });
+    }
+    write(chunk, encodingOrCallback, callback) {
+        if (this.writableEnded || this.destroyed) {
+            const error = new Error("write after end");
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+            queueMicrotask(() => cb?.(error));
+            return false;
+        }
+        let data;
+        if (typeof chunk === "string") {
+            data = Buffer.from(chunk, typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8");
+        }
+        else if (isArrayBufferView(chunk)) {
+            data = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        }
+        else {
+            throw createInvalidArgTypeError("chunk", "a string, Buffer, TypedArray, or DataView", chunk);
+        }
+        if (this.writableLength + data.length > MAX_WRITE_STREAM_BYTES) {
+            const error = new Error(`WriteStream buffer exceeded ${MAX_WRITE_STREAM_BYTES} bytes`);
+            this.errored = error;
+            this.destroyed = true;
+            this.writable = false;
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+            queueMicrotask(() => {
+                cb?.(error);
+                this.emit("error", error);
+            });
+            return false;
+        }
+        this._chunks.push(data);
+        this.bytesWritten += data.length;
+        this.writableLength += data.length;
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        queueMicrotask(() => cb?.(null));
+        return true;
+    }
+    end(chunkOrCb, encodingOrCallback, callback) {
+        if (this.writableEnded) {
+            return this;
+        }
+        let cb;
+        if (typeof chunkOrCb === "function") {
+            cb = chunkOrCb;
+        }
+        else if (typeof encodingOrCallback === "function") {
+            cb = encodingOrCallback;
+            if (chunkOrCb !== undefined && chunkOrCb !== null) {
+                this.write(chunkOrCb);
+            }
+        }
+        else {
+            cb = callback;
+            if (chunkOrCb !== undefined && chunkOrCb !== null) {
+                this.write(chunkOrCb, encodingOrCallback);
+            }
+        }
+        this.writableEnded = true;
+        this.writable = false;
+        this.writableFinished = true;
+        this.writableLength = 0;
+        queueMicrotask(() => {
+            void (async () => {
+                try {
+                    if (this._fileHandle) {
+                        for (const chunk of this._chunks) {
+                            await this._fileHandle.write(chunk, 0, chunk.byteLength, undefined);
+                        }
+                        if (this.autoClose && !this._fileHandle.closed) {
+                            await this._fileHandle.close();
+                        }
+                    }
+                    else if (this.fd !== null && this.fd >= 0) {
+                        for (const chunk of this._chunks) {
+                            fs.writeSync(this.fd, chunk, 0, chunk.byteLength, null);
+                        }
+                        if (this.autoClose) {
+                            await this._closeUnderlying();
+                        }
+                    }
+                    else {
+                        const pathStr = typeof this.path === "string"
+                            ? this.path
+                            : this.path instanceof Buffer
+                                ? this.path.toString()
+                                : null;
+                        if (!pathStr) {
+                            throw createFsError("EBADF", "EBADF: bad file descriptor", "write");
+                        }
+                        fs.writeFileSync(pathStr, Buffer.concat(this._chunks.map((chunk) => Buffer.from(chunk))));
+                    }
+                    this.emit("finish");
+                    if (this.autoClose && !this.closed) {
+                        this.closed = true;
+                        this.emit("close");
+                    }
+                    cb?.();
+                }
+                catch (error) {
+                    this.errored = error;
+                    this.emit("error", error);
+                }
+            })();
+        });
+        return this;
+    }
+    setDefaultEncoding(_encoding) {
+        return this;
+    }
+    cork() {
+        this.writableCorked++;
+    }
+    uncork() {
+        if (this.writableCorked > 0) {
+            this.writableCorked--;
+        }
+    }
+    destroy(error) {
+        if (this.destroyed) {
+            return this;
+        }
+        this.destroyed = true;
+        this.writable = false;
+        if (error) {
+            this.errored = error;
+            this.emit("error", error);
+        }
+        queueMicrotask(() => {
+            void this._closeUnderlying().then(() => {
+                if (!this.closed) {
+                    this.closed = true;
+                    this.emit("close");
+                }
+            });
+        });
+        return this;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    on(event, listener) {
+        const listeners = this._listeners.get(event) ?? [];
+        listeners.push(listener);
+        this._listeners.set(event, listeners);
+        return this;
+    }
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.removeListener(event, wrapper);
+            listener(...args);
+        };
+        return this.on(event, wrapper);
+    }
+    removeListener(event, listener) {
+        const listeners = this._listeners.get(event);
+        if (!listeners) {
+            return this;
+        }
+        const index = listeners.indexOf(listener);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+        return this;
+    }
+    off(event, listener) {
+        return this.removeListener(event, listener);
+    }
+    removeAllListeners(event) {
+        if (event === undefined) {
+            this._listeners.clear();
+        }
+        else {
+            this._listeners.delete(event);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const listeners = this._listeners.get(event);
+        if (!listeners?.length) {
+            return false;
+        }
+        listeners.slice().forEach((listener) => listener(...args));
+        return true;
+    }
+    pipe(destination, _options) {
+        return destination;
+    }
+    unpipe(_destination) {
+        return this;
+    }
+    [Symbol.asyncDispose]() {
+        return Promise.resolve();
+    }
+}
+const ReadStreamClass = ReadStream;
+const WriteStreamClass = WriteStream;
+const ReadStreamFactory = function ReadStream(path, options) {
+    validateEncodingOption(options);
+    return new ReadStreamClass(path, options);
+};
+ReadStreamFactory.prototype = ReadStream.prototype;
+const WriteStreamFactory = function WriteStream(path, options) {
+    validateEncodingOption(options);
+    validateWriteStreamStartOption((options ?? {}));
+    return new WriteStreamClass(path, options);
+};
+WriteStreamFactory.prototype = WriteStream.prototype;
+// Parse flags string to number
+function parseFlags(flags) {
+    if (typeof flags === "number")
+        return flags;
+    const flagMap = {
+        r: O_RDONLY,
+        "r+": O_RDWR,
+        rs: O_RDONLY,
+        "rs+": O_RDWR,
+        w: O_WRONLY | O_CREAT | O_TRUNC,
+        "w+": O_RDWR | O_CREAT | O_TRUNC,
+        a: O_WRONLY | O_APPEND | O_CREAT,
+        "a+": O_RDWR | O_APPEND | O_CREAT,
+        wx: O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
+        xw: O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
+        "wx+": O_RDWR | O_CREAT | O_TRUNC | O_EXCL,
+        "xw+": O_RDWR | O_CREAT | O_TRUNC | O_EXCL,
+        ax: O_WRONLY | O_APPEND | O_CREAT | O_EXCL,
+        xa: O_WRONLY | O_APPEND | O_CREAT | O_EXCL,
+        "ax+": O_RDWR | O_APPEND | O_CREAT | O_EXCL,
+        "xa+": O_RDWR | O_APPEND | O_CREAT | O_EXCL,
+    };
+    if (flags in flagMap)
+        return flagMap[flags];
+    throw new Error("Unknown file flag: " + flags);
+}
+// Helper to create fs errors
+function createFsError(code, message, syscall, path) {
+    const err = new Error(message);
+    err.code = code;
+    err.errno = code === "ENOENT" ? -2 : code === "EACCES" ? -13 : code === "EBADF" ? -9 : code === "EMFILE" ? -24 : -1;
+    err.syscall = syscall;
+    if (path)
+        err.path = path;
+    return err;
+}
+/** Wrap a bridge call with ENOENT/EACCES error re-creation. */
+function bridgeCall(fn, syscall, path) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        const msg = err.message || String(err);
+        if (msg.includes("ENOENT") || msg.includes("no such file or directory") || msg.includes("not found")) {
+            throw createFsError("ENOENT", `ENOENT: no such file or directory, ${syscall} '${path}'`, syscall, path);
+        }
+        if (msg.includes("EACCES") || msg.includes("permission denied")) {
+            throw createFsError("EACCES", `EACCES: permission denied, ${syscall} '${path}'`, syscall, path);
+        }
+        if (msg.includes("EEXIST") || msg.includes("file already exists")) {
+            throw createFsError("EEXIST", `EEXIST: file already exists, ${syscall} '${path}'`, syscall, path);
+        }
+        if (msg.includes("EINVAL") || msg.includes("invalid argument")) {
+            throw createFsError("EINVAL", `EINVAL: invalid argument, ${syscall} '${path}'`, syscall, path);
+        }
+        throw err;
+    }
+}
+// Glob pattern matching helper — converts glob to regex and walks VFS recursively
+function _globToRegex(pattern) {
+    // Determine base directory vs glob portion
+    let regexStr = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*") {
+            // ** matches any depth of directories
+            if (pattern[i + 2] === "/") {
+                regexStr += "(?:.+/)?";
+                i += 3;
+            }
+            else {
+                regexStr += ".*";
+                i += 2;
+            }
+        }
+        else if (ch === "*") {
+            regexStr += "[^/]*";
+            i++;
+        }
+        else if (ch === "?") {
+            regexStr += "[^/]";
+            i++;
+        }
+        else if (ch === "{") {
+            const close = pattern.indexOf("}", i);
+            if (close !== -1) {
+                const alternatives = pattern.slice(i + 1, close).split(",");
+                regexStr += "(?:" + alternatives.map(a => a.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "[^/]*")).join("|") + ")";
+                i = close + 1;
+            }
+            else {
+                regexStr += "\\{";
+                i++;
+            }
+        }
+        else if (ch === "[") {
+            const close = pattern.indexOf("]", i);
+            if (close !== -1) {
+                regexStr += pattern.slice(i, close + 1);
+                i = close + 1;
+            }
+            else {
+                regexStr += "\\[";
+                i++;
+            }
+        }
+        else if (".+^${}()|[]\\".includes(ch)) {
+            regexStr += "\\" + ch;
+            i++;
+        }
+        else {
+            regexStr += ch;
+            i++;
+        }
+    }
+    return new RegExp("^" + regexStr + "$");
+}
+function _globGetBase(pattern) {
+    // Find the longest directory prefix that has no glob characters
+    const parts = pattern.split("/");
+    const baseParts = [];
+    for (const part of parts) {
+        if (/[*?{}\[\]]/.test(part))
+            break;
+        baseParts.push(part);
+    }
+    return baseParts.join("/") || "/";
+}
+// Recursively walk VFS directory and collect matching paths
+// We use a reference to `fs` via late-binding in the fs object method
+const MAX_GLOB_DEPTH = 100; // Prevent stack overflow on deeply nested trees
+function _globCollect(pattern, results) {
+    const regex = _globToRegex(pattern);
+    const base = _globGetBase(pattern);
+    const walk = (dir, depth) => {
+        if (depth > MAX_GLOB_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = _globReadDir(dir);
+        }
+        catch {
+            return; // Directory doesn't exist or not readable
+        }
+        for (const entry of entries) {
+            const fullPath = dir === "/" ? "/" + entry : dir + "/" + entry;
+            // Check if this path matches the pattern
+            if (regex.test(fullPath)) {
+                results.push(fullPath);
+            }
+            // Recurse into directories if pattern has ** or more segments
+            try {
+                const stat = _globStat(fullPath);
+                if (stat.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                }
+            }
+            catch {
+                // Not a directory or stat failed — skip
+            }
+        }
+    };
+    // Start walking from the base directory
+    try {
+        // Check if base itself matches (edge case)
+        if (regex.test(base)) {
+            const stat = _globStat(base);
+            if (!stat.isDirectory()) {
+                results.push(base);
+                return;
+            }
+        }
+        walk(base, 0);
+    }
+    catch {
+        // Base doesn't exist — no matches
+    }
+}
+// Late-bound references — these get assigned after fs is defined
+let _globReadDir;
+let _globStat;
+// Helper to convert PathLike to string
+function toPathString(path) {
+    return normalizePathLike(path);
+}
+// Note: Path normalization is handled by VirtualFileSystem, not here.
+// The VFS expects /data/* paths for Directory access, so we pass paths through unchanged.
+// The fs module implementation
+const fs = {
+    // Constants
+    constants: {
+        // File Access Constants
+        F_OK: 0,
+        R_OK: 4,
+        W_OK: 2,
+        X_OK: 1,
+        // File Copy Constants
+        COPYFILE_EXCL: 1,
+        COPYFILE_FICLONE: 2,
+        COPYFILE_FICLONE_FORCE: 4,
+        // File Open Constants
+        O_RDONLY,
+        O_WRONLY,
+        O_RDWR,
+        O_CREAT,
+        O_EXCL,
+        O_NOCTTY: 256,
+        O_TRUNC,
+        O_APPEND,
+        O_DIRECTORY: 65536,
+        O_NOATIME: 262144,
+        O_NOFOLLOW: 131072,
+        O_SYNC: 1052672,
+        O_DSYNC: 4096,
+        O_SYMLINK: 2097152,
+        O_DIRECT: 16384,
+        O_NONBLOCK: 2048,
+        // File Type Constants
+        S_IFMT: 61440,
+        S_IFREG: 32768,
+        S_IFDIR: 16384,
+        S_IFCHR: 8192,
+        S_IFBLK: 24576,
+        S_IFIFO: 4096,
+        S_IFLNK: 40960,
+        S_IFSOCK: 49152,
+        // File Mode Constants
+        S_IRWXU: 448,
+        S_IRUSR: 256,
+        S_IWUSR: 128,
+        S_IXUSR: 64,
+        S_IRWXG: 56,
+        S_IRGRP: 32,
+        S_IWGRP: 16,
+        S_IXGRP: 8,
+        S_IRWXO: 7,
+        S_IROTH: 4,
+        S_IWOTH: 2,
+        S_IXOTH: 1,
+        UV_FS_O_FILEMAP: 536870912,
+    },
+    Stats,
+    Dirent,
+    Dir,
+    // Sync methods
+    readFileSync(path, options) {
+        validateEncodingOption(options);
+        const rawPath = typeof path === "number"
+            ? _fdGetPath.applySync(undefined, [normalizeFdInteger(path)])
+            : normalizePathLike(path);
+        if (!rawPath)
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "read");
+        const pathStr = rawPath;
+        const encoding = typeof options === "string" ? options : options?.encoding;
+        try {
+            if (encoding) {
+                // Text mode - use text read
+                const content = _fs.readFile.applySyncPromise(undefined, [pathStr]);
+                return content;
+            }
+            else {
+                // Binary mode - use binary read with base64 encoding
+                const base64Content = _fs.readFileBinary.applySyncPromise(undefined, [pathStr]);
+                return Buffer.from(base64Content, "base64");
+            }
+        }
+        catch (err) {
+            const errMsg = err.message || String(err);
+            // Convert various "not found" errors to proper ENOENT
+            if (errMsg.includes("entry not found") ||
+                errMsg.includes("not found") ||
+                errMsg.includes("ENOENT") ||
+                errMsg.includes("no such file or directory")) {
+                throw createFsError("ENOENT", `ENOENT: no such file or directory, open '${rawPath}'`, "open", rawPath);
+            }
+            // Convert permission errors to proper EACCES
+            if (errMsg.includes("EACCES") || errMsg.includes("permission denied")) {
+                throw createFsError("EACCES", `EACCES: permission denied, open '${rawPath}'`, "open", rawPath);
+            }
+            throw err;
+        }
+    },
+    writeFileSync(file, data, _options) {
+        validateEncodingOption(_options);
+        const rawPath = typeof file === "number"
+            ? _fdGetPath.applySync(undefined, [normalizeFdInteger(file)])
+            : normalizePathLike(file);
+        if (!rawPath)
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "write");
+        const pathStr = rawPath;
+        if (typeof data === "string") {
+            // Text mode - use text write
+            // Return the result so async callers (fs.promises) can await it.
+            return _fs.writeFile.applySyncPromise(undefined, [pathStr, data]);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // Binary mode - convert to base64 and use binary write
+            const uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+            const base64 = Buffer.from(uint8).toString("base64");
+            return _fs.writeFileBinary.applySyncPromise(undefined, [pathStr, base64]);
+        }
+        else {
+            // Fallback to text mode
+            return _fs.writeFile.applySyncPromise(undefined, [pathStr, String(data)]);
+        }
+    },
+    appendFileSync(path, data, options) {
+        validateEncodingOption(options);
+        const existing = fs.existsSync(path)
+            ? fs.readFileSync(path, "utf8")
+            : "";
+        const content = typeof data === "string" ? data : String(data);
+        fs.writeFileSync(path, existing + content, options);
+    },
+    readdirSync(path, options) {
+        validateEncodingOption(options);
+        const rawPath = normalizePathLike(path);
+        const pathStr = rawPath;
+        let entriesJson;
+        try {
+            entriesJson = _fs.readDir.applySyncPromise(undefined, [pathStr]);
+        }
+        catch (err) {
+            // Convert "entry not found" and similar errors to proper ENOENT
+            const errMsg = err.message || String(err);
+            if (errMsg.includes("entry not found") || errMsg.includes("not found")) {
+                throw createFsError("ENOENT", `ENOENT: no such file or directory, scandir '${rawPath}'`, "scandir", rawPath);
+            }
+            throw err;
+        }
+        const entries = JSON.parse(entriesJson);
+        if (options?.withFileTypes) {
+            return entries.map((e) => new Dirent(e.name, e.isDirectory, rawPath));
+        }
+        return entries.map((e) => e.name);
+    },
+    mkdirSync(path, options) {
+        const rawPath = normalizePathLike(path);
+        const pathStr = rawPath;
+        const recursive = typeof options === "object" ? options?.recursive ?? false : false;
+        _fs.mkdir.applySyncPromise(undefined, [pathStr, recursive]);
+        return recursive ? rawPath : undefined;
+    },
+    rmdirSync(path, _options) {
+        const pathStr = normalizePathLike(path);
+        _fs.rmdir.applySyncPromise(undefined, [pathStr]);
+    },
+    rmSync(path, options) {
+        const pathStr = toPathString(path);
+        const opts = options || {};
+        try {
+            const stats = fs.statSync(pathStr);
+            if (stats.isDirectory()) {
+                if (opts.recursive) {
+                    // Recursively remove directory contents
+                    const entries = fs.readdirSync(pathStr);
+                    for (const entry of entries) {
+                        const entryPath = pathStr.endsWith("/") ? pathStr + entry : pathStr + "/" + entry;
+                        const entryStats = fs.statSync(entryPath);
+                        if (entryStats.isDirectory()) {
+                            fs.rmSync(entryPath, { recursive: true });
+                        }
+                        else {
+                            fs.unlinkSync(entryPath);
+                        }
+                    }
+                    fs.rmdirSync(pathStr);
+                }
+                else {
+                    fs.rmdirSync(pathStr);
+                }
+            }
+            else {
+                fs.unlinkSync(pathStr);
+            }
+        }
+        catch (e) {
+            if (opts.force && e.code === "ENOENT") {
+                return; // Ignore ENOENT when force is true
+            }
+            throw e;
+        }
+    },
+    existsSync(path) {
+        const pathStr = tryNormalizeExistsPath(path);
+        if (!pathStr) {
+            return false;
+        }
+        return _fs.exists.applySyncPromise(undefined, [pathStr]);
+    },
+    statSync(path, _options) {
+        const rawPath = normalizePathLike(path);
+        const pathStr = rawPath;
+        let statJson;
+        try {
+            statJson = _fs.stat.applySyncPromise(undefined, [pathStr]);
+        }
+        catch (err) {
+            // Convert various "not found" errors to proper ENOENT
+            const errMsg = err.message || String(err);
+            if (errMsg.includes("entry not found") ||
+                errMsg.includes("not found") ||
+                errMsg.includes("ENOENT") ||
+                errMsg.includes("no such file or directory")) {
+                throw createFsError("ENOENT", `ENOENT: no such file or directory, stat '${rawPath}'`, "stat", rawPath);
+            }
+            throw err;
+        }
+        const stat = JSON.parse(statJson);
+        return new Stats(stat);
+    },
+    lstatSync(path, _options) {
+        const pathStr = normalizePathLike(path);
+        const statJson = bridgeCall(() => _fs.lstat.applySyncPromise(undefined, [pathStr]), "lstat", pathStr);
+        const stat = JSON.parse(statJson);
+        return new Stats(stat);
+    },
+    unlinkSync(path) {
+        const pathStr = normalizePathLike(path);
+        _fs.unlink.applySyncPromise(undefined, [pathStr]);
+    },
+    renameSync(oldPath, newPath) {
+        const oldPathStr = normalizePathLike(oldPath, "oldPath");
+        const newPathStr = normalizePathLike(newPath, "newPath");
+        _fs.rename.applySyncPromise(undefined, [oldPathStr, newPathStr]);
+    },
+    copyFileSync(src, dest, _mode) {
+        // readFileSync and writeFileSync already normalize paths
+        const content = fs.readFileSync(src);
+        fs.writeFileSync(dest, content);
+    },
+    // Recursive copy
+    cpSync(src, dest, options) {
+        const srcPath = toPathString(src);
+        const destPath = toPathString(dest);
+        const opts = options || {};
+        const srcStat = fs.statSync(srcPath);
+        if (srcStat.isDirectory()) {
+            if (!opts.recursive) {
+                throw createFsError("ERR_FS_EISDIR", `Path is a directory: cp '${srcPath}'`, "cp", srcPath);
+            }
+            // Create destination directory
+            try {
+                fs.mkdirSync(destPath, { recursive: true });
+            }
+            catch {
+                // May already exist
+            }
+            // Copy contents recursively
+            const entries = fs.readdirSync(srcPath);
+            for (const entry of entries) {
+                const srcEntry = srcPath.endsWith("/") ? srcPath + entry : srcPath + "/" + entry;
+                const destEntry = destPath.endsWith("/") ? destPath + entry : destPath + "/" + entry;
+                fs.cpSync(srcEntry, destEntry, opts);
+            }
+        }
+        else {
+            // File copy
+            if (opts.errorOnExist && fs.existsSync(destPath)) {
+                throw createFsError("EEXIST", `EEXIST: file already exists, cp '${srcPath}' -> '${destPath}'`, "cp", destPath);
+            }
+            if (!opts.force && opts.force !== undefined && fs.existsSync(destPath)) {
+                return; // Skip without error when force is false
+            }
+            fs.copyFileSync(srcPath, destPath);
+        }
+    },
+    // Temp directory creation
+    mkdtempSync(prefix, _options) {
+        validateEncodingOption(_options);
+        const suffix = Math.random().toString(36).slice(2, 8);
+        const dirPath = prefix + suffix;
+        fs.mkdirSync(dirPath, { recursive: true });
+        return dirPath;
+    },
+    // Directory handle (sync)
+    opendirSync(path, _options) {
+        const pathStr = normalizePathLike(path);
+        // Verify directory exists
+        const stat = fs.statSync(pathStr);
+        if (!stat.isDirectory()) {
+            throw createFsError("ENOTDIR", `ENOTDIR: not a directory, opendir '${pathStr}'`, "opendir", pathStr);
+        }
+        return new Dir(pathStr);
+    },
+    // File descriptor methods
+    openSync(path, flags, _mode) {
+        const pathStr = normalizePathLike(path);
+        const numFlags = parseFlags(flags ?? "r");
+        const modeNum = normalizeOpenModeArgument(_mode);
+        try {
+            return _fdOpen.applySyncPromise(undefined, [pathStr, numFlags, modeNum]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("ENOENT"))
+                throw createFsError("ENOENT", msg, "open", pathStr);
+            if (msg.includes("EMFILE"))
+                throw createFsError("EMFILE", msg, "open", pathStr);
+            throw e;
+        }
+    },
+    closeSync(fd) {
+        normalizeFdInteger(fd);
+        try {
+            _fdClose.applySyncPromise(undefined, [fd]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", "EBADF: bad file descriptor, close", "close");
+            throw e;
+        }
+    },
+    readSync(fd, buffer, offset, length, position) {
+        const normalized = normalizeReadSyncArgs(buffer, offset, length, position);
+        let base64;
+        try {
+            base64 = _fdRead.applySyncPromise(undefined, [fd, normalized.length, normalized.position ?? null]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", msg, "read");
+            throw e;
+        }
+        const bytes = Buffer.from(base64, "base64");
+        const targetBuffer = new Uint8Array(normalized.buffer.buffer, normalized.buffer.byteOffset, normalized.buffer.byteLength);
+        for (let i = 0; i < bytes.length && i < normalized.length; i++) {
+            targetBuffer[normalized.offset + i] = bytes[i];
+        }
+        return bytes.length;
+    },
+    writeSync(fd, buffer, offsetOrPosition, lengthOrEncoding, position) {
+        const normalized = normalizeWriteSyncArgs(buffer, offsetOrPosition, lengthOrEncoding, position);
+        let dataBytes;
+        if (typeof normalized.buffer === "string") {
+            dataBytes = Buffer.from(normalized.buffer, normalized.encoding);
+        }
+        else {
+            dataBytes = new Uint8Array(normalized.buffer.buffer, normalized.buffer.byteOffset + normalized.offset, normalized.length);
+        }
+        const base64 = Buffer.from(dataBytes).toString("base64");
+        const pos = normalized.position ?? null;
+        try {
+            return _fdWrite.applySyncPromise(undefined, [fd, base64, pos]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", msg, "write");
+            throw e;
+        }
+    },
+    fstatSync(fd) {
+        normalizeFdInteger(fd);
+        let raw;
+        try {
+            raw = _fdFstat.applySyncPromise(undefined, [fd]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", "EBADF: bad file descriptor, fstat", "fstat");
+            throw e;
+        }
+        return new Stats(JSON.parse(raw));
+    },
+    ftruncateSync(fd, len) {
+        normalizeFdInteger(fd);
+        try {
+            _fdFtruncate.applySyncPromise(undefined, [fd, len]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", "EBADF: bad file descriptor, ftruncate", "ftruncate");
+            throw e;
+        }
+    },
+    // fsync / fdatasync — no-op for in-memory VFS (validates FD exists)
+    fsyncSync(fd) {
+        normalizeFdInteger(fd);
+        try {
+            _fdFsync.applySyncPromise(undefined, [fd]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", "EBADF: bad file descriptor, fsync", "fsync");
+            throw e;
+        }
+    },
+    fdatasyncSync(fd) {
+        normalizeFdInteger(fd);
+        try {
+            _fdFsync.applySyncPromise(undefined, [fd]);
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            if (msg.includes("EBADF"))
+                throw createFsError("EBADF", "EBADF: bad file descriptor, fdatasync", "fdatasync");
+            throw e;
+        }
+    },
+    // readv — scatter-read into multiple buffers (delegates to readSync)
+    readvSync(fd, buffers, position) {
+        const normalizedFd = normalizeFdInteger(fd);
+        const normalizedBuffers = normalizeIoVectorBuffers(buffers);
+        let totalBytesRead = 0;
+        const normalizedPosition = normalizeOptionalPosition(position);
+        let nextPosition = normalizedPosition;
+        for (const buffer of normalizedBuffers) {
+            const target = buffer instanceof Uint8Array
+                ? buffer
+                : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            const bytesRead = fs.readSync(normalizedFd, target, 0, target.byteLength, nextPosition);
+            totalBytesRead += bytesRead;
+            if (nextPosition !== null) {
+                nextPosition += bytesRead;
+            }
+            // EOF — stop filling further buffers
+            if (bytesRead < target.byteLength)
+                break;
+        }
+        return totalBytesRead;
+    },
+    // statfs — return synthetic filesystem stats for the in-memory VFS
+    statfsSync(path, _options) {
+        const pathStr = normalizePathLike(path);
+        // Verify path exists
+        if (!fs.existsSync(pathStr)) {
+            throw createFsError("ENOENT", `ENOENT: no such file or directory, statfs '${pathStr}'`, "statfs", pathStr);
+        }
+        // Return synthetic stats — in-memory VFS has no real block device
+        return {
+            type: 0x01021997, // TMPFS_MAGIC
+            bsize: 4096,
+            blocks: 262144, // 1GB virtual capacity
+            bfree: 262144,
+            bavail: 262144,
+            files: 1000000,
+            ffree: 999999,
+        };
+    },
+    // glob — pattern matching over VFS files
+    globSync(pattern, _options) {
+        const patterns = Array.isArray(pattern) ? pattern : [pattern];
+        const results = [];
+        for (const pat of patterns) {
+            _globCollect(pat, results);
+        }
+        return [...new Set(results)].sort();
+    },
+    // Metadata and link sync methods — delegate to VFS via host refs
+    chmodSync(path, mode) {
+        const pathStr = normalizePathLike(path);
+        const modeNum = normalizeModeArgument(mode);
+        bridgeCall(() => _fs.chmod.applySyncPromise(undefined, [pathStr, modeNum]), "chmod", pathStr);
+    },
+    chownSync(path, uid, gid) {
+        const pathStr = normalizePathLike(path);
+        const normalizedUid = normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+        const normalizedGid = normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+        bridgeCall(() => _fs.chown.applySyncPromise(undefined, [pathStr, normalizedUid, normalizedGid]), "chown", pathStr);
+    },
+    fchmodSync(fd, mode) {
+        const normalizedFd = normalizeFdInteger(fd);
+        const pathStr = _fdGetPath.applySync(undefined, [normalizedFd]);
+        if (!pathStr) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "chmod");
+        }
+        fs.chmodSync(pathStr, normalizeModeArgument(mode));
+    },
+    fchownSync(fd, uid, gid) {
+        const normalizedFd = normalizeFdInteger(fd);
+        const pathStr = _fdGetPath.applySync(undefined, [normalizedFd]);
+        if (!pathStr) {
+            throw createFsError("EBADF", "EBADF: bad file descriptor", "chown");
+        }
+        fs.chownSync(pathStr, uid, gid);
+    },
+    lchownSync(path, uid, gid) {
+        const pathStr = normalizePathLike(path);
+        const normalizedUid = normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+        const normalizedGid = normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+        bridgeCall(() => _fs.chown.applySyncPromise(undefined, [pathStr, normalizedUid, normalizedGid]), "chown", pathStr);
+    },
+    linkSync(existingPath, newPath) {
+        const existingStr = normalizePathLike(existingPath, "existingPath");
+        const newStr = normalizePathLike(newPath, "newPath");
+        bridgeCall(() => _fs.link.applySyncPromise(undefined, [existingStr, newStr]), "link", newStr);
+    },
+    symlinkSync(target, path, _type) {
+        const targetStr = normalizePathLike(target, "target");
+        const pathStr = normalizePathLike(path);
+        bridgeCall(() => _fs.symlink.applySyncPromise(undefined, [targetStr, pathStr]), "symlink", pathStr);
+    },
+    readlinkSync(path, _options) {
+        validateEncodingOption(_options);
+        const pathStr = normalizePathLike(path);
+        return bridgeCall(() => _fs.readlink.applySyncPromise(undefined, [pathStr]), "readlink", pathStr);
+    },
+    truncateSync(path, len) {
+        const pathStr = normalizePathLike(path);
+        bridgeCall(() => _fs.truncate.applySyncPromise(undefined, [pathStr, len ?? 0]), "truncate", pathStr);
+    },
+    utimesSync(path, atime, mtime) {
+        const pathStr = normalizePathLike(path);
+        const atimeNum = typeof atime === "number" ? atime : new Date(atime).getTime() / 1000;
+        const mtimeNum = typeof mtime === "number" ? mtime : new Date(mtime).getTime() / 1000;
+        bridgeCall(() => _fs.utimes.applySyncPromise(undefined, [pathStr, atimeNum, mtimeNum]), "utimes", pathStr);
+    },
+    // Async methods - wrap sync methods in callbacks/promises
+    //
+    // IMPORTANT: Low-level fd operations (open, close, read, write) and operations commonly
+    // used by streaming libraries (stat, lstat, rename, unlink) must defer their callbacks
+    // using queueMicrotask(). This is critical for proper stream operation.
+    //
+    // Why: Node.js streams (like tar, minipass, fs-minipass) use callback chains where each
+    // callback triggers the next read/write operation. These streams also rely on events like
+    // 'drain' to know when to resume writing. If callbacks fire synchronously, the event loop
+    // never gets a chance to process these events, causing streams to stall after the first chunk.
+    //
+    // Example problem without queueMicrotask:
+    //   1. tar calls fs.read() with callback
+    //   2. Our sync implementation calls callback immediately
+    //   3. Callback writes to stream, stream buffer fills, returns false (needs drain)
+    //   4. Code sets up 'drain' listener and returns
+    //   5. But we never returned to event loop, so 'drain' never fires
+    //   6. Stream hangs forever
+    //
+    // With queueMicrotask, step 2 defers the callback, allowing the event loop to process
+    // pending events (including 'drain') before the next operation starts.
+    readFile(path, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            validateEncodingOption(options);
+            try {
+                callback(null, fs.readFileSync(path, options));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.readFileSync(path, options));
+        }
+    },
+    writeFile(path, data, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            validateEncodingOption(options);
+            try {
+                fs.writeFileSync(path, data, options);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.writeFileSync(path, data, options));
+        }
+    },
+    appendFile(path, data, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            validateEncodingOption(options);
+            try {
+                fs.appendFileSync(path, data, options);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.appendFileSync(path, data, options));
+        }
+    },
+    readdir(path, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            validateEncodingOption(options);
+            try {
+                callback(null, fs.readdirSync(path, options));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.readdirSync(path, options));
+        }
+    },
+    mkdir(path, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            try {
+                fs.mkdirSync(path, options);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            fs.mkdirSync(path, options);
+            return Promise.resolve();
+        }
+    },
+    rmdir(path, callback) {
+        if (callback) {
+            normalizePathLike(path);
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                fs.rmdirSync(path);
+                queueMicrotask(() => cb(null));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.rmdirSync(path));
+        }
+    },
+    // rm - remove files or directories (with recursive support)
+    rm(path, options, callback) {
+        let opts = {};
+        let cb;
+        if (typeof options === "function") {
+            cb = options;
+        }
+        else if (options) {
+            opts = options;
+            cb = callback;
+        }
+        else {
+            cb = callback;
+        }
+        const doRm = () => {
+            try {
+                const stats = fs.statSync(path);
+                if (stats.isDirectory()) {
+                    if (opts.recursive) {
+                        // Recursively remove directory contents
+                        const entries = fs.readdirSync(path);
+                        for (const entry of entries) {
+                            const entryPath = path.endsWith("/") ? path + entry : path + "/" + entry;
+                            const entryStats = fs.statSync(entryPath);
+                            if (entryStats.isDirectory()) {
+                                fs.rmSync(entryPath, { recursive: true });
+                            }
+                            else {
+                                fs.unlinkSync(entryPath);
+                            }
+                        }
+                        fs.rmdirSync(path);
+                    }
+                    else {
+                        fs.rmdirSync(path);
+                    }
+                }
+                else {
+                    fs.unlinkSync(path);
+                }
+            }
+            catch (e) {
+                if (opts.force && e.code === "ENOENT") {
+                    return; // Ignore ENOENT when force is true
+                }
+                throw e;
+            }
+        };
+        if (cb) {
+            // Defer callback to next tick to allow event loop to process stream events
+            try {
+                doRm();
+                queueMicrotask(() => cb(null));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            doRm();
+            return Promise.resolve();
+        }
+    },
+    exists(path, callback) {
+        validateCallback(callback, "cb");
+        if (path === undefined) {
+            throw createInvalidArgTypeError("path", "of type string or an instance of Buffer or URL", path);
+        }
+        queueMicrotask(() => callback(Boolean(tryNormalizeExistsPath(path) && fs.existsSync(path))));
+    },
+    stat(path, callback) {
+        validateCallback(callback, "cb");
+        normalizePathLike(path);
+        const cb = callback;
+        try {
+            const stats = fs.statSync(path);
+            queueMicrotask(() => cb(null, stats));
+        }
+        catch (e) {
+            queueMicrotask(() => cb(e));
+        }
+    },
+    lstat(path, callback) {
+        if (callback) {
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                const stats = fs.lstatSync(path);
+                queueMicrotask(() => cb(null, stats));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.lstatSync(path));
+        }
+    },
+    unlink(path, callback) {
+        if (callback) {
+            normalizePathLike(path);
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                fs.unlinkSync(path);
+                queueMicrotask(() => cb(null));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.unlinkSync(path));
+        }
+    },
+    rename(oldPath, newPath, callback) {
+        if (callback) {
+            normalizePathLike(oldPath, "oldPath");
+            normalizePathLike(newPath, "newPath");
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                fs.renameSync(oldPath, newPath);
+                queueMicrotask(() => cb(null));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.renameSync(oldPath, newPath));
+        }
+    },
+    copyFile(src, dest, callback) {
+        if (callback) {
+            try {
+                fs.copyFileSync(src, dest);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.copyFileSync(src, dest));
+        }
+    },
+    cp(src, dest, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            try {
+                fs.cpSync(src, dest, options);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.cpSync(src, dest, options));
+        }
+    },
+    mkdtemp(prefix, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        validateCallback(callback, "cb");
+        validateEncodingOption(options);
+        try {
+            callback(null, fs.mkdtempSync(prefix, options));
+        }
+        catch (e) {
+            callback(e);
+        }
+    },
+    opendir(path, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            try {
+                callback(null, fs.opendirSync(path, options));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.opendirSync(path, options));
+        }
+    },
+    open(path, flags, mode, callback) {
+        let resolvedFlags = "r";
+        let resolvedMode = mode;
+        if (typeof flags === "function") {
+            callback = flags;
+            resolvedMode = undefined;
+        }
+        else {
+            resolvedFlags = flags ?? "r";
+        }
+        if (typeof mode === "function") {
+            callback = mode;
+            resolvedMode = undefined;
+        }
+        validateCallback(callback, "cb");
+        normalizePathLike(path);
+        normalizeOpenModeArgument(resolvedMode);
+        const cb = callback;
+        try {
+            const fd = fs.openSync(path, resolvedFlags, resolvedMode);
+            queueMicrotask(() => cb(null, fd));
+        }
+        catch (e) {
+            queueMicrotask(() => cb(e));
+        }
+    },
+    close(fd, callback) {
+        normalizeFdInteger(fd);
+        validateCallback(callback, "cb");
+        const cb = callback;
+        try {
+            fs.closeSync(fd);
+            queueMicrotask(() => cb(null));
+        }
+        catch (e) {
+            queueMicrotask(() => cb(e));
+        }
+    },
+    read(fd, buffer, offset, length, position, callback) {
+        if (callback) {
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                const bytesRead = fs.readSync(fd, buffer, offset, length, position);
+                queueMicrotask(() => cb(null, bytesRead, buffer));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.readSync(fd, buffer, offset, length, position));
+        }
+    },
+    write(fd, buffer, offset, length, position, callback) {
+        if (typeof offset === "function") {
+            callback = offset;
+            offset = undefined;
+            length = undefined;
+            position = undefined;
+        }
+        else if (typeof length === "function") {
+            callback = length;
+            length = undefined;
+            position = undefined;
+        }
+        else if (typeof position === "function") {
+            callback = position;
+            position = undefined;
+        }
+        if (callback) {
+            const normalized = normalizeWriteSyncArgs(buffer, offset, length, position);
+            // Defer callback to next tick to allow event loop to process stream events
+            const cb = callback;
+            try {
+                const bytesWritten = typeof normalized.buffer === "string"
+                    ? _fdWrite.applySyncPromise(undefined, [fd, Buffer.from(normalized.buffer, normalized.encoding).toString("base64"), normalized.position ?? null])
+                    : _fdWrite.applySyncPromise(undefined, [
+                        fd,
+                        Buffer.from(new Uint8Array(normalized.buffer.buffer, normalized.buffer.byteOffset + normalized.offset, normalized.length)).toString("base64"),
+                        normalized.position ?? null,
+                    ]);
+                queueMicrotask(() => cb(null, bytesWritten));
+            }
+            catch (e) {
+                queueMicrotask(() => cb(e));
+            }
+        }
+        else {
+            return Promise.resolve(fs.writeSync(fd, buffer, offset, length, position));
+        }
+    },
+    // writev - write multiple buffers to a file descriptor
+    writev(fd, buffers, position, callback) {
+        if (typeof position === "function") {
+            callback = position;
+            position = null;
+        }
+        const normalizedFd = normalizeFdInteger(fd);
+        const normalizedBuffers = normalizeIoVectorBuffers(buffers);
+        const normalizedPosition = normalizeOptionalPosition(position);
+        if (callback) {
+            try {
+                const bytesWritten = fs.writevSync(normalizedFd, normalizedBuffers, normalizedPosition);
+                queueMicrotask(() => callback(null, bytesWritten, normalizedBuffers));
+            }
+            catch (e) {
+                queueMicrotask(() => callback(e));
+            }
+        }
+    },
+    writevSync(fd, buffers, position) {
+        const normalizedFd = normalizeFdInteger(fd);
+        const normalizedBuffers = normalizeIoVectorBuffers(buffers);
+        let nextPosition = normalizeOptionalPosition(position);
+        let totalBytesWritten = 0;
+        for (const buffer of normalizedBuffers) {
+            const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            totalBytesWritten += fs.writeSync(normalizedFd, bytes, 0, bytes.length, nextPosition);
+            if (nextPosition !== null) {
+                nextPosition += bytes.length;
+            }
+        }
+        return totalBytesWritten;
+    },
+    fstat(fd, callback) {
+        if (callback) {
+            try {
+                callback(null, fs.fstatSync(fd));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.fstatSync(fd));
+        }
+    },
+    // fsync / fdatasync async callback forms
+    fsync(fd, callback) {
+        normalizeFdInteger(fd);
+        validateCallback(callback, "cb");
+        try {
+            fs.fsyncSync(fd);
+            callback(null);
+        }
+        catch (e) {
+            callback(e);
+        }
+    },
+    fdatasync(fd, callback) {
+        normalizeFdInteger(fd);
+        validateCallback(callback, "cb");
+        try {
+            fs.fdatasyncSync(fd);
+            callback(null);
+        }
+        catch (e) {
+            callback(e);
+        }
+    },
+    // readv async callback form
+    readv(fd, buffers, position, callback) {
+        if (typeof position === "function") {
+            callback = position;
+            position = null;
+        }
+        const normalizedFd = normalizeFdInteger(fd);
+        const normalizedBuffers = normalizeIoVectorBuffers(buffers);
+        const normalizedPosition = normalizeOptionalPosition(position);
+        if (callback) {
+            try {
+                const bytesRead = fs.readvSync(normalizedFd, normalizedBuffers, normalizedPosition);
+                queueMicrotask(() => callback(null, bytesRead, normalizedBuffers));
+            }
+            catch (e) {
+                queueMicrotask(() => callback(e));
+            }
+        }
+    },
+    // statfs async callback form
+    statfs(path, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            try {
+                callback(null, fs.statfsSync(path, options));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.statfsSync(path, options));
+        }
+    },
+    // glob async callback form
+    glob(pattern, options, callback) {
+        if (typeof options === "function") {
+            callback = options;
+            options = undefined;
+        }
+        if (callback) {
+            try {
+                callback(null, fs.globSync(pattern, options));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+    },
+    // fs.promises API
+    // Note: Using async functions to properly catch sync errors and return rejected promises
+    promises: {
+        async readFile(path, options) {
+            if (path instanceof FileHandle) {
+                return path.readFile(options);
+            }
+            return fs.readFileSync(path, options);
+        },
+        async writeFile(path, data, options) {
+            if (path instanceof FileHandle) {
+                return path.writeFile(data, options);
+            }
+            return fs.writeFileSync(path, data, options);
+        },
+        async appendFile(path, data, options) {
+            if (path instanceof FileHandle) {
+                return path.appendFile(data, options);
+            }
+            return fs.appendFileSync(path, data, options);
+        },
+        async readdir(path, options) {
+            return fs.readdirSync(path, options);
+        },
+        async mkdir(path, options) {
+            return fs.mkdirSync(path, options);
+        },
+        async rmdir(path) {
+            return fs.rmdirSync(path);
+        },
+        async stat(path) {
+            return fs.statSync(path);
+        },
+        async lstat(path) {
+            return fs.lstatSync(path);
+        },
+        async unlink(path) {
+            return fs.unlinkSync(path);
+        },
+        async rename(oldPath, newPath) {
+            return fs.renameSync(oldPath, newPath);
+        },
+        async copyFile(src, dest) {
+            return fs.copyFileSync(src, dest);
+        },
+        async cp(src, dest, options) {
+            return fs.cpSync(src, dest, options);
+        },
+        async mkdtemp(prefix, options) {
+            return fs.mkdtempSync(prefix, options);
+        },
+        async opendir(path, options) {
+            return fs.opendirSync(path, options);
+        },
+        async open(path, flags, mode) {
+            return new FileHandle(fs.openSync(path, flags ?? "r", mode));
+        },
+        async statfs(path, options) {
+            return fs.statfsSync(path, options);
+        },
+        async glob(pattern, _options) {
+            return fs.globSync(pattern, _options);
+        },
+        async access(path) {
+            if (!fs.existsSync(path)) {
+                throw createFsError("ENOENT", `ENOENT: no such file or directory, access '${path}'`, "access", path);
+            }
+        },
+        async rm(path, options) {
+            return fs.rmSync(path, options);
+        },
+        async chmod(path, mode) {
+            return fs.chmodSync(path, mode);
+        },
+        async chown(path, uid, gid) {
+            return fs.chownSync(path, uid, gid);
+        },
+        async lchown(path, uid, gid) {
+            return fs.lchownSync(path, uid, gid);
+        },
+        async link(existingPath, newPath) {
+            return fs.linkSync(existingPath, newPath);
+        },
+        async symlink(target, path) {
+            return fs.symlinkSync(target, path);
+        },
+        async readlink(path) {
+            return fs.readlinkSync(path);
+        },
+        async truncate(path, len) {
+            return fs.truncateSync(path, len);
+        },
+        async utimes(path, atime, mtime) {
+            return fs.utimesSync(path, atime, mtime);
+        },
+        watch(path, options) {
+            return createUnsupportedPromisesWatchIterator(path, options);
+        },
+    },
+    // Compatibility methods
+    accessSync(path) {
+        // existsSync already normalizes the path
+        if (!fs.existsSync(path)) {
+            throw createFsError("ENOENT", `ENOENT: no such file or directory, access '${path}'`, "access", path);
+        }
+    },
+    access(path, mode, callback) {
+        if (typeof mode === "function") {
+            callback = mode;
+            mode = undefined;
+        }
+        if (callback) {
+            try {
+                fs.accessSync(path);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return fs.promises.access(path);
+        }
+    },
+    realpathSync: Object.assign(function realpathSync(path, options) {
+        validateEncodingOption(options);
+        // Resolve symlinks by walking each path component via lstat + readlink
+        const MAX_SYMLINK_DEPTH = 40;
+        let symlinksFollowed = 0;
+        const raw = normalizePathLike(path);
+        // Build initial queue: normalize . and .. segments
+        const pending = [];
+        for (const seg of raw.split("/")) {
+            if (!seg || seg === ".")
+                continue;
+            if (seg === "..") {
+                if (pending.length > 0)
+                    pending.pop();
+            }
+            else
+                pending.push(seg);
+        }
+        // Walk each component, resolving symlinks via a queue
+        const resolved = [];
+        while (pending.length > 0) {
+            const seg = pending.shift();
+            if (seg === ".")
+                continue;
+            if (seg === "..") {
+                if (resolved.length > 0)
+                    resolved.pop();
+                continue;
+            }
+            resolved.push(seg);
+            const currentPath = "/" + resolved.join("/");
+            try {
+                const stat = fs.lstatSync(currentPath);
+                if (stat.isSymbolicLink()) {
+                    if (++symlinksFollowed > MAX_SYMLINK_DEPTH) {
+                        const err = new Error(`ELOOP: too many levels of symbolic links, realpath '${raw}'`);
+                        err.code = "ELOOP";
+                        err.syscall = "realpath";
+                        err.path = raw;
+                        throw err;
+                    }
+                    const target = fs.readlinkSync(currentPath);
+                    // Prepend target segments to pending for re-resolution
+                    const targetSegs = target.split("/").filter(Boolean);
+                    if (target.startsWith("/")) {
+                        // Absolute symlink — restart from root
+                        resolved.length = 0;
+                    }
+                    else {
+                        // Relative symlink — drop current component
+                        resolved.pop();
+                    }
+                    // Prepend target segments so they're processed next
+                    pending.unshift(...targetSegs);
+                }
+            }
+            catch (e) {
+                const err = e;
+                if (err.code === "ELOOP")
+                    throw e;
+                if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+                    const enoent = new Error(`ENOENT: no such file or directory, realpath '${raw}'`);
+                    enoent.code = "ENOENT";
+                    enoent.syscall = "realpath";
+                    enoent.path = raw;
+                    throw enoent;
+                }
+                break;
+            }
+        }
+        return "/" + resolved.join("/") || "/";
+    }, {
+        native(path, options) {
+            validateEncodingOption(options);
+            return fs.realpathSync(path);
+        }
+    }),
+    realpath: Object.assign(function realpath(path, optionsOrCallback, callback) {
+        let options;
+        if (typeof optionsOrCallback === "function") {
+            callback = optionsOrCallback;
+        }
+        else {
+            options = optionsOrCallback;
+        }
+        if (callback) {
+            validateEncodingOption(options);
+            callback(null, fs.realpathSync(path, options));
+        }
+        else {
+            return Promise.resolve(fs.realpathSync(path, options));
+        }
+    }, {
+        native(path, optionsOrCallback, callback) {
+            let options;
+            if (typeof optionsOrCallback === "function") {
+                callback = optionsOrCallback;
+            }
+            else {
+                options = optionsOrCallback;
+            }
+            if (callback) {
+                validateEncodingOption(options);
+                callback(null, fs.realpathSync.native(path, options));
+            }
+            else {
+                return Promise.resolve(fs.realpathSync.native(path, options));
+            }
+        }
+    }),
+    ReadStream: ReadStreamFactory,
+    WriteStream: WriteStreamFactory,
+    createReadStream: function createReadStream(path, options) {
+        const opts = typeof options === "string" ? { encoding: options } : options;
+        validateEncodingOption(opts);
+        const fd = normalizeStreamFd(opts?.fd);
+        const pathLike = normalizeStreamPath(path, fd);
+        // Use type assertion since our ReadStream has all the methods npm needs
+        // but not all the complex overloaded signatures of the full Node.js interface
+        return new ReadStream(pathLike, opts);
+    },
+    createWriteStream: function createWriteStream(path, options) {
+        const opts = typeof options === "string" ? { encoding: options } : options;
+        validateEncodingOption(opts);
+        validateWriteStreamStartOption((opts ?? {}));
+        const fd = normalizeStreamFd(opts?.fd);
+        const pathLike = normalizeStreamPath(path, fd);
+        // Use type assertion since our WriteStream has all the methods npm needs
+        // but not all the complex overloaded signatures of the full Node.js interface
+        return new WriteStream(pathLike, opts);
+    },
+    // Unsupported fs APIs — watch requires kernel-level inotify, use polling instead
+    watch(..._args) {
+        normalizeWatchArguments(_args[0], _args[1], _args[2]);
+        throw createUnsupportedWatcherError("watch");
+    },
+    watchFile(..._args) {
+        normalizeWatchFileArguments(_args[0], _args[1], _args[2]);
+        throw createUnsupportedWatcherError("watchFile");
+    },
+    unwatchFile(..._args) {
+        normalizePathLike(_args[0]);
+        throw createUnsupportedWatcherError("unwatchFile");
+    },
+    chmod(path, mode, callback) {
+        if (callback) {
+            normalizePathLike(path);
+            normalizeModeArgument(mode);
+            try {
+                fs.chmodSync(path, mode);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.chmodSync(path, mode));
+        }
+    },
+    chown(path, uid, gid, callback) {
+        if (callback) {
+            normalizePathLike(path);
+            normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            try {
+                fs.chownSync(path, uid, gid);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.chownSync(path, uid, gid));
+        }
+    },
+    fchmod(fd, mode, callback) {
+        if (callback) {
+            normalizeFdInteger(fd);
+            normalizeModeArgument(mode);
+            try {
+                fs.fchmodSync(fd, mode);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            normalizeFdInteger(fd);
+            normalizeModeArgument(mode);
+            return Promise.resolve(fs.fchmodSync(fd, mode));
+        }
+    },
+    fchown(fd, uid, gid, callback) {
+        if (callback) {
+            normalizeFdInteger(fd);
+            normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            try {
+                fs.fchownSync(fd, uid, gid);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            normalizeFdInteger(fd);
+            normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            return Promise.resolve(fs.fchownSync(fd, uid, gid));
+        }
+    },
+    lchown(path, uid, gid, callback) {
+        if (arguments.length >= 4) {
+            validateCallback(callback, "cb");
+            normalizePathLike(path);
+            normalizeNumberArgument("uid", uid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            normalizeNumberArgument("gid", gid, { min: -1, max: 0xffffffff, allowNegativeOne: true });
+            try {
+                fs.lchownSync(path, uid, gid);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.lchownSync(path, uid, gid));
+        }
+    },
+    link(existingPath, newPath, callback) {
+        if (callback) {
+            normalizePathLike(existingPath, "existingPath");
+            normalizePathLike(newPath, "newPath");
+            try {
+                fs.linkSync(existingPath, newPath);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.linkSync(existingPath, newPath));
+        }
+    },
+    symlink(target, path, typeOrCb, callback) {
+        if (typeof typeOrCb === "function") {
+            callback = typeOrCb;
+        }
+        if (callback) {
+            try {
+                fs.symlinkSync(target, path);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.symlinkSync(target, path));
+        }
+    },
+    readlink(path, optionsOrCb, callback) {
+        if (typeof optionsOrCb === "function") {
+            callback = optionsOrCb;
+            optionsOrCb = undefined;
+        }
+        if (callback) {
+            normalizePathLike(path);
+            validateEncodingOption(optionsOrCb);
+            try {
+                callback(null, fs.readlinkSync(path, optionsOrCb));
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.readlinkSync(path, optionsOrCb));
+        }
+    },
+    truncate(path, lenOrCb, callback) {
+        if (typeof lenOrCb === "function") {
+            callback = lenOrCb;
+            lenOrCb = 0;
+        }
+        if (callback) {
+            try {
+                fs.truncateSync(path, lenOrCb);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.truncateSync(path, lenOrCb));
+        }
+    },
+    utimes(path, atime, mtime, callback) {
+        if (callback) {
+            try {
+                fs.utimesSync(path, atime, mtime);
+                callback(null);
+            }
+            catch (e) {
+                callback(e);
+            }
+        }
+        else {
+            return Promise.resolve(fs.utimesSync(path, atime, mtime));
+        }
+    },
+};
+// Wire late-bound glob helpers to the fs object
+_globReadDir = (dir) => fs.readdirSync(dir);
+_globStat = (path) => fs.statSync(path);
+// Export the fs module
+export default fs;