@componentor/fs 3.0.28 → 3.0.30

package/dist/index.d.mts

@@ -311,6 +311,18 @@ type AsyncRequestFn = (op: number, path: string, flags?: number, data?: Uint8Arr
     data: Uint8Array | null;
 }>;
 
+/**
+ * VFSFileSystem — main thread API.
+ *
+ * Provides Node.js-compatible sync and async filesystem methods.
+ * Sync methods use SAB + Atomics to block until the server responds.
+ * Async methods use postMessage to the async relay worker.
+ *
+ * On import, workers are spawned immediately. Every method blocks
+ * (or waits) until the worker is ready. This is by design — the library
+ * primarily runs inside workers where blocking is fine.
+ */
+
 declare class VFSFileSystem {
     private sab;
     private ctrl;
@@ -388,8 +400,9 @@ declare class VFSFileSystem {
     rmdirSync(filePath: PathLike, options?: RmdirOptions): void;
     rmSync(filePath: PathLike, options?: RmOptions): void;
     unlinkSync(filePath: PathLike): void;
-    readdirSync(filePath: PathLike, options?: ReaddirOptions | Encoding | null): string[] | Dirent[];
+    readdirSync(filePath: PathLike, options?: ReaddirOptions | Encoding | null): string[] | Uint8Array[] | Dirent[];
     globSync(pattern: string, options?: GlobOptions): string[];
+    opendirSync(filePath: PathLike): Dir;
     statSync(filePath: PathLike, options?: StatOptions): Stats | BigIntStats;
     lstatSync(filePath: PathLike, options?: StatOptions): Stats | BigIntStats;
     renameSync(oldPath: PathLike, newPath: PathLike): void;
@@ -410,6 +423,8 @@ declare class VFSFileSystem {
     /** chown on an open file descriptor. No-op in this VFS (permissions are cosmetic). */
     fchownSync(_fd: number, _uid: number, _gid: number): void;
     utimesSync(filePath: PathLike, atime: Date | number, mtime: Date | number): void;
+    /** utimes on an open file descriptor. No-op in this VFS (cannot resolve fd to path). */
+    futimesSync(_fd: number, _atime: Date | number, _mtime: Date | number): void;
     /** Like utimesSync but operates on the symlink itself. In this VFS, delegates to utimesSync. */
     lutimesSync(filePath: string, atime: Date | number, mtime: Date | number): void;
     symlinkSync(target: PathLike, linkPath: PathLike, type?: string | null): void;
@@ -515,12 +530,73 @@ declare class VFSFileSystem {
     cp(src: string, dest: string, options: CpOptions, callback: (err: Error | null) => void): void;
     fdatasync(fd: number, callback: (err: Error | null) => void): void;
     fsync(fd: number, callback: (err: Error | null) => void): void;
+    fstat(fd: number, callback: (err: Error | null, stats?: Stats) => void): void;
+    fstat(fd: number, options: any, callback: (err: Error | null, stats?: Stats) => void): void;
+    ftruncate(fd: number, callback: (err: Error | null) => void): void;
+    ftruncate(fd: number, len: number, callback: (err: Error | null) => void): void;
+    read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, callback: (err: Error | null, bytesRead?: number, buffer?: Uint8Array) => void): void;
+    write(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, callback: (err: Error | null, bytesWritten?: number, buffer?: Uint8Array) => void): void;
+    write(fd: number, data: string, position: number | null | undefined, encoding: string | undefined, callback: (err: Error | null, bytesWritten?: number, data?: string) => void): void;
+    close(fd: number, callback?: (err: Error | null) => void): void;
     exists(filePath: string, callback: (exists: boolean) => void): void;
+    opendir(filePath: string, callback: (err: Error | null, dir?: Dir) => void): void;
+    glob(pattern: string, callback: (err: Error | null, matches?: string[]) => void): void;
+    glob(pattern: string, options: GlobOptions, callback: (err: Error | null, matches?: string[]) => void): void;
+    futimes(fd: number, atime: Date | number, mtime: Date | number, callback: (err: Error | null) => void): void;
+    fchmod(fd: number, mode: number, callback: (err: Error | null) => void): void;
+    fchown(fd: number, uid: number, gid: number, callback: (err: Error | null) => void): void;
+    lchmod(filePath: string, mode: number, callback: (err: Error | null) => void): void;
+    lchown(filePath: string, uid: number, gid: number, callback: (err: Error | null) => void): void;
+    lutimes(filePath: string, atime: Date | number, mtime: Date | number, callback: (err: Error | null) => void): void;
 }
 declare class VFSPromises {
     private _async;
     private _ns;
     constructor(asyncRequest: AsyncRequestFn, ns: string);
+    /** Node.js compat: fs.promises.constants (same as fs.constants) */
+    get constants(): {
+        readonly F_OK: 0;
+        readonly R_OK: 4;
+        readonly W_OK: 2;
+        readonly X_OK: 1;
+        readonly COPYFILE_EXCL: 1;
+        readonly COPYFILE_FICLONE: 2;
+        readonly COPYFILE_FICLONE_FORCE: 4;
+        readonly O_RDONLY: 0;
+        readonly O_WRONLY: 1;
+        readonly O_RDWR: 2;
+        readonly O_CREAT: 64;
+        readonly O_EXCL: 128;
+        readonly O_TRUNC: 512;
+        readonly O_APPEND: 1024;
+        readonly O_NOCTTY: 256;
+        readonly O_NONBLOCK: 2048;
+        readonly O_SYNC: 4096;
+        readonly O_DSYNC: 4096;
+        readonly O_DIRECTORY: 65536;
+        readonly O_NOFOLLOW: 131072;
+        readonly O_NOATIME: 262144;
+        readonly S_IFMT: 61440;
+        readonly S_IFREG: 32768;
+        readonly S_IFDIR: 16384;
+        readonly S_IFCHR: 8192;
+        readonly S_IFBLK: 24576;
+        readonly S_IFIFO: 4096;
+        readonly S_IFLNK: 40960;
+        readonly S_IFSOCK: 49152;
+        readonly S_IRWXU: 448;
+        readonly S_IRUSR: 256;
+        readonly S_IWUSR: 128;
+        readonly S_IXUSR: 64;
+        readonly S_IRWXG: 56;
+        readonly S_IRGRP: 32;
+        readonly S_IWGRP: 16;
+        readonly S_IXGRP: 8;
+        readonly S_IRWXO: 7;
+        readonly S_IROTH: 4;
+        readonly S_IWOTH: 2;
+        readonly S_IXOTH: 1;
+    };
     readFile(filePath: PathLike, options?: ReadOptions | Encoding | null): Promise<string | Uint8Array<ArrayBufferLike>>;
     writeFile(filePath: PathLike, data: string | Uint8Array, options?: WriteOptions | Encoding): Promise<void>;
     appendFile(filePath: PathLike, data: string | Uint8Array, options?: WriteOptions | Encoding): Promise<void>;
@@ -528,7 +604,7 @@ declare class VFSPromises {
     rmdir(filePath: PathLike, options?: RmdirOptions): Promise<void>;
     rm(filePath: PathLike, options?: RmOptions): Promise<void>;
     unlink(filePath: PathLike): Promise<void>;
-    readdir(filePath: PathLike, options?: ReaddirOptions | Encoding | null): Promise<string[] | Dirent[]>;
+    readdir(filePath: PathLike, options?: ReaddirOptions | Encoding | null): Promise<Uint8Array<ArrayBufferLike>[] | string[] | Dirent[]>;
     glob(pattern: string, options?: GlobOptions): Promise<string[]>;
     stat(filePath: PathLike, options?: StatOptions): Promise<BigIntStats | Stats>;
     lstat(filePath: PathLike, options?: StatOptions): Promise<BigIntStats | Stats>;
@@ -550,6 +626,8 @@ declare class VFSPromises {
     /** chown on an open file descriptor. No-op in this VFS (permissions are cosmetic). */
     fchown(_fd: number, _uid: number, _gid: number): Promise<void>;
     utimes(filePath: PathLike, atime: Date | number, mtime: Date | number): Promise<void>;
+    /** utimes on an open file descriptor. No-op in this VFS (cannot resolve fd to path). */
+    futimes(_fd: number, _atime: Date | number, _mtime: Date | number): Promise<void>;
     /** Like utimes but operates on the symlink itself. In this VFS, delegates to utimes. */
     lutimes(filePath: string, atime: Date | number, mtime: Date | number): Promise<void>;
     symlink(target: PathLike, linkPath: PathLike, type?: string | null): Promise<void>;
@@ -856,4 +934,4 @@ declare function getDefaultFS(): VFSFileSystem;
 /** Async init helper — avoids blocking main thread */
 declare function init(): Promise<void>;
 
-export { type BigIntStats, type CpOptions, type Dir, type Dirent, type Encoding, FSError, type FSMode, type FSReadStream, type FSWatcher, type FSWriteStream, type FileHandle, type LoadResult, type MkdirOptions, NodeReadable, NodeWritable, type OpenAsBlobOptions, type PathLike, type ReadOptions, type ReadStreamOptions, type ReaddirOptions, type RepairResult, type RmOptions, type RmdirOptions, SimpleEventEmitter, type StatFs, type StatOptions, type Stats, type UnpackResult, type VFSConfig, VFSFileSystem, type VFSLimits, type WatchEventType, type WatchFileListener, type WatchListener, type WatchOptions, type WriteOptions, type WriteStreamOptions, constants, createError, createFS, getDefaultFS, init, loadFromOPFS, path, repairVFS, statusToError, unpackToOPFS };
+export { type BigIntStats, type CpOptions, type Dir, type Dirent, type Encoding, FSError, type FSMode, type FSReadStream, type FSWatcher, type FSWriteStream, type FileHandle, type LoadResult, type MkdirOptions, NodeReadable, NodeWritable, type OpenAsBlobOptions, type PathLike, type ReadOptions, NodeReadable as ReadStream, type ReadStreamOptions, type ReaddirOptions, type RepairResult, type RmOptions, type RmdirOptions, SimpleEventEmitter, type StatFs, type StatOptions, type Stats, type UnpackResult, type VFSConfig, VFSFileSystem, type VFSLimits, type WatchEventType, type WatchFileListener, type WatchListener, type WatchOptions, type WriteOptions, NodeWritable as WriteStream, type WriteStreamOptions, constants, createError, createFS, getDefaultFS, init, loadFromOPFS, path, repairVFS, statusToError, unpackToOPFS };

package/dist/index.js

@@ -1176,6 +1176,21 @@ async function readFile(asyncRequest, filePath, options) {
   }
 }
 
+// src/methods/chmod.ts
+function chmodSync(syncRequest, filePath, mode) {
+  const modeBuf = new Uint8Array(4);
+  new DataView(modeBuf.buffer).setUint32(0, mode, true);
+  const buf = encodeRequest(OP.CHMOD, filePath, 0, modeBuf);
+  const { status } = syncRequest(buf);
+  if (status !== 0) throw statusToError(status, "chmod", filePath);
+}
+async function chmod(asyncRequest, filePath, mode) {
+  const modeBuf = new Uint8Array(4);
+  new DataView(modeBuf.buffer).setUint32(0, mode, true);
+  const { status } = await asyncRequest(OP.CHMOD, filePath, 0, modeBuf);
+  if (status !== 0) throw statusToError(status, "chmod", filePath);
+}
+
 // src/methods/writeFile.ts
 var encoder3 = new TextEncoder();
 function writeFileSync(syncRequest, filePath, data, options) {
@@ -1191,9 +1206,12 @@ function writeFileSync(syncRequest, filePath, data, options) {
     const buf = encodeRequest(OP.WRITE, filePath, flags, encoded);
     const { status } = syncRequest(buf);
     if (status !== 0) throw statusToError(status, "write", filePath);
+    if (opts?.mode !== void 0) {
+      chmodSync(syncRequest, filePath, opts.mode);
+    }
     return;
   }
-  const fd = openSync(syncRequest, filePath, flag);
+  const fd = openSync(syncRequest, filePath, flag, opts?.mode);
   try {
     writeSyncFd(syncRequest, fd, encoded, 0, encoded.byteLength, 0);
   } finally {
@@ -1213,9 +1231,12 @@ async function writeFile(asyncRequest, filePath, data, options) {
     const { status } = await asyncRequest(OP.WRITE, filePath, flags, encoded);
     if (signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
     if (status !== 0) throw statusToError(status, "write", filePath);
+    if (opts?.mode !== void 0) {
+      await chmod(asyncRequest, filePath, opts.mode);
+    }
     return;
   }
-  const handle = await open(asyncRequest, filePath, flag);
+  const handle = await open(asyncRequest, filePath, flag, opts?.mode);
   try {
     await handle.writeFile(encoded);
     if (signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
@@ -1371,6 +1392,10 @@ async function unlink(asyncRequest, filePath) {
 }
 
 // src/methods/readdir.ts
+var textEncoder = new TextEncoder();
+function namesToBuffers(names) {
+  return names.map((n) => textEncoder.encode(n));
+}
 function readdirBaseSync(syncRequest, filePath, withFileTypes) {
   const flags = withFileTypes ? 1 : 0;
   const buf = encodeRequest(OP.READDIR, filePath, flags);
@@ -1456,28 +1481,46 @@ async function readdirRecursiveAsync(asyncRequest, basePath, prefix, withFileTyp
   return results;
 }
 function readdirSync(syncRequest, filePath, options) {
-  const opts = typeof options === "string" ? { } : options;
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const asBuffer = opts?.encoding === "buffer";
   if (opts?.recursive) {
-    return readdirRecursiveSync(
+    const result2 = readdirRecursiveSync(
       syncRequest,
       filePath,
       "",
       !!opts?.withFileTypes
     );
+    if (asBuffer && !opts?.withFileTypes) {
+      return namesToBuffers(result2);
+    }
+    return result2;
   }
-  return readdirBaseSync(syncRequest, filePath, !!opts?.withFileTypes);
+  const result = readdirBaseSync(syncRequest, filePath, !!opts?.withFileTypes);
+  if (asBuffer && !opts?.withFileTypes) {
+    return namesToBuffers(result);
+  }
+  return result;
 }
 async function readdir(asyncRequest, filePath, options) {
-  const opts = typeof options === "string" ? { } : options;
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const asBuffer = opts?.encoding === "buffer";
   if (opts?.recursive) {
-    return readdirRecursiveAsync(
+    const result2 = await readdirRecursiveAsync(
       asyncRequest,
       filePath,
       "",
       !!opts?.withFileTypes
     );
+    if (asBuffer && !opts?.withFileTypes) {
+      return namesToBuffers(result2);
+    }
+    return result2;
+  }
+  const result = await readdirBaseAsync(asyncRequest, filePath, !!opts?.withFileTypes);
+  if (asBuffer && !opts?.withFileTypes) {
+    return namesToBuffers(result);
   }
-  return readdirBaseAsync(asyncRequest, filePath, !!opts?.withFileTypes);
+  return result;
 }
 
 // src/methods/stat.ts
@@ -1576,21 +1619,6 @@ async function realpath(asyncRequest, filePath) {
   return decoder5.decode(data);
 }
 
-// src/methods/chmod.ts
-function chmodSync(syncRequest, filePath, mode) {
-  const modeBuf = new Uint8Array(4);
-  new DataView(modeBuf.buffer).setUint32(0, mode, true);
-  const buf = encodeRequest(OP.CHMOD, filePath, 0, modeBuf);
-  const { status } = syncRequest(buf);
-  if (status !== 0) throw statusToError(status, "chmod", filePath);
-}
-async function chmod(asyncRequest, filePath, mode) {
-  const modeBuf = new Uint8Array(4);
-  new DataView(modeBuf.buffer).setUint32(0, mode, true);
-  const { status } = await asyncRequest(OP.CHMOD, filePath, 0, modeBuf);
-  if (status !== 0) throw statusToError(status, "chmod", filePath);
-}
-
 // src/methods/chown.ts
 function chownSync(syncRequest, filePath, uid, gid) {
   const ownerBuf = new Uint8Array(8);
@@ -2326,6 +2354,12 @@ var VFSFileSystem = class {
       this.rejectReady = reject;
     });
     this.promises = new VFSPromises(this._async, ns);
+    const boundRealpath = this.realpath.bind(this);
+    boundRealpath.native = boundRealpath;
+    this.realpath = boundRealpath;
+    const boundRealpathSync = this.realpathSync.bind(this);
+    boundRealpathSync.native = boundRealpathSync;
+    this.realpathSync = boundRealpathSync;
     instanceRegistry.set(ns, this);
     this.bootstrap();
   }
@@ -2799,6 +2833,25 @@ var VFSFileSystem = class {
   globSync(pattern, options) {
     return globSync(this._sync, pattern, options);
   }
+  opendirSync(filePath) {
+    const dirPath = toPathString(filePath);
+    const entries = this.readdirSync(dirPath, { withFileTypes: true });
+    let index = 0;
+    return {
+      path: dirPath,
+      async read() {
+        if (index >= entries.length) return null;
+        return entries[index++];
+      },
+      async close() {
+      },
+      async *[Symbol.asyncIterator]() {
+        for (const entry of entries) {
+          yield entry;
+        }
+      }
+    };
+  }
   statSync(filePath, options) {
     return statSync(this._sync, toPathString(filePath), options);
   }
@@ -2951,6 +3004,9 @@ var VFSFileSystem = class {
   utimesSync(filePath, atime, mtime) {
     utimesSync(this._sync, toPathString(filePath), atime, mtime);
   }
+  /** utimes on an open file descriptor. No-op in this VFS (cannot resolve fd to path). */
+  futimesSync(_fd, _atime, _mtime) {
+  }
   /** Like utimesSync but operates on the symlink itself. In this VFS, delegates to utimesSync. */
   lutimesSync(filePath, atime, mtime) {
     utimesSync(this._sync, filePath, atime, mtime);
@@ -3026,9 +3082,9 @@ var VFSFileSystem = class {
     }
     try {
       const bytesRead = this.readvSync(fd, buffers, pos);
-      cb(null, bytesRead, buffers);
+      setTimeout(() => cb(null, bytesRead, buffers), 0);
     } catch (err) {
-      cb(err);
+      setTimeout(() => cb(err), 0);
     }
   }
   writev(fd, buffers, positionOrCallback, callback) {
@@ -3043,9 +3099,9 @@ var VFSFileSystem = class {
     }
     try {
       const bytesWritten = this.writevSync(fd, buffers, pos);
-      cb(null, bytesWritten, buffers);
+      setTimeout(() => cb(null, bytesWritten, buffers), 0);
     } catch (err) {
-      cb(err);
+      setTimeout(() => cb(err), 0);
     }
   }
   // ---- statfs methods ----
@@ -3446,17 +3502,72 @@ var VFSFileSystem = class {
   fdatasync(fd, callback) {
     try {
       this.fdatasyncSync(fd);
-      callback(null);
+      setTimeout(() => callback(null), 0);
     } catch (err) {
-      callback(err);
+      setTimeout(() => callback(err), 0);
     }
   }
   fsync(fd, callback) {
     try {
       this.fsyncSync(fd);
-      callback(null);
+      setTimeout(() => callback(null), 0);
+    } catch (err) {
+      setTimeout(() => callback(err), 0);
+    }
+  }
+  fstat(fd, optionsOrCallback, callback) {
+    const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    try {
+      const result = this.fstatSync(fd);
+      setTimeout(() => cb(null, result), 0);
+    } catch (err) {
+      setTimeout(() => cb(err), 0);
+    }
+  }
+  ftruncate(fd, lenOrCallback, callback) {
+    const cb = typeof lenOrCallback === "function" ? lenOrCallback : callback;
+    const len = typeof lenOrCallback === "function" ? 0 : lenOrCallback;
+    try {
+      this.ftruncateSync(fd, len);
+      setTimeout(() => cb(null), 0);
+    } catch (err) {
+      setTimeout(() => cb(err), 0);
+    }
+  }
+  read(fd, buffer, offset, length, position, callback) {
+    try {
+      const bytesRead = this.readSync(fd, buffer, offset, length, position);
+      setTimeout(() => callback(null, bytesRead, buffer), 0);
     } catch (err) {
-      callback(err);
+      setTimeout(() => callback(err), 0);
+    }
+  }
+  write(fd, bufferOrString, offsetOrPosition, lengthOrEncoding, position, callback) {
+    const cb = [offsetOrPosition, lengthOrEncoding, position, callback].find((a) => typeof a === "function");
+    try {
+      let bytesWritten;
+      if (typeof bufferOrString === "string") {
+        const pos = typeof offsetOrPosition === "function" ? void 0 : offsetOrPosition;
+        const enc = typeof lengthOrEncoding === "function" ? void 0 : lengthOrEncoding;
+        bytesWritten = this.writeSync(fd, bufferOrString, pos, enc);
+      } else {
+        const off = typeof offsetOrPosition === "function" ? void 0 : offsetOrPosition;
+        const len = typeof lengthOrEncoding === "function" ? void 0 : lengthOrEncoding;
+        const pos = typeof position === "function" ? void 0 : position;
+        bytesWritten = this.writeSync(fd, bufferOrString, off, len, pos);
+      }
+      setTimeout(() => cb(null, bytesWritten, bufferOrString), 0);
+    } catch (err) {
+      setTimeout(() => cb(err), 0);
+    }
+  }
+  close(fd, callback) {
+    try {
+      this.closeSync(fd);
+      if (callback) setTimeout(() => callback(null), 0);
+    } catch (err) {
+      if (callback) setTimeout(() => callback(err), 0);
+      else throw err;
     }
   }
   exists(filePath, callback) {
@@ -3465,6 +3576,47 @@ var VFSFileSystem = class {
       () => setTimeout(() => callback(false), 0)
     );
   }
+  opendir(filePath, callback) {
+    this.promises.opendir(filePath).then(
+      (dir) => setTimeout(() => callback(null, dir), 0),
+      (err) => setTimeout(() => callback(err), 0)
+    );
+  }
+  glob(pattern, optionsOrCallback, callback) {
+    const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
+    this.promises.glob(pattern, opts).then(
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
+    );
+  }
+  futimes(fd, atime, mtime, callback) {
+    setTimeout(() => callback(null), 0);
+  }
+  fchmod(fd, mode, callback) {
+    setTimeout(() => callback(null), 0);
+  }
+  fchown(fd, uid, gid, callback) {
+    setTimeout(() => callback(null), 0);
+  }
+  lchmod(filePath, mode, callback) {
+    this.promises.lchmod(filePath, mode).then(
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
+    );
+  }
+  lchown(filePath, uid, gid, callback) {
+    this.promises.lchown(filePath, uid, gid).then(
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
+    );
+  }
+  lutimes(filePath, atime, mtime, callback) {
+    this.promises.lutimes(filePath, atime, mtime).then(
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
+    );
+  }
 };
 var VFSPromises = class {
   _async;
@@ -3473,6 +3625,10 @@ var VFSPromises = class {
     this._async = asyncRequest;
     this._ns = ns;
   }
+  /** Node.js compat: fs.promises.constants (same as fs.constants) */
+  get constants() {
+    return constants;
+  }
   readFile(filePath, options) {
     return readFile(this._async, toPathString(filePath), options);
   }
@@ -3602,6 +3758,9 @@ var VFSPromises = class {
   utimes(filePath, atime, mtime) {
     return utimes(this._async, toPathString(filePath), atime, mtime);
   }
+  /** utimes on an open file descriptor. No-op in this VFS (cannot resolve fd to path). */
+  async futimes(_fd, _atime, _mtime) {
+  }
   /** Like utimes but operates on the symlink itself. In this VFS, delegates to utimes. */
   lutimes(filePath, atime, mtime) {
     return utimes(this._async, filePath, atime, mtime);
@@ -5332,6 +5491,6 @@ function init() {
   return getDefaultFS().init();
 }
 
-export { FSError, NodeReadable, NodeWritable, SimpleEventEmitter, VFSFileSystem, constants, createError, createFS, getDefaultFS, init, loadFromOPFS, path_exports as path, repairVFS, statusToError, unpackToOPFS };
+export { FSError, NodeReadable, NodeWritable, NodeReadable as ReadStream, SimpleEventEmitter, VFSFileSystem, NodeWritable as WriteStream, constants, createError, createFS, getDefaultFS, init, loadFromOPFS, path_exports as path, repairVFS, statusToError, unpackToOPFS };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map