@componentor/fs 3.0.27 → 3.0.29

package/dist/index.js

@@ -71,6 +71,7 @@ var NodeReadable = class extends SimpleEventEmitter {
   _ended = false;
   _reading = false;
   _readBuffer = null;
+  _encoding = null;
   /** Whether the stream is still readable (not ended or destroyed). */
   readable = true;
   /** The file path this stream reads from (set externally). */
@@ -97,6 +98,14 @@ var NodeReadable = class extends SimpleEventEmitter {
     this._drain();
     return this;
   }
+  /**
+   * Set the character encoding for data read from this stream.
+   * When set, 'data' events emit strings instead of Uint8Array.
+   */
+  setEncoding(encoding) {
+    this._encoding = encoding;
+    return this;
+  }
   /**
    * Non-flowing read — returns the last buffered chunk or null.
    * Node.js has a complex buffer system; we keep it simple here.
@@ -174,7 +183,11 @@ var NodeReadable = class extends SimpleEventEmitter {
         }
         this.bytesRead += result.value.byteLength;
         this._readBuffer = result.value;
-        this.emit("data", result.value);
+        if (this._encoding) {
+          this.emit("data", new TextDecoder(this._encoding).decode(result.value));
+        } else {
+          this.emit("data", result.value);
+        }
       }
     } catch (err) {
       if (!this._destroyed) {
@@ -201,7 +214,22 @@ var NodeWritable = class extends SimpleEventEmitter {
   _destroyed = false;
   _finished = false;
   _writing = false;
+  _corked = false;
   // -- public API -----------------------------------------------------------
+  /**
+   * Buffer all writes until `uncork()` is called.
+   * In this minimal implementation we only track the flag for compatibility.
+   */
+  cork() {
+    this._corked = true;
+  }
+  /**
+   * Flush buffered writes (clears the cork flag).
+   * In this minimal implementation we only track the flag for compatibility.
+   */
+  uncork() {
+    this._corked = false;
+  }
   write(chunk, encodingOrCb, cb) {
     const callback = typeof encodingOrCb === "function" ? encodingOrCb : cb;
     if (this._destroyed || this._finished) {
@@ -1148,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) {
@@ -1163,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 {
@@ -1185,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");
@@ -1343,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);
@@ -1428,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;
+  }
+  const result = readdirBaseSync(syncRequest, filePath, !!opts?.withFileTypes);
+  if (asBuffer && !opts?.withFileTypes) {
+    return namesToBuffers(result);
   }
-  return readdirBaseSync(syncRequest, filePath, !!opts?.withFileTypes);
+  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
@@ -1548,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);
@@ -2002,7 +2058,11 @@ function emptyStats() {
     atime: zero,
     mtime: zero,
     ctime: zero,
-    birthtime: zero
+    birthtime: zero,
+    atimeNs: 0,
+    mtimeNs: 0,
+    ctimeNs: 0,
+    birthtimeNs: 0
   };
 }
 async function* watchAsync(ns, _asyncRequest, filePath, options) {
@@ -2294,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();
   }
@@ -2767,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);
   }
@@ -2919,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);
@@ -2957,6 +3045,9 @@ var VFSFileSystem = class {
   fdatasyncSync(fd) {
     fdatasyncSync(this._sync, fd);
   }
+  fsyncSync(fd) {
+    fdatasyncSync(this._sync, fd);
+  }
   // ---- Vector I/O methods ----
   readvSync(fd, buffers, position) {
     let totalRead = 0;
@@ -3232,168 +3323,168 @@ var VFSFileSystem = class {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.readFile(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   writeFile(filePath, data, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.writeFile(filePath, data, opts).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   appendFile(filePath, data, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.appendFile(filePath, data, opts).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   mkdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.mkdir(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   rmdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.rmdir(filePath, opts).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   rm(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.rm(filePath, opts).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   unlink(filePath, callback) {
     this.promises.unlink(filePath).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   readdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.readdir(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   stat(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.stat(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   lstat(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.lstat(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   access(filePath, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
     this.promises.access(filePath, mode).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   rename(oldPath, newPath, callback) {
     this.promises.rename(oldPath, newPath).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   copyFile(src, dest, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
     this.promises.copyFile(src, dest, mode).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   truncate(filePath, lenOrCallback, callback) {
     const cb = typeof lenOrCallback === "function" ? lenOrCallback : callback;
     const len = typeof lenOrCallback === "function" ? void 0 : lenOrCallback;
     this.promises.truncate(filePath, len).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   realpath(filePath, callback) {
     this.promises.realpath(filePath).then(
-      (result) => callback(null, result),
-      (err) => callback(err)
+      (result) => setTimeout(() => callback(null, result), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   chmod(filePath, mode, callback) {
     this.promises.chmod(filePath, mode).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   chown(filePath, uid, gid, callback) {
     this.promises.chown(filePath, uid, gid).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   utimes(filePath, atime, mtime, callback) {
     this.promises.utimes(filePath, atime, mtime).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   symlink(target, linkPath, typeOrCallback, callback) {
     const cb = typeof typeOrCallback === "function" ? typeOrCallback : callback;
     const type = typeof typeOrCallback === "function" ? void 0 : typeOrCallback;
     this.promises.symlink(target, linkPath, type).then(
-      () => cb(null),
-      (err) => cb(err)
+      () => setTimeout(() => cb(null), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   readlink(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     this.promises.readlink(filePath, opts).then(
-      (result) => cb(null, result),
-      (err) => cb(err)
+      (result) => setTimeout(() => cb(null, result), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   link(existingPath, newPath, callback) {
     this.promises.link(existingPath, newPath).then(
-      () => callback(null),
-      (err) => callback(err)
+      () => setTimeout(() => callback(null), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   open(filePath, flags, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
     this.promises.open(filePath, flags, mode).then(
-      (handle) => cb(null, handle.fd),
-      (err) => cb(err)
+      (handle) => setTimeout(() => cb(null, handle.fd), 0),
+      (err) => setTimeout(() => cb(err), 0)
     );
   }
   mkdtemp(prefix, callback) {
     this.promises.mkdtemp(prefix).then(
-      (result) => callback(null, result),
-      (err) => callback(err)
+      (result) => setTimeout(() => callback(null, result), 0),
+      (err) => setTimeout(() => callback(err), 0)
     );
   }
   cp(src, dest, optionsOrCallback, callback) {
@@ -3401,19 +3492,113 @@ var VFSFileSystem = class {
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     if (cb) {
       this._cpAsync(src, dest, opts).then(
-        () => cb(null),
-        (err) => cb(err)
+        () => setTimeout(() => cb(null), 0),
+        (err) => setTimeout(() => cb(err), 0)
       );
       return;
     }
     return this._cpAsync(src, dest, opts);
   }
+  fdatasync(fd, callback) {
+    try {
+      this.fdatasyncSync(fd);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  }
+  fsync(fd, callback) {
+    try {
+      this.fsyncSync(fd);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  }
+  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) {
+      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) {
     this.promises.exists(filePath).then(
-      (result) => callback(result),
-      () => callback(false)
+      (result) => setTimeout(() => callback(result), 0),
+      () => 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);
+  }
 };
 var VFSPromises = class {
   _async;
@@ -3422,6 +3607,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);
   }
@@ -3551,6 +3740,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);
@@ -3597,6 +3789,12 @@ var VFSPromises = class {
   async *watch(filePath, options) {
     yield* watchAsync(this._ns, this._async, filePath, options);
   }
+  async fsync(_fd) {
+    await this._async(OP.FSYNC, "");
+  }
+  async fdatasync(_fd) {
+    await this._async(OP.FSYNC, "");
+  }
   async flush() {
     await this._async(OP.FSYNC, "");
   }
@@ -5275,6 +5473,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