@zenfs/core 0.9.6 → 0.10.0

package/src/emulation/promises.ts

@@ -1,35 +1,39 @@
 import { Buffer } from 'buffer';
-import type * as Node from 'node:fs';
+import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
 import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo, FileReadResult, FlagAndOpenMode } from 'node:fs/promises';
+import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import type { ReadableStreamController } from 'stream/web';
+import { ErrnoError, Errno } from '../error.js';
 import { ActionType, File, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
-import { FileContents, FileSystem } from '../filesystem.js';
+import type { FileContents } from '../filesystem.js';
 import { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } 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 type { PathLike } from './shared.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 implements promises.FileHandle {
-	public constructor(
-		/**
-		 * Gets the file descriptor for this file handle.
-		 */
-		public readonly fd: number
-	) {}
+	/**
+	 * The file descriptor for this file handle.
+	 */
+	public readonly fd: number;
 
 	/**
 	 * @internal
+	 * The file for this file handle
 	 */
-	public get file(): File {
-		return fd2file(this.fd);
+	public readonly file: File;
+
+	public constructor(fdOrFile: number | File) {
+		const isFile = typeof fdOrFile != 'number';
+		this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
+		this.file = isFile ? fdOrFile : fd2file(fdOrFile);
 	}
 
 	/**
@@ -43,10 +47,10 @@ export class FileHandle implements promises.FileHandle {
 	 * Asynchronous fchmod(2) - Change permissions of a file.
 	 * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
 	 */
-	public chmod(mode: Node.Mode): Promise<void> {
+	public chmod(mode: fs.Mode): Promise<void> {
 		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);
 	}
@@ -69,9 +73,10 @@ export class FileHandle implements promises.FileHandle {
 	 * Asynchronous ftruncate(2) - Truncate a file to a specified length.
 	 * @param len If not specified, defaults to `0`.
 	 */
-	public truncate(len?: number): Promise<void> {
+	public truncate(len?: number | null): Promise<void> {
+		len ||= 0;
 		if (len < 0) {
-			throw new ApiError(ErrorCode.EINVAL);
+			throw new ErrnoError(Errno.EINVAL);
 		}
 		return this.file.truncate(len);
 	}
@@ -95,16 +100,16 @@ export class FileHandle implements promises.FileHandle {
 	 * If `mode` is a string, it is parsed as an octal integer.
 	 * If `flag` is not supplied, the default of `'a'` is used.
 	 */
-	public async appendFile(data: string | Uint8Array, _options?: (Node.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<void> {
+	public async appendFile(data: string | Uint8Array, _options: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding = {}): Promise<void> {
 		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;
+		const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : data;
 		await this.file.write(encodedData, 0, encodedData.length, null);
 	}
 
@@ -116,11 +121,11 @@ export class FileHandle implements promises.FileHandle {
 	 * @param length The number of bytes to read.
 	 * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
 	 */
-	public read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>> {
-		if (isNaN(+position)) {
-			position = this.file.position!;
+	public read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number | null): Promise<FileReadResult<TBuffer>> {
+		if (isNaN(+position!)) {
+			position = this.file.position;
 		}
-		return this.file.read(buffer, offset, length, position);
+		return this.file.read(buffer, offset, length, position!);
 	}
 
 	/**
@@ -129,13 +134,13 @@ export class FileHandle implements promises.FileHandle {
 	 * @param _options An object that may contain an optional flag.
 	 * If a flag is not provided, it defaults to `'r'`.
 	 */
-	public async readFile(_options?: { flag?: Node.OpenMode }): Promise<Buffer>;
-	public async readFile(_options: (Node.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string>;
-	public async readFile(_options?: (Node.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string | Buffer> {
+	public async readFile(_options?: { flag?: fs.OpenMode }): Promise<Buffer>;
+	public async readFile(_options: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string>;
+	public async readFile(_options?: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string | Buffer> {
 		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();
@@ -156,18 +161,18 @@ export class FileHandle implements promises.FileHandle {
 	 * @since v17.0.0
 	 * @experimental
 	 */
-	public readableWebStream(options?: promises.ReadableWebStreamOptions): TReadableStream<Uint8Array> {
+	public readableWebStream(options: promises.ReadableWebStreamOptions = {}): TReadableStream<Uint8Array> {
 		// Note: using an arrow function to preserve `this`
-		const start = async ({ close, enqueue, error }) => {
+		const start = async ({ close, enqueue, error }: ReadableStreamController<Uint8Array>) => {
 			try {
 				const chunkSize = 64 * 1024,
 					maxChunks = 1e7;
 				let i = 0,
 					position = 0,
-					result: FileReadResult<Uint8Array>;
+					bytesRead = NaN;
 
-				while (result.bytesRead > 0) {
-					result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
+				while (bytesRead > 0) {
+					const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
 					if (!result.bytesRead) {
 						close();
 						return;
@@ -175,19 +180,20 @@ export class FileHandle implements promises.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) {
 				error(e);
 			}
 		};
 
-		return new globalThis.ReadableStream({ start, type: options.type });
+		return new (globalThis as any).ReadableStream({ start, type: options.type });
 	}
 
 	public readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface {
-		throw ApiError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
+		throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
 	}
 
 	public [Symbol.asyncDispose](): Promise<void> {
@@ -197,40 +203,34 @@ export class FileHandle implements promises.FileHandle {
 	/**
 	 * Asynchronous fstat(2) - Get file status.
 	 */
-	public async stat(opts: Node.BigIntOptions): Promise<BigIntStats>;
-	public async stat(opts?: Node.StatOptions & { bigint?: false }): Promise<Stats>;
-	public async stat(opts?: Node.StatOptions): Promise<Stats | BigIntStats> {
+	public async stat(opts: fs.BigIntOptions): Promise<BigIntStats>;
+	public async stat(opts?: fs.StatOptions & { bigint?: false }): Promise<Stats>;
+	public async stat(opts?: fs.StatOptions): Promise<Stats | BigIntStats> {
 		const stats = await this.file.stat();
 		return opts?.bigint ? new BigIntStats(stats) : stats;
 	}
 
-	public async write(data: FileContents, posOrOff?: number, lenOrEnc?: BufferEncoding | number, position?: number): Promise<{ bytesWritten: number; buffer: FileContents }>;
-
-	/**
-	 * Asynchronously writes `buffer` to the file.
-	 * The `FileHandle` must have been opened for writing.
-	 * @param buffer The buffer that the data will be written to.
-	 * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
-	 * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
-	 * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
-	 */
-	public async write<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{ bytesWritten: number; buffer: TBuffer }>;
-
 	/**
 	 * Asynchronously writes `string` to the file.
 	 * The `FileHandle` must have been opened for writing.
 	 * It is unsafe to call `write()` multiple times on the same file without waiting for the `Promise`
 	 * to be resolved (or rejected). For this scenario, `fs.createWriteStream` is strongly recommended.
-	 * @param string A string to write.
-	 * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
-	 * @param encoding The expected string encoding.
 	 */
+	public async write(
+		data: FileContents,
+		posOrOff?: number | null,
+		lenOrEnc?: BufferEncoding | number,
+		position?: number | null
+	): Promise<{ bytesWritten: number; buffer: FileContents }>;
+	public async write<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{ bytesWritten: number; buffer: TBuffer }>;
 	public async write(data: string, position?: number, encoding?: BufferEncoding): Promise<{ bytesWritten: number; buffer: string }>;
-
-	public async write(data: FileContents, posOrOff?: number, lenOrEnc?: BufferEncoding | number, position?: number): Promise<{ bytesWritten: number; buffer: FileContents }> {
-		let buffer: Uint8Array,
-			offset: number = 0,
-			length: number;
+	public async write(
+		data: FileContents,
+		posOrOff?: number,
+		lenOrEnc?: BufferEncoding | number,
+		position?: number | null
+	): Promise<{ bytesWritten: number; buffer: FileContents }> {
+		let buffer: Uint8Array, offset: number | null | undefined, length: number;
 		if (typeof data === 'string') {
 			// Signature 1: (fd, string, [position?, [encoding?]])
 			position = typeof posOrOff === 'number' ? posOrOff : null;
@@ -240,13 +240,12 @@ export class FileHandle implements promises.FileHandle {
 			length = buffer.length;
 		} else {
 			// Signature 2: (fd, buffer, offset, length, position?)
-			buffer = data;
+			buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 			offset = posOrOff;
 			length = lenOrEnc as number;
 			position = typeof position === 'number' ? position : null;
 		}
-
-		position ??= this.file.position!;
+		position ??= this.file.position;
 		const bytesWritten = await this.file.write(buffer, offset, length, position);
 		return { buffer, bytesWritten };
 	}
@@ -262,16 +261,16 @@ export class FileHandle implements promises.FileHandle {
 	 * If `mode` is a string, it is parsed as an octal integer.
 	 * If `flag` is not supplied, the default of `'w'` is used.
 	 */
-	public async writeFile(data: string | Uint8Array, _options?: Node.WriteFileOptions): Promise<void> {
+	public async writeFile(data: string | Uint8Array, _options: fs.WriteFileOptions = {}): Promise<void> {
 		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;
+		const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : data;
 		await this.file.write(encodedData, 0, encodedData.length, 0);
 	}
 
@@ -289,11 +288,11 @@ export class FileHandle implements promises.FileHandle {
 	 * @param position The position in the file where to begin writing.
 	 * @returns The number of bytes written.
 	 */
-	public async writev(buffers: Uint8Array[], position?: number): Promise<Node.WriteVResult> {
+	public async writev(buffers: Uint8Array[], position?: number): Promise<fs.WriteVResult> {
 		let bytesWritten = 0;
 
 		for (const buffer of buffers) {
-			bytesWritten += (await this.write(buffer, 0, buffer.length, position + bytesWritten)).bytesWritten;
+			bytesWritten += (await this.write(buffer, 0, buffer.length, position! + bytesWritten)).bytesWritten;
 		}
 
 		return { bytesWritten, buffers };
@@ -305,11 +304,11 @@ export class FileHandle implements promises.FileHandle {
 	 * @param position The position in the file where to begin reading.
 	 * @returns The number of bytes read.
 	 */
-	public async readv(buffers: NodeJS.ArrayBufferView[], position?: number): Promise<Node.ReadVResult> {
+	public async readv(buffers: NodeJS.ArrayBufferView[], position?: number): Promise<fs.ReadVResult> {
 		let bytesRead = 0;
 
 		for (const buffer of buffers) {
-			bytesRead += (await this.read(buffer, 0, buffer.byteLength, position + bytesRead)).bytesRead;
+			bytesRead += (await this.read(buffer, 0, buffer.byteLength, position! + bytesRead)).bytesRead;
 		}
 
 		return { bytesRead, buffers };
@@ -322,9 +321,9 @@ export class FileHandle implements promises.FileHandle {
 	 * @returns A `ReadStream` object.
 	 */
 	public createReadStream(options?: CreateReadStreamOptions): ReadStream {
-		const streamOptions = {
+		const stream = new ReadStream({
 			highWaterMark: options?.highWaterMark || 64 * 1024,
-			encoding: options?.encoding,
+			encoding: options!.encoding!,
 
 			read: async (size: number) => {
 				try {
@@ -332,12 +331,11 @@ export class FileHandle implements promises.FileHandle {
 					stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead)); // Push data or null for EOF
 					this.file.position += result.bytesRead;
 				} catch (error) {
-					stream.destroy(error);
+					stream.destroy(error as Error);
 				}
 			},
-		};
+		});
 
-		const stream = new ReadStream(streamOptions);
 		stream.path = this.file.path;
 		return stream;
 	}
@@ -358,7 +356,7 @@ export class FileHandle implements promises.FileHandle {
 					const { bytesWritten } = await this.write(chunk, null, encoding);
 					callback(bytesWritten == chunk.length ? null : new Error('Failed to write full chunk'));
 				} catch (error) {
-					callback(error);
+					callback(error as Error);
 				}
 			},
 		};
@@ -369,44 +367,12 @@ export class FileHandle implements promises.FileHandle {
 	}
 }
 
-type FileSystemMethod = {
-	[K in keyof FileSystem]: FileSystem[K] extends (...args) => unknown
-		? (name: K, resolveSymlinks: boolean, ...args: Parameters<FileSystem[K]>) => ReturnType<FileSystem[K]>
-		: never;
-}[keyof FileSystem]; // https://stackoverflow.com/a/76335220/17637456
-
-/**
- * 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<M extends FileSystemMethod, RT extends ReturnType<M> = ReturnType<M>>(...[name, resolveSymlinks, rawPath, ...args]: Parameters<M>): Promise<RT> {
-	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) as Promise<RT>;
-	} catch (e) {
-		throw fixError(e, { [path]: rawPath });
-	}
-}
-
-// fs.promises
-
 /**
  * Renames a file
  * @param oldPath
  * @param newPath
  */
-export async function rename(oldPath: PathLike, newPath: PathLike): Promise<void> {
+export async function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promise<void> {
 	oldPath = normalizePath(oldPath);
 	newPath = normalizePath(newPath);
 	const src = resolveMount(oldPath);
@@ -419,21 +385,21 @@ export async function rename(oldPath: PathLike, newPath: PathLike): Promise<void
 		await writeFile(newPath, await readFile(oldPath));
 		await unlink(oldPath);
 	} catch (e) {
-		throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
+		throw fixError(e as Error, { [src.path]: oldPath, [dst.path]: newPath });
 	}
 }
 rename satisfies typeof promises.rename;
 
 /**
  * Test whether or not the given path exists by checking with the file system.
- * @param _path
+ * @param path
  */
-export async function exists(_path: PathLike): Promise<boolean> {
+export async function exists(path: fs.PathLike): Promise<boolean> {
 	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 as ApiError).errno == ErrorCode.ENOENT) {
+		if (e instanceof ErrnoError && e.code == 'ENOENT') {
 			return false;
 		}
 
@@ -446,12 +412,18 @@ export async function exists(_path: PathLike): Promise<boolean> {
  * @param path
  * @returns Stats
  */
-export async function stat(path: PathLike, options: Node.BigIntOptions): Promise<BigIntStats>;
-export async function stat(path: PathLike, options?: { bigint?: false }): Promise<Stats>;
-export async function stat(path: PathLike, options?: Node.StatOptions): Promise<Stats | BigIntStats>;
-export async function stat(path: PathLike, options?: Node.StatOptions): Promise<Stats | BigIntStats> {
-	const stats: Stats = await doOp('stat', true, path, cred);
-	return options?.bigint ? new BigIntStats(stats) : stats;
+export async function stat(path: fs.PathLike, options: fs.BigIntOptions): Promise<BigIntStats>;
+export async function stat(path: fs.PathLike, options?: { bigint?: false }): Promise<Stats>;
+export async function stat(path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats>;
+export async function stat(path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats> {
+	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 as Error, { [resolved]: path });
+	}
 }
 stat satisfies typeof promises.stat;
 
@@ -462,11 +434,17 @@ stat satisfies typeof promises.stat;
  * @param path
  * @return
  */
-export async function lstat(path: PathLike, options?: { bigint?: false }): Promise<Stats>;
-export async function lstat(path: PathLike, options: { bigint: true }): Promise<BigIntStats>;
-export async function lstat(path: PathLike, options?: Node.StatOptions): Promise<Stats | BigIntStats> {
-	const stats: Stats = await doOp('stat', false, path, cred);
-	return options?.bigint ? new BigIntStats(stats) : stats;
+export async function lstat(path: fs.PathLike, options?: { bigint?: boolean }): Promise<Stats>;
+export async function lstat(path: fs.PathLike, options: { bigint: true }): Promise<BigIntStats>;
+export async function lstat(path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats> {
+	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 as Error, { [resolved]: path });
+	}
 }
 lstat satisfies typeof promises.lstat;
 
@@ -477,7 +455,7 @@ lstat satisfies typeof promises.lstat;
  * @param path
  * @param len
  */
-export async function truncate(path: PathLike, len: number = 0): Promise<void> {
+export async function truncate(path: fs.PathLike, len: number = 0): Promise<void> {
 	const handle = await open(path, 'r+');
 	try {
 		await handle.truncate(len);
@@ -491,8 +469,14 @@ truncate satisfies typeof promises.truncate;
  * `unlink`.
  * @param path
  */
-export async function unlink(path: PathLike): Promise<void> {
-	return doOp('unlink', false, path, cred);
+export async function unlink(path: fs.PathLike): Promise<void> {
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(path);
+	try {
+		await fs.unlink(resolved, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 unlink satisfies typeof promises.unlink;
 
@@ -500,15 +484,18 @@ unlink satisfies typeof promises.unlink;
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(_path: PathLike, _flag: string, _mode: Node.Mode = 0o644, resolveSymlinks: boolean): Promise<File> {
-	const path = normalizePath(_path),
-		mode = normalizeMode(_mode, 0o644),
+async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o644, resolveSymlinks: boolean): Promise<FileHandle> {
+	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
@@ -516,32 +503,29 @@ async function _open(_path: PathLike, _flag: string, _mode: Node.Mode = 0o644, r
 					asynchronous request was trying to read the file, as the file
 					would not exist for a small period of time.
 				*/
-				const file: File = await doOp('openFile', resolveSymlinks, path, flag, cred);
-				if (!file) {
-					throw new ApiError(ErrorCode.EIO, 'Impossible code path reached');
-				}
+				const file: 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: Stats = await doOp('stat', resolveSymlinks, dirname(path), cred);
+				const parentStats: Stats = 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');
 		}
 	}
 }
@@ -552,39 +536,11 @@ async function _open(_path: PathLike, _flag: string, _mode: Node.Mode = 0o644, r
  * @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: PathLike, flag: string, mode: Node.Mode = 0o644): Promise<FileHandle> {
-	const file = await _open(path, flag, mode, true);
-	return new FileHandle(getFdForFile(file));
+export async function open(path: fs.PathLike, flag: fs.OpenMode = 'r', mode: fs.Mode = 0o644): Promise<FileHandle> {
+	return await _open(path, flag, mode, true);
 }
 open satisfies typeof promises.open;
 
-/**
- * Opens a file without resolving symlinks
- * @internal
- */
-export async function lopen(path: PathLike, flag: string, mode: Node.Mode = 0o644): Promise<FileHandle> {
-	const file: File = await _open(path, flag, mode, false);
-	return new FileHandle(getFdForFile(file));
-}
-
-/**
- * Asynchronously reads the entire contents of a file.
- */
-async function _readFile(fname: string, flag: string, resolveSymlinks: boolean): Promise<Uint8Array> {
-	const file = await _open(normalizePath(fname), flag, 0o644, resolveSymlinks);
-
-	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;
-	}
-}
-
 /**
  * Asynchronously reads the entire contents of a file.
  * @param filename
@@ -593,17 +549,24 @@ async function _readFile(fname: string, flag: string, resolveSymlinks: boolean):
  * options.flag Defaults to `'r'`.
  * @returns file data
  */
-export async function readFile(filename: PathLike, options?: { flag?: Node.OpenMode }): Promise<Buffer>;
-export async function readFile(filename: PathLike, options: (Node.EncodingOption & { flag?: Node.OpenMode }) | BufferEncoding): Promise<string>;
-export async function readFile(filename: PathLike, _options?: (Node.EncodingOption & { flag?: Node.OpenMode }) | BufferEncoding): Promise<Buffer | string> {
-	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.');
-	}
+export async function readFile(path: fs.PathLike | promises.FileHandle, options?: { encoding?: null; flag?: fs.OpenMode } | null): Promise<Buffer>;
+export async function readFile(path: fs.PathLike | promises.FileHandle, options: { encoding: BufferEncoding; flag?: fs.OpenMode } | BufferEncoding): Promise<string>;
+export async function readFile(
+	path: fs.PathLike | promises.FileHandle,
+	options?: (fs.ObjectEncodingOptions & { flag?: fs.OpenMode }) | BufferEncoding | null
+): Promise<string | Buffer>;
+export async function readFile(
+	path: fs.PathLike | promises.FileHandle,
+	_options?: (fs.ObjectEncodingOptions & { flag?: fs.OpenMode }) | BufferEncoding | null
+): Promise<Buffer | string> {
+	const options = normalizeOptions(_options, null, 'r', 0o644);
+	const handle: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, options.flag, options.mode);
 
-	const data: Buffer = Buffer.from(await _readFile(filename, options.flag, true));
-	return options.encoding ? data.toString(options.encoding) : data;
+	try {
+		return await handle.readFile(options);
+	} finally {
+		await handle.close();
+	}
 }
 readFile satisfies typeof promises.readFile;
 
@@ -611,41 +574,36 @@ readFile satisfies typeof promises.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: PathLike, data: FileContents, _options?: Node.WriteFileOptions): Promise<void> {
+export async function writeFile(
+	path: fs.PathLike | promises.FileHandle,
+	data: FileContents | Stream | Iterable<string | ArrayBufferView> | AsyncIterable<string | ArrayBufferView>,
+	_options?: (fs.ObjectEncodingOptions & { mode?: fs.Mode; flag?: fs.OpenMode; flush?: boolean }) | BufferEncoding | null
+): Promise<void> {
 	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 satisfies typeof promises.writeFile;
 
-/**
- * Asynchronously append data to a file, creating the file if
- * it not yet exists.
- */
-async function _appendFile(fname: string, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): Promise<void> {
-	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'`.
@@ -653,20 +611,26 @@ async function _appendFile(fname: string, data: Uint8Array, flag: string, mode:
  * @option options flag Defaults to `'a'`.
  */
 export async function appendFile(
-	filename: PathLike,
+	path: fs.PathLike | promises.FileHandle,
 	data: FileContents,
-	_options?: BufferEncoding | (Node.EncodingOption & { mode?: Node.Mode; flag?: Node.OpenMode })
+	_options?: BufferEncoding | (fs.EncodingOption & { mode?: fs.Mode; flag?: fs.OpenMode }) | null
 ): Promise<void> {
 	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: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, 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 satisfies typeof promises.appendFile;
 
@@ -676,38 +640,65 @@ appendFile satisfies typeof promises.appendFile;
  * `rmdir`.
  * @param path
  */
-export async function rmdir(path: PathLike): Promise<void> {
-	return doOp('rmdir', true, path, cred);
+export async function rmdir(path: fs.PathLike): Promise<void> {
+	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 as Error, { [resolved]: path });
+	}
 }
 rmdir satisfies typeof promises.rmdir;
 
 /**
- * `mkdir`.
- * @param path
- * @param mode defaults to `0777`
+ * Asynchronous mkdir(2) - create a directory.
+ * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+ * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
+ * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
  */
-export async function mkdir(path: PathLike, mode?: Node.Mode | (Node.MakeDirectoryOptions & { recursive?: false })): Promise<void>;
-export async function mkdir(path: PathLike, mode: Node.MakeDirectoryOptions & { recursive: true }): Promise<string>;
-export async function mkdir(path: PathLike, mode?: Node.Mode | Node.MakeDirectoryOptions): Promise<string | void> {
-	await doOp('mkdir', true, path, normalizeMode(typeof mode == 'object' ? mode?.mode : mode, 0o777), cred);
+export async function mkdir(path: fs.PathLike, options: fs.MakeDirectoryOptions & { recursive: true }): Promise<string | undefined>;
+export async function mkdir(path: fs.PathLike, options?: fs.Mode | (fs.MakeDirectoryOptions & { recursive?: false | undefined }) | null): Promise<void>;
+export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): Promise<string | undefined>;
+export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): Promise<string | undefined | void> {
+	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 as Error, { [resolved]: path });
+	}
 }
 mkdir satisfies typeof promises.mkdir;
 
 /**
- * `readdir`. Reads the contents of a directory.
- * @param path
+ * Asynchronous readdir(3) - read a directory.
+ * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+ * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
  */
-export async function readdir(path: PathLike, options?: (Node.EncodingOption & { withFileTypes?: false }) | BufferEncoding): Promise<string[]>;
-export async function readdir(path: PathLike, options: Node.BufferEncodingOption & { withFileTypes?: false }): Promise<Buffer[]>;
-export async function readdir(path: PathLike, options: Node.EncodingOption & { withFileTypes: true }): Promise<Dirent[]>;
+export async function readdir(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null): Promise<string[]>;
+export async function readdir(path: fs.PathLike, options: fs.BufferEncodingOption & { withFileTypes?: false; recursive?: boolean }): Promise<Buffer[]>;
+export async function readdir(
+	path: fs.PathLike,
+	options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null
+): Promise<string[] | Buffer[]>;
+export async function readdir(path: fs.PathLike, options: fs.ObjectEncodingOptions & { withFileTypes: true; recursive?: boolean }): Promise<Dirent[]>;
 export async function readdir(
-	path: PathLike,
-	options?: (Node.EncodingOption & { withFileTypes?: boolean }) | BufferEncoding | (Node.BufferEncodingOption & { withFileTypes?: boolean })
+	path: fs.PathLike,
+	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
 ): Promise<string[] | Dirent[] | Buffer[]> {
 	path = normalizePath(path);
-	const entries: string[] = 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: string[];
+	try {
+		entries = await fs.readdir(resolved, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
+	for (const point of mounts.keys()) {
 		if (point.startsWith(path)) {
 			const entry = point.slice(path.length);
 			if (entry.includes('/') || entry.length == 0) {
@@ -732,9 +723,15 @@ readdir satisfies typeof promises.readdir;
  * @param existing
  * @param newpath
  */
-export async function link(existing: PathLike, newpath: PathLike): Promise<void> {
+export async function link(existing: fs.PathLike, newpath: fs.PathLike): Promise<void> {
+	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 as Error, { [resolved]: newpath });
+	}
 }
 link satisfies typeof promises.link;
 
@@ -744,18 +741,18 @@ link satisfies typeof promises.link;
  * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export async function symlink(target: PathLike, path: PathLike, type: Node.symlink.Type = 'file'): Promise<void> {
-	if (!['file', 'dir', 'junction'].includes(type)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
+export async function symlink(target: fs.PathLike, path: fs.PathLike, type: fs.symlink.Type | string | null = 'file'): Promise<void> {
+	if (!['file', 'dir', 'junction'].includes(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 satisfies typeof promises.symlink;
 
@@ -763,15 +760,18 @@ symlink satisfies typeof promises.symlink;
  * readlink.
  * @param path
  */
-export async function readlink(path: PathLike, options: Node.BufferEncodingOption): Promise<Buffer>;
-export async function readlink(path: PathLike, options?: Node.EncodingOption | BufferEncoding): Promise<string>;
-export async function readlink(path: PathLike, options?: Node.BufferEncodingOption | Node.EncodingOption | BufferEncoding): Promise<string | Buffer> {
-	const value: Buffer = Buffer.from(await _readFile(path, 'r', false));
-	const encoding: BufferEncoding | 'buffer' = typeof options == 'object' ? options.encoding : options;
-	if (encoding == 'buffer') {
-		return value;
+export async function readlink(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
+export async function readlink(path: fs.PathLike, options?: fs.EncodingOption | null): Promise<string>;
+export async function readlink(path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | Buffer>;
+export async function readlink(path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | Buffer> {
+	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! as BufferEncoding);
+	} finally {
+		await handle.close();
 	}
-	return value.toString(encoding);
 }
 readlink satisfies typeof promises.readlink;
 
@@ -783,7 +783,7 @@ readlink satisfies typeof promises.readlink;
  * @param uid
  * @param gid
  */
-export async function chown(path: PathLike, uid: number, gid: number): Promise<void> {
+export async function chown(path: fs.PathLike, uid: number, gid: number): Promise<void> {
 	const handle = await open(path, 'r+');
 	try {
 		await handle.chown(uid, gid);
@@ -799,8 +799,8 @@ chown satisfies typeof promises.chown;
  * @param uid
  * @param gid
  */
-export async function lchown(path: PathLike, uid: number, gid: number): Promise<void> {
-	const handle = await lopen(path, 'r+');
+export async function lchown(path: fs.PathLike, uid: number, gid: number): Promise<void> {
+	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
 	try {
 		await handle.chown(uid, gid);
 	} finally {
@@ -814,7 +814,7 @@ lchown satisfies typeof promises.lchown;
  * @param path
  * @param mode
  */
-export async function chmod(path: PathLike, mode: Node.Mode): Promise<void> {
+export async function chmod(path: fs.PathLike, mode: fs.Mode): Promise<void> {
 	const handle = await open(path, 'r+');
 	try {
 		await handle.chmod(mode);
@@ -829,8 +829,8 @@ chmod satisfies typeof promises.chmod;
  * @param path
  * @param mode
  */
-export async function lchmod(path: PathLike, mode: Node.Mode): Promise<void> {
-	const handle = await lopen(path, 'r+');
+export async function lchmod(path: fs.PathLike, mode: fs.Mode): Promise<void> {
+	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
 	try {
 		await handle.chmod(mode);
 	} finally {
@@ -845,7 +845,7 @@ lchmod satisfies typeof promises.lchmod;
  * @param atime
  * @param mtime
  */
-export async function utimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void> {
+export async function utimes(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void> {
 	const handle = await open(path, 'r+');
 	try {
 		await handle.utimes(atime, mtime);
@@ -861,10 +861,10 @@ utimes satisfies typeof promises.utimes;
  * @param atime
  * @param mtime
  */
-export async function lutimes(path: PathLike, atime: number | Date, mtime: number | Date): Promise<void> {
-	const handle = await lopen(path, 'r+');
+export async function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs.TimeLike): Promise<void> {
+	const handle: FileHandle = 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();
 	}
@@ -875,12 +875,10 @@ lutimes satisfies typeof promises.lutimes;
  * Asynchronous realpath(3) - return the canonicalized absolute pathname.
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
- *
- * Note: This *Can not* use doOp since doOp depends on it
  */
-export async function realpath(path: PathLike, options: Node.BufferEncodingOption): Promise<Buffer>;
-export async function realpath(path: PathLike, options?: Node.EncodingOption | BufferEncoding): Promise<string>;
-export async function realpath(path: PathLike, options?: Node.EncodingOption | BufferEncoding | Node.BufferEncodingOption): Promise<string | Buffer> {
+export async function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
+export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
+export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Promise<string | Buffer> {
 	path = normalizePath(path);
 	const { base, dir } = parse(path);
 	const lpath = join(dir == '/' ? '/' : await realpath(dir), base);
@@ -894,7 +892,7 @@ export async function realpath(path: PathLike, options?: Node.EncodingOption | B
 
 		return realpath(mountPoint + (await readlink(lpath)));
 	} catch (e) {
-		throw fixError(e, { [resolvedPath]: lpath });
+		throw fixError(e as Error, { [resolvedPath]: lpath });
 	}
 }
 realpath satisfies typeof promises.realpath;
@@ -902,10 +900,11 @@ realpath satisfies typeof promises.realpath;
 /**
  * @todo Implement
  */
-export function watch(filename: PathLike, options: (Node.WatchOptions & { encoding: 'buffer' }) | 'buffer'): AsyncIterable<FileChangeInfo<Buffer>>;
-export function watch(filename: PathLike, options?: Node.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
-export function watch(filename: PathLike, options: Node.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>> {
-	throw ApiError.With('ENOSYS', filename, 'watch');
+export function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
+export function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<FileChangeInfo<Buffer>>;
+export function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
+export function watch(filename: fs.PathLike, options: fs.WatchOptions | string = {}): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>> {
+	throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
 }
 watch satisfies typeof promises.watch;
 
@@ -914,10 +913,10 @@ watch satisfies typeof promises.watch;
  * @param path
  * @param mode
  */
-export async function access(path: PathLike, mode: number = constants.F_OK): Promise<void> {
+export async function access(path: fs.PathLike, mode: number = constants.F_OK): Promise<void> {
 	const stats = await stat(path);
 	if (!stats.hasAccess(mode, cred)) {
-		throw new ApiError(ErrorCode.EACCES);
+		throw new ErrnoError(Errno.EACCES);
 	}
 }
 access satisfies typeof promises.access;
@@ -926,7 +925,7 @@ access satisfies typeof promises.access;
  * Asynchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export async function rm(path: PathLike, options?: Node.RmOptions) {
+export async function rm(path: fs.PathLike, options?: fs.RmOptions) {
 	path = normalizePath(path);
 
 	const stats = await stat(path);
@@ -950,7 +949,7 @@ export async function rm(path: PathLike, options?: Node.RmOptions) {
 		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 satisfies typeof promises.rm;
@@ -961,10 +960,10 @@ rm satisfies typeof promises.rm;
  * @param options The encoding (or an object including `encoding`).
  * @returns The path to the created temporary directory, encoded as a string or buffer.
  */
-export async function mkdtemp(prefix: string, options?: Node.EncodingOption): Promise<string>;
-export async function mkdtemp(prefix: string, options?: Node.BufferEncodingOption): Promise<Buffer>;
-export async function mkdtemp(prefix: string, options?: Node.EncodingOption | Node.BufferEncodingOption): Promise<string | Buffer> {
-	const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+export async function mkdtemp(prefix: string, options?: fs.EncodingOption): Promise<string>;
+export async function mkdtemp(prefix: string, options?: fs.BufferEncodingOption): Promise<Buffer>;
+export async function mkdtemp(prefix: string, options?: fs.EncodingOption | fs.BufferEncodingOption): Promise<string | Buffer> {
+	const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
 	const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
 	const resolvedPath = '/tmp/' + fsName;
 
@@ -981,12 +980,12 @@ mkdtemp satisfies typeof promises.mkdtemp;
  * @param mode Optional flags for the copy operation. Currently supports these flags:
  *    * `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
  */
-export async function copyFile(src: PathLike, dest: PathLike, mode?: number): Promise<void> {
+export async function copyFile(src: fs.PathLike, dest: fs.PathLike, mode?: number): Promise<void> {
 	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));
@@ -999,7 +998,7 @@ copyFile satisfies typeof promises.copyFile;
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
  */
-export async function opendir(path: PathLike, options?: Node.OpenDirOptions): Promise<Dir> {
+export async function opendir(path: fs.PathLike, options?: fs.OpenDirOptions): Promise<Dir> {
 	path = normalizePath(path);
 	return new Dir(path);
 }
@@ -1017,20 +1016,20 @@ opendir satisfies typeof promises.opendir;
  *   * `preserveTimestamps`: Preserve file timestamps.
  *   * `recursive`: If `true`, copies directories recursively.
  */
-export async function cp(source: PathLike, destination: PathLike, opts?: Node.CopyOptions): Promise<void> {
+export async function cp(source: fs.PathLike, destination: fs.PathLike, opts?: fs.CopyOptions): Promise<void> {
 	source = normalizePath(source);
 	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 })) {
@@ -1049,7 +1048,7 @@ export async function cp(source: PathLike, destination: PathLike, opts?: Node.Co
 		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
@@ -1063,9 +1062,9 @@ cp satisfies typeof promises.cp;
  * @since v18.15.0
  * @return Fulfills with an {fs.StatFs} for the file system.
  */
-export async function statfs(path: PathLike, opts?: Node.StatFsOptions & { bigint?: false }): Promise<StatsFs>;
-export async function statfs(path: PathLike, opts: Node.StatFsOptions & { bigint: true }): Promise<BigIntStatsFs>;
-export async function statfs(path: PathLike, opts?: Node.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
-export async function statfs(path: PathLike, opts?: Node.StatFsOptions): Promise<StatsFs | BigIntStatsFs> {
-	throw ApiError.With('ENOSYS', path, 'statfs');
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<StatsFs>;
+export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs> {
+	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }