@componentor/fs 3.0.30 → 3.0.33

package/dist/index.js

@@ -59,6 +59,25 @@ var SimpleEventEmitter = class {
   listenerCount(event) {
     return this._listeners.get(event)?.length ?? 0;
   }
+  rawListeners(event) {
+    return [...this._listeners.get(event) ?? []];
+  }
+  prependListener(event, fn) {
+    const arr = this._listeners.get(event) ?? [];
+    arr.unshift(fn);
+    this._listeners.set(event, arr);
+    return this;
+  }
+  prependOnceListener(event, fn) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      fn(...args);
+    };
+    return this.prependListener(event, wrapper);
+  }
+  eventNames() {
+    return [...this._listeners.keys()].filter((k) => (this._listeners.get(k)?.length ?? 0) > 0);
+  }
 };
 var NodeReadable = class extends SimpleEventEmitter {
   constructor(_readFn, destroyFn) {
@@ -852,13 +871,13 @@ function writeSyncFd(syncRequest, fd, bufferOrString, offsetOrPositionOrOptions,
   if (status !== 0) throw statusToError(status, "write", String(fd));
   return data ? new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) : 0;
 }
-function fstatSync(syncRequest, fd) {
+function fstatSync(syncRequest, fd, options) {
   const fdBuf = new Uint8Array(4);
   new DataView(fdBuf.buffer).setUint32(0, fd, true);
   const buf = encodeRequest(OP.FSTAT, "", 0, fdBuf);
   const { status, data } = syncRequest(buf);
   if (status !== 0) throw statusToError(status, "fstat", String(fd));
-  return decodeStats(data);
+  return options?.bigint ? decodeStatsBigInt(data) : decodeStats(data);
 }
 function ftruncateSync(syncRequest, fd, len = 0) {
   const fdBuf = new Uint8Array(12);
@@ -1775,7 +1794,7 @@ function toPathString(p) {
     }
     return decodeURIComponent(p.pathname);
   }
-  return String(p);
+  throw new TypeError('The "path" argument must be of type string, Uint8Array, or URL. Received ' + typeof p);
 }
 var sep = "/";
 var delimiter = ":";
@@ -3036,8 +3055,8 @@ var VFSFileSystem = class {
   writeSync(fd, bufferOrString, offsetOrPositionOrOptions, lengthOrEncoding, position) {
     return writeSyncFd(this._sync, fd, bufferOrString, offsetOrPositionOrOptions, lengthOrEncoding, position);
   }
-  fstatSync(fd) {
-    return fstatSync(this._sync, fd);
+  fstatSync(fd, options) {
+    return fstatSync(this._sync, fd, options);
   }
   ftruncateSync(fd, len) {
     ftruncateSync(this._sync, fd, len);
@@ -3080,11 +3099,13 @@ var VFSFileSystem = class {
       pos = positionOrCallback;
       cb = callback;
     }
+    this._validateCb(cb);
     try {
       const bytesRead = this.readvSync(fd, buffers, pos);
-      setTimeout(() => cb(null, bytesRead, buffers), 0);
+      if (cb) setTimeout(() => cb(null, bytesRead, buffers), 0);
     } catch (err) {
-      setTimeout(() => cb(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   writev(fd, buffers, positionOrCallback, callback) {
@@ -3097,11 +3118,13 @@ var VFSFileSystem = class {
       pos = positionOrCallback;
       cb = callback;
     }
+    this._validateCb(cb);
     try {
       const bytesWritten = this.writevSync(fd, buffers, pos);
-      setTimeout(() => cb(null, bytesWritten, buffers), 0);
+      if (cb) setTimeout(() => cb(null, bytesWritten, buffers), 0);
     } catch (err) {
-      setTimeout(() => cb(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   // ---- statfs methods ----
@@ -3124,7 +3147,8 @@ var VFSFileSystem = class {
   statfs(path, callback) {
     const result = this.statfsSync(path);
     if (callback) {
-      callback(null, result);
+      this._validateCb(callback);
+      setTimeout(() => callback(null, result), 0);
       return;
     }
     return Promise.resolve(result);
@@ -3155,18 +3179,24 @@ var VFSFileSystem = class {
     let handle = null;
     let finished = false;
     const cleanup = async () => {
-      if (handle) {
+      if (handle && ownsHandle) {
         try {
           await handle.close();
         } catch {
         }
-        handle = null;
       }
+      handle = null;
     };
+    const providedFd = opts?.fd;
+    let ownsHandle = providedFd == null;
     const readFn = async () => {
       if (finished) return { done: true };
       if (!handle) {
-        handle = await this.promises.open(toPathString(filePath), opts?.flags ?? "r");
+        if (providedFd != null) {
+          handle = createFileHandle(providedFd, this._async);
+        } else {
+          handle = await this.promises.open(toPathString(filePath), opts?.flags ?? "r");
+        }
       }
       const readLen = end !== void 0 ? Math.min(highWaterMark, end - position + 1) : highWaterMark;
       if (readLen <= 0) {
@@ -3197,9 +3227,15 @@ var VFSFileSystem = class {
     const opts = typeof options === "string" ? { } : options;
     let position = opts?.start ?? 0;
     let handle = null;
+    const providedWFd = opts?.fd;
+    const ownsWHandle = providedWFd == null;
     const writeFn = async (chunk) => {
       if (!handle) {
-        handle = await this.promises.open(toPathString(filePath), opts?.flags ?? "w");
+        if (providedWFd != null) {
+          handle = createFileHandle(providedWFd, this._async);
+        } else {
+          handle = await this.promises.open(toPathString(filePath), opts?.flags ?? "w");
+        }
       }
       const { bytesWritten } = await handle.write(chunk, 0, chunk.byteLength, position);
       position += bytesWritten;
@@ -3209,7 +3245,9 @@ var VFSFileSystem = class {
         if (opts?.flush) {
           await handle.sync();
         }
-        await handle.close();
+        if (ownsWHandle) {
+          await handle.close();
+        }
         handle = null;
       }
     };
@@ -3319,178 +3357,165 @@ var VFSFileSystem = class {
     }
     return this.readyPromise;
   }
+  // ========== Callback API ==========
+  // Node.js-style callback overloads for all async operations.
+  // These delegate to this.promises.* and adapt the result to (err, result) callbacks.
+  _validateCb(cb) {
+    if (cb !== void 0 && cb !== null && typeof cb !== "function") {
+      throw new TypeError('The "cb" argument must be of type function. Received ' + typeof cb);
+    }
+  }
+  /** Adapt a promise to optional Node.js callback style.
+   *  If cb is a function: calls cb(err, result) via setTimeout. Returns void.
+   *  If cb is missing: returns the promise (allows .then() or await). */
+  _cb(promise, cb, mapResult) {
+    if (typeof cb === "function") {
+      promise.then(
+        (val) => setTimeout(() => cb(null, ...mapResult ? mapResult(val) : [val]), 0),
+        (err) => setTimeout(() => cb(err), 0)
+      );
+      return;
+    }
+    return promise;
+  }
+  /** Like _cb but for void-returning promises (no result value). */
+  _cbVoid(promise, cb) {
+    if (typeof cb === "function") {
+      promise.then(
+        () => setTimeout(() => cb(null), 0),
+        (err) => setTimeout(() => cb(err), 0)
+      );
+      return;
+    }
+    return promise;
+  }
   readFile(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.readFile(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.readFile(filePath, opts), cb);
   }
   writeFile(filePath, data, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.writeFile(filePath, data, opts).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.writeFile(filePath, data, opts), cb);
   }
   appendFile(filePath, data, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.appendFile(filePath, data, opts).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.appendFile(filePath, data, opts), cb);
   }
   mkdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.mkdir(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.mkdir(filePath, opts), cb);
   }
   rmdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.rmdir(filePath, opts).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.rmdir(filePath, opts), cb);
   }
   rm(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.rm(filePath, opts).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.rm(filePath, opts), cb);
   }
   unlink(filePath, callback) {
-    this.promises.unlink(filePath).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.unlink(filePath), callback);
   }
   readdir(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.readdir(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.readdir(filePath, opts), cb);
   }
   stat(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.stat(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.stat(filePath, opts), cb);
   }
   lstat(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.lstat(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.lstat(filePath, opts), cb);
   }
   access(filePath, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
+    this._validateCb(cb);
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
-    this.promises.access(filePath, mode).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.access(filePath, mode), cb);
   }
   rename(oldPath, newPath, callback) {
-    this.promises.rename(oldPath, newPath).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.rename(oldPath, newPath), callback);
   }
   copyFile(src, dest, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
+    this._validateCb(cb);
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
-    this.promises.copyFile(src, dest, mode).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.copyFile(src, dest, mode), cb);
   }
   truncate(filePath, lenOrCallback, callback) {
     const cb = typeof lenOrCallback === "function" ? lenOrCallback : callback;
+    this._validateCb(cb);
     const len = typeof lenOrCallback === "function" ? void 0 : lenOrCallback;
-    this.promises.truncate(filePath, len).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.truncate(filePath, len), cb);
   }
   realpath(filePath, callback) {
-    this.promises.realpath(filePath).then(
-      (result) => setTimeout(() => callback(null, result), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cb(this.promises.realpath(filePath), callback);
   }
   chmod(filePath, mode, callback) {
-    this.promises.chmod(filePath, mode).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.chmod(filePath, mode), callback);
   }
   chown(filePath, uid, gid, callback) {
-    this.promises.chown(filePath, uid, gid).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.chown(filePath, uid, gid), callback);
   }
   utimes(filePath, atime, mtime, callback) {
-    this.promises.utimes(filePath, atime, mtime).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.utimes(filePath, atime, mtime), callback);
   }
   symlink(target, linkPath, typeOrCallback, callback) {
     const cb = typeof typeOrCallback === "function" ? typeOrCallback : callback;
+    this._validateCb(cb);
     const type = typeof typeOrCallback === "function" ? void 0 : typeOrCallback;
-    this.promises.symlink(target, linkPath, type).then(
-      () => setTimeout(() => cb(null), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cbVoid(this.promises.symlink(target, linkPath, type), cb);
   }
   readlink(filePath, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-    this.promises.readlink(filePath, opts).then(
-      (result) => setTimeout(() => cb(null, result), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.readlink(filePath, opts), cb);
   }
   link(existingPath, newPath, callback) {
-    this.promises.link(existingPath, newPath).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.link(existingPath, newPath), callback);
   }
   open(filePath, flags, modeOrCallback, callback) {
     const cb = typeof modeOrCallback === "function" ? modeOrCallback : callback;
+    this._validateCb(cb);
     const mode = typeof modeOrCallback === "function" ? void 0 : modeOrCallback;
-    this.promises.open(filePath, flags, mode).then(
-      (handle) => setTimeout(() => cb(null, handle.fd), 0),
-      (err) => setTimeout(() => cb(err), 0)
-    );
+    return this._cb(this.promises.open(filePath, flags, mode), cb, (handle) => [handle.fd]);
   }
   mkdtemp(prefix, callback) {
-    this.promises.mkdtemp(prefix).then(
-      (result) => setTimeout(() => callback(null, result), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cb(this.promises.mkdtemp(prefix), callback);
   }
   cp(src, dest, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     if (cb) {
+      this._validateCb(cb);
       this._cpAsync(src, dest, opts).then(
         () => setTimeout(() => cb(null), 0),
         (err) => setTimeout(() => cb(err), 0)
@@ -3500,50 +3525,80 @@ var VFSFileSystem = class {
     return this._cpAsync(src, dest, opts);
   }
   fdatasync(fd, callback) {
+    this._validateCb(callback);
     try {
       this.fdatasyncSync(fd);
-      setTimeout(() => callback(null), 0);
+      if (callback) setTimeout(() => callback(null), 0);
     } catch (err) {
-      setTimeout(() => callback(err), 0);
+      if (callback) setTimeout(() => callback(err), 0);
+      else throw err;
     }
   }
   fsync(fd, callback) {
+    this._validateCb(callback);
     try {
       this.fsyncSync(fd);
-      setTimeout(() => callback(null), 0);
+      if (callback) setTimeout(() => callback(null), 0);
     } catch (err) {
-      setTimeout(() => callback(err), 0);
+      if (callback) setTimeout(() => callback(err), 0);
+      else throw err;
     }
   }
   fstat(fd, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
+    const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
     try {
-      const result = this.fstatSync(fd);
-      setTimeout(() => cb(null, result), 0);
+      const result = this.fstatSync(fd, opts);
+      if (cb) setTimeout(() => cb(null, result), 0);
     } catch (err) {
-      setTimeout(() => cb(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   ftruncate(fd, lenOrCallback, callback) {
     const cb = typeof lenOrCallback === "function" ? lenOrCallback : callback;
+    this._validateCb(cb);
     const len = typeof lenOrCallback === "function" ? 0 : lenOrCallback;
     try {
       this.ftruncateSync(fd, len);
-      setTimeout(() => cb(null), 0);
+      if (cb) setTimeout(() => cb(null), 0);
     } catch (err) {
-      setTimeout(() => cb(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   read(fd, buffer, offset, length, position, callback) {
+    let cb;
+    let buf;
+    let off;
+    let len;
+    let pos;
+    if (typeof buffer === "object" && !(buffer instanceof Uint8Array) && buffer !== null && "buffer" in buffer) {
+      cb = offset;
+      buf = buffer.buffer;
+      off = buffer.offset ?? 0;
+      len = buffer.length ?? buf.byteLength;
+      pos = buffer.position ?? null;
+    } else {
+      cb = callback;
+      buf = buffer;
+      off = offset;
+      len = length;
+      pos = position;
+    }
+    this._validateCb(cb);
     try {
-      const bytesRead = this.readSync(fd, buffer, offset, length, position);
-      setTimeout(() => callback(null, bytesRead, buffer), 0);
+      const bytesRead = this.readSync(fd, buf, off, len, pos);
+      if (cb) setTimeout(() => cb(null, bytesRead, buf), 0);
     } catch (err) {
-      setTimeout(() => callback(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   write(fd, bufferOrString, offsetOrPosition, lengthOrEncoding, position, callback) {
     const cb = [offsetOrPosition, lengthOrEncoding, position, callback].find((a) => typeof a === "function");
+    this._validateCb(cb);
     try {
       let bytesWritten;
       if (typeof bufferOrString === "string") {
@@ -3556,9 +3611,10 @@ var VFSFileSystem = class {
         const pos = typeof position === "function" ? void 0 : position;
         bytesWritten = this.writeSync(fd, bufferOrString, off, len, pos);
       }
-      setTimeout(() => cb(null, bytesWritten, bufferOrString), 0);
+      if (cb) setTimeout(() => cb(null, bytesWritten, bufferOrString), 0);
     } catch (err) {
-      setTimeout(() => cb(err), 0);
+      if (cb) setTimeout(() => cb(err), 0);
+      else throw err;
     }
   }
   close(fd, callback) {
@@ -3571,51 +3627,49 @@ var VFSFileSystem = class {
     }
   }
   exists(filePath, callback) {
-    this.promises.exists(filePath).then(
-      (result) => setTimeout(() => callback(result), 0),
-      () => setTimeout(() => callback(false), 0)
-    );
+    const p = this.promises.exists(filePath);
+    if (typeof callback === "function") {
+      p.then(
+        (result) => setTimeout(() => callback(result), 0),
+        () => setTimeout(() => callback(false), 0)
+      );
+      return;
+    }
+    return p;
   }
   opendir(filePath, callback) {
-    this.promises.opendir(filePath).then(
-      (dir) => setTimeout(() => callback(null, dir), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cb(this.promises.opendir(filePath), callback);
   }
   glob(pattern, optionsOrCallback, callback) {
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    this._validateCb(cb);
     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)
-    );
+    return this._cb(this.promises.glob(pattern, opts), cb);
   }
   futimes(fd, atime, mtime, callback) {
-    setTimeout(() => callback(null), 0);
+    this._validateCb(callback);
+    if (callback) setTimeout(() => callback(null), 0);
   }
   fchmod(fd, mode, callback) {
-    setTimeout(() => callback(null), 0);
+    this._validateCb(callback);
+    if (callback) setTimeout(() => callback(null), 0);
   }
   fchown(fd, uid, gid, callback) {
-    setTimeout(() => callback(null), 0);
+    this._validateCb(callback);
+    if (callback) setTimeout(() => callback(null), 0);
   }
   lchmod(filePath, mode, callback) {
-    this.promises.lchmod(filePath, mode).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.lchmod(filePath, mode), callback);
   }
   lchown(filePath, uid, gid, callback) {
-    this.promises.lchown(filePath, uid, gid).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.lchown(filePath, uid, gid), callback);
   }
   lutimes(filePath, atime, mtime, callback) {
-    this.promises.lutimes(filePath, atime, mtime).then(
-      () => setTimeout(() => callback(null), 0),
-      (err) => setTimeout(() => callback(err), 0)
-    );
+    this._validateCb(callback);
+    return this._cbVoid(this.promises.lutimes(filePath, atime, mtime), callback);
   }
 };
 var VFSPromises = class {
@@ -3807,6 +3861,15 @@ var VFSPromises = class {
   async *watch(filePath, options) {
     yield* watchAsync(this._ns, this._async, filePath, options);
   }
+  async fstat(fd, options) {
+    const { status, data } = await this._async(OP.FSTAT, "", 0, null, void 0, { fd });
+    if (status !== 0) throw statusToError(status, "fstat", String(fd));
+    return options?.bigint ? decodeStatsBigInt(data) : decodeStats(data);
+  }
+  async ftruncate(fd, len = 0) {
+    const { status } = await this._async(OP.FTRUNCATE, "", 0, null, void 0, { fd, length: len });
+    if (status !== 0) throw statusToError(status, "ftruncate", String(fd));
+  }
   async fsync(_fd) {
     await this._async(OP.FSYNC, "");
   }