@zenfs/core 0.9.6 → 0.10.0

package/dist/emulation/promises.js

@@ -1,27 +1,19 @@
 import { Buffer } from 'buffer';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
-    constructor(
-    /**
-     * Gets the file descriptor for this file handle.
-     */
-    fd) {
-        this.fd = fd;
-    }
-    /**
-     * @internal
-     */
-    get file() {
-        return fd2file(this.fd);
+    constructor(fdOrFile) {
+        const isFile = typeof fdOrFile != 'number';
+        this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
+        this.file = isFile ? fdOrFile : fd2file(fdOrFile);
     }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
@@ -36,7 +28,7 @@ export class FileHandle {
     chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid mode.');
+            throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
         }
         return this.file.chmod(numMode);
     }
@@ -57,8 +49,9 @@ export class FileHandle {
      * @param len If not specified, defaults to `0`.
      */
     truncate(len) {
+        len || (len = 0);
         if (len < 0) {
-            throw new ApiError(ErrorCode.EINVAL);
+            throw new ErrnoError(Errno.EINVAL);
         }
         return this.file.truncate(len);
     }
@@ -80,14 +73,14 @@ export class FileHandle {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'a'` is used.
      */
-    async appendFile(data, _options) {
+    async appendFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, null);
@@ -110,7 +103,7 @@ export class FileHandle {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading.');
         }
         const { size } = await this.stat();
         const data = new Uint8Array(size);
@@ -129,14 +122,14 @@ export class FileHandle {
      * @since v17.0.0
      * @experimental
      */
-    readableWebStream(options) {
+    readableWebStream(options = {}) {
         // Note: using an arrow function to preserve `this`
         const start = async ({ close, enqueue, error }) => {
             try {
                 const chunkSize = 64 * 1024, maxChunks = 1e7;
-                let i = 0, position = 0, result;
-                while (result.bytesRead > 0) {
-                    result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
+                let i = 0, position = 0, bytesRead = NaN;
+                while (bytesRead > 0) {
+                    const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
                     if (!result.bytesRead) {
                         close();
                         return;
@@ -144,8 +137,9 @@ export class FileHandle {
                     enqueue(result.buffer.slice(0, result.bytesRead));
                     position += result.bytesRead;
                     if (++i >= maxChunks) {
-                        throw new ApiError(ErrorCode.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
+                        throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
                     }
+                    bytesRead = result.bytesRead;
                 }
             }
             catch (e) {
@@ -155,7 +149,7 @@ export class FileHandle {
         return new globalThis.ReadableStream({ start, type: options.type });
     }
     readLines(options) {
-        throw ApiError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
+        throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
     }
     [Symbol.asyncDispose]() {
         return this.close();
@@ -165,7 +159,7 @@ export class FileHandle {
         return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
-        let buffer, offset = 0, length;
+        let buffer, offset, length;
         if (typeof data === 'string') {
             // Signature 1: (fd, string, [position?, [encoding?]])
             position = typeof posOrOff === 'number' ? posOrOff : null;
@@ -176,7 +170,7 @@ export class FileHandle {
         }
         else {
             // Signature 2: (fd, buffer, offset, length, position?)
-            buffer = data;
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
             offset = posOrOff;
             length = lenOrEnc;
             position = typeof position === 'number' ? position : null;
@@ -196,14 +190,14 @@ export class FileHandle {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    async writeFile(data, _options) {
+    async writeFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = parseFlag(options.flag);
         if (!isWriteable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for writing.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing.');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, 0);
@@ -248,9 +242,9 @@ export class FileHandle {
      * @returns A `ReadStream` object.
      */
     createReadStream(options) {
-        const streamOptions = {
+        const stream = new ReadStream({
             highWaterMark: options?.highWaterMark || 64 * 1024,
-            encoding: options?.encoding,
+            encoding: options.encoding,
             read: async (size) => {
                 try {
                     const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
@@ -261,8 +255,7 @@ export class FileHandle {
                     stream.destroy(error);
                 }
             },
-        };
-        const stream = new ReadStream(streamOptions);
+        });
         stream.path = this.file.path;
         return stream;
     }
@@ -291,31 +284,6 @@ export class FileHandle {
         return stream;
     }
 }
-/**
- * Utility for FS ops. It handles
- * - path normalization (for the first parameter to the FS op)
- * - path translation for errors
- * - FS/mount point resolution
- *
- * It can't be used for functions which may operate on multiple mounted FSs or paths (e.g. `rename`)
- * @param name the function name
- * @param resolveSymlinks whether to resolve symlinks
- * @param args the rest of the parameters are passed to the FS function. Note that the first parameter is required to be a path
- * @returns
- */
-async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
-    rawPath = normalizePath(rawPath);
-    const _path = resolveSymlinks && (await exists(rawPath)) ? await realpath(rawPath) : rawPath;
-    const { fs, path } = resolveMount(_path);
-    try {
-        // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-        return fs[name](path, ...args);
-    }
-    catch (e) {
-        throw fixError(e, { [path]: rawPath });
-    }
-}
-// fs.promises
 /**
  * Renames a file
  * @param oldPath
@@ -341,28 +309,42 @@ export async function rename(oldPath, newPath) {
 rename;
 /**
  * Test whether or not the given path exists by checking with the file system.
- * @param _path
+ * @param path
  */
-export async function exists(_path) {
+export async function exists(path) {
     try {
-        const { fs, path } = resolveMount(await realpath(_path));
-        return await fs.exists(path, cred);
+        const { fs, path: resolved } = resolveMount(await realpath(path));
+        return await fs.exists(resolved, cred);
     }
     catch (e) {
-        if (e.errno == ErrorCode.ENOENT) {
+        if (e instanceof ErrnoError && e.code == 'ENOENT') {
             return false;
         }
         throw e;
     }
 }
 export async function stat(path, options) {
-    const stats = await doOp('stat', true, path, cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
+    try {
+        const stats = await fs.stat(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 stat;
 export async function lstat(path, options) {
-    const stats = await doOp('stat', false, path, cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        const stats = await fs.stat(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 lstat;
 // FILE-ONLY METHODS
@@ -386,19 +368,29 @@ truncate;
  * @param path
  */
 export async function unlink(path) {
-    return doOp('unlink', false, path, cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.unlink(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 unlink;
 /**
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
-    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
+    path = normalizePath(path);
+    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+    path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
     try {
         switch (pathExistsAction(flag)) {
             case ActionType.THROW:
-                throw ApiError.With('EEXIST', path, '_open');
+                throw ErrnoError.With('EEXIST', path, '_open');
             case ActionType.TRUNCATE:
                 /*
                     In a previous implementation, we deleted the file and
@@ -406,33 +398,30 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
                     asynchronous request was trying to read the file, as the file
                     would not exist for a small period of time.
                 */
-                const file = await doOp('openFile', resolveSymlinks, path, flag, cred);
-                if (!file) {
-                    throw new ApiError(ErrorCode.EIO, 'Impossible code path reached');
-                }
+                const file = await fs.openFile(resolved, flag, cred);
                 await file.truncate(0);
                 await file.sync();
-                return file;
+                return new FileHandle(file);
             case ActionType.NOP:
                 // Must await so thrown errors are caught by the catch below
-                return await doOp('openFile', resolveSymlinks, path, flag, cred);
+                return new FileHandle(await fs.openFile(resolved, flag, cred));
             default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
+                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
         }
     }
     catch (e) {
         switch (pathNotExistsAction(flag)) {
             case ActionType.CREATE:
                 // Ensure parent exists.
-                const parentStats = await doOp('stat', resolveSymlinks, dirname(path), cred);
+                const parentStats = await fs.stat(dirname(resolved), cred);
                 if (parentStats && !parentStats.isDirectory()) {
-                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
+                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
                 }
-                return await doOp('createFile', resolveSymlinks, path, flag, mode, cred);
+                return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
             case ActionType.THROW:
-                throw ApiError.With('ENOENT', path, '_open');
+                throw ErrnoError.With('ENOENT', path, '_open');
             default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
+                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
         }
     }
 }
@@ -442,102 +431,74 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
  * @param flags Handles the complexity of the various file modes. See its API for more details.
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
-export async function open(path, flag, mode = 0o644) {
-    const file = await _open(path, flag, mode, true);
-    return new FileHandle(getFdForFile(file));
+export async function open(path, flag = 'r', mode = 0o644) {
+    return await _open(path, flag, mode, true);
 }
 open;
-/**
- * Opens a file without resolving symlinks
- * @internal
- */
-export async function lopen(path, flag, mode = 0o644) {
-    const file = await _open(path, flag, mode, false);
-    return new FileHandle(getFdForFile(file));
-}
-/**
- * Asynchronously reads the entire contents of a file.
- */
-async function _readFile(fname, flag, resolveSymlinks) {
-    const file = await _open(normalizePath(fname), flag, 0o644, resolveSymlinks);
+export async function readFile(path, _options) {
+    const options = normalizeOptions(_options, null, 'r', 0o644);
+    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
     try {
-        const stat = await file.stat();
-        const data = new Uint8Array(stat.size);
-        await file.read(data, 0, stat.size, 0);
-        await file.close();
-        return data;
-    }
-    catch (e) {
-        await file.close();
-        throw e;
+        return await handle.readFile(options);
     }
-}
-export async function readFile(filename, _options) {
-    const options = normalizeOptions(_options, null, 'r', 0);
-    const flag = parseFlag(options.flag);
-    if (!isReadable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+    finally {
+        await handle.close();
     }
-    const data = Buffer.from(await _readFile(filename, options.flag, true));
-    return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile;
 /**
  * Asynchronously writes data to a file, replacing the file if it already exists.
  *
  * The encoding option is ignored if data is a buffer.
- * @param filename
- * @param data
+ * @param path
+ * @param data Note:
  * @param _options
  * @option options encoding Defaults to `'utf8'`.
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'w'`.
  */
-export async function writeFile(filename, data, _options) {
+export async function writeFile(path, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-    const handle = await open(filename, options.flag, options.mode);
+    const handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
     try {
-        await handle.writeFile(data, options);
+        const _data = typeof data == 'string' ? data : data;
+        if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
+            throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
+        }
+        await handle.writeFile(_data, options);
     }
     finally {
         await handle.close();
     }
 }
 writeFile;
-/**
- * Asynchronously append data to a file, creating the file if
- * it not yet exists.
- */
-async function _appendFile(fname, data, flag, mode, resolveSymlinks) {
-    const file = await _open(fname, flag, mode, resolveSymlinks);
-    try {
-        await file.write(data, 0, data.length, null);
-    }
-    finally {
-        await file.close();
-    }
-}
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
- * @param filename
+ * @param path
  * @param data
  * @param options
  * @option options encoding Defaults to `'utf8'`.
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export async function appendFile(filename, data, _options) {
+export async function appendFile(path, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
     if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+    }
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
+    try {
+        await handle.appendFile(encodedData, options);
+    }
+    finally {
+        await handle.close();
     }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-    await _appendFile(filename, encodedData, options.flag, options.mode, true);
 }
 appendFile;
 // DIRECTORY-ONLY METHODS
@@ -546,18 +507,41 @@ appendFile;
  * @param path
  */
 export async function rmdir(path) {
-    return doOp('rmdir', true, path, cred);
+    path = normalizePath(path);
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.rmdir(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 rmdir;
-export async function mkdir(path, mode) {
-    await doOp('mkdir', true, path, normalizeMode(typeof mode == 'object' ? mode?.mode : mode, 0o777), cred);
+export async function mkdir(path, options) {
+    path = normalizePath(path);
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.mkdir(resolved, normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 mkdir;
 export async function readdir(path, options) {
     path = normalizePath(path);
-    const entries = await doOp('readdir', true, path, cred);
-    const points = [...mounts.keys()];
-    for (const point of points) {
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    let entries;
+    try {
+        entries = await fs.readdir(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
+    for (const point of mounts.keys()) {
         if (point.startsWith(path)) {
             const entry = point.slice(path.length);
             if (entry.includes('/') || entry.length == 0) {
@@ -581,8 +565,15 @@ readdir;
  * @param newpath
  */
 export async function link(existing, newpath) {
+    existing = normalizePath(existing);
     newpath = normalizePath(newpath);
-    return doOp('link', false, existing, newpath, cred);
+    const { fs, path: resolved } = resolveMount(newpath);
+    try {
+        return await fs.link(existing, newpath, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: newpath });
+    }
 }
 link;
 /**
@@ -593,23 +584,26 @@ link;
  */
 export async function symlink(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
+        throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
     }
     if (await exists(path)) {
-        throw ApiError.With('EEXIST', path, 'symlink');
+        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
-    await writeFile(path, target);
-    const file = await _open(path, 'r+', 0o644, false);
-    await file._setType(FileType.SYMLINK);
+    await writeFile(path, target.toString());
+    const handle = await _open(path, 'r+', 0o644, false);
+    await handle.file._setType(FileType.SYMLINK);
 }
 symlink;
 export async function readlink(path, options) {
-    const value = Buffer.from(await _readFile(path, 'r', false));
-    const encoding = typeof options == 'object' ? options.encoding : options;
-    if (encoding == 'buffer') {
-        return value;
+    const handle = await _open(normalizePath(path), 'r', 0o644, false);
+    try {
+        const value = await handle.readFile();
+        const encoding = typeof options == 'object' ? options?.encoding : options;
+        return encoding == 'buffer' ? value : value.toString(encoding);
+    }
+    finally {
+        await handle.close();
     }
-    return value.toString(encoding);
 }
 readlink;
 // PROPERTY OPERATIONS
@@ -636,7 +630,7 @@ chown;
  * @param gid
  */
 export async function lchown(path, uid, gid) {
-    const handle = await lopen(path, 'r+');
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
         await handle.chown(uid, gid);
     }
@@ -666,7 +660,7 @@ chmod;
  * @param mode
  */
 export async function lchmod(path, mode) {
-    const handle = await lopen(path, 'r+');
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
         await handle.chmod(mode);
     }
@@ -698,9 +692,9 @@ utimes;
  * @param mtime
  */
 export async function lutimes(path, atime, mtime) {
-    const handle = await lopen(path, 'r+');
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
-        await handle.utimes(atime, mtime);
+        await handle.utimes(new Date(atime), new Date(mtime));
     }
     finally {
         await handle.close();
@@ -724,8 +718,8 @@ export async function realpath(path, options) {
     }
 }
 realpath;
-export function watch(filename, options) {
-    throw ApiError.With('ENOSYS', filename, 'watch');
+export function watch(filename, options = {}) {
+    throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
 }
 watch;
 /**
@@ -736,7 +730,7 @@ watch;
 export async function access(path, mode = constants.F_OK) {
     const stats = await stat(path);
     if (!stats.hasAccess(mode, cred)) {
-        throw new ApiError(ErrorCode.EACCES);
+        throw new ErrnoError(Errno.EACCES);
     }
 }
 access;
@@ -765,12 +759,12 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
 }
 rm;
 export async function mkdtemp(prefix, options) {
-    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
     await mkdir(resolvedPath);
@@ -788,7 +782,7 @@ export async function copyFile(src, dest, mode) {
     src = normalizePath(src);
     dest = normalizePath(dest);
     if (mode && mode & constants.COPYFILE_EXCL && (await exists(dest))) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
     await writeFile(dest, await readFile(src));
 }
@@ -821,12 +815,12 @@ export async function cp(source, destination, opts) {
     destination = normalizePath(destination);
     const srcStats = await lstat(source); // Use lstat to follow symlinks if not dereferencing
     if (opts?.errorOnExist && (await exists(destination))) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (!opts?.recursive) {
-                throw new ApiError(ErrorCode.EISDIR, source + ' is a directory (not copied)', source, 'cp');
+                throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
             await mkdir(destination, { recursive: true }); // Ensure the destination directory exists
             for (const dirent of await readdir(source, { withFileTypes: true })) {
@@ -845,7 +839,7 @@ export async function cp(source, destination, opts) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', source, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', source, 'rm');
     }
     // Optionally preserve timestamps
     if (opts?.preserveTimestamps) {
@@ -854,5 +848,5 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ApiError.With('ENOSYS', path, 'statfs');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }