@zenfs/core 0.9.7 → 0.11.0

package/src/emulation/promises.ts

@@ -6,9 +6,9 @@ import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import type { ReadableStreamController } from 'stream/web';
-import { ApiError, ErrorCode } from '../ApiError.js';
+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';
@@ -19,18 +19,21 @@ 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);
 	}
 
 	/**
@@ -47,7 +50,7 @@ export class FileHandle implements promises.FileHandle {
 	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);
 	}
@@ -73,7 +76,7 @@ export class FileHandle implements promises.FileHandle {
 	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);
 	}
@@ -101,10 +104,10 @@ export class FileHandle implements promises.FileHandle {
 		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);
@@ -133,11 +136,11 @@ export class FileHandle implements promises.FileHandle {
 	 */
 	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> {
+	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();
@@ -177,7 +180,7 @@ 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;
 				}
@@ -190,7 +193,7 @@ export class FileHandle implements promises.FileHandle {
 	}
 
 	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> {
@@ -262,10 +265,10 @@ export class FileHandle implements promises.FileHandle {
 		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);
@@ -328,7 +331,7 @@ 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>error);
+					stream.destroy(error as Error);
 				}
 			},
 		});
@@ -353,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>error);
+					callback(error as Error);
 				}
 			},
 		};
@@ -364,38 +367,6 @@ export class FileHandle implements promises.FileHandle {
 	}
 }
 
-type FileSystemMethod = {
-	[K in keyof FileSystem]: FileSystem[K] extends (...args: any[]) => 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(<Error>e, { [path]: rawPath });
-	}
-}
-
-// fs.promises
-
 /**
  * Renames a file
  * @param oldPath
@@ -414,21 +385,21 @@ export async function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promis
 		await writeFile(newPath, await readFile(oldPath));
 		await unlink(oldPath);
 	} catch (e) {
-		throw fixError(<Error>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: fs.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;
 		}
 
@@ -445,8 +416,14 @@ export async function stat(path: fs.PathLike, options: fs.BigIntOptions): Promis
 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> {
-	const stats: Stats = await doOp('stat', true, path.toString(), 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 as Error, { [resolved]: path });
+	}
 }
 stat satisfies typeof promises.stat;
 
@@ -460,8 +437,14 @@ stat satisfies typeof promises.stat;
 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> {
-	const stats: Stats = await doOp('stat', false, path.toString(), 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 as Error, { [resolved]: path });
+	}
 }
 lstat satisfies typeof promises.lstat;
 
@@ -487,7 +470,13 @@ truncate satisfies typeof promises.truncate;
  * @param path
  */
 export async function unlink(path: fs.PathLike): Promise<void> {
-	return doOp('unlink', false, path.toString(), cred);
+	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;
 
@@ -495,15 +484,18 @@ unlink satisfies typeof promises.unlink;
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(_path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.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
@@ -511,32 +503,29 @@ async function _open(_path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o
 					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');
 		}
 	}
 }
@@ -548,29 +537,10 @@ async function _open(_path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path: fs.PathLike, flag: fs.OpenMode = 'r', mode: fs.Mode = 0o644): Promise<FileHandle> {
-	const file = await _open(path, flag, mode, true);
-	return new FileHandle(file2fd(file));
+	return await _open(path, flag, mode, true);
 }
 open satisfies typeof promises.open;
 
-/**
- * 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
@@ -589,14 +559,14 @@ 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', 0);
-	const flag = parseFlag(options.flag);
-	if (!isReadable(flag)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+	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);
+
+	try {
+		return await handle.readFile(options);
+	} finally {
+		await handle.close();
 	}
-	path = path instanceof FileHandle ? path.file.path : path.toString();
-	const data: Buffer = Buffer.from(await _readFile(path, options.flag, true));
-	return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile satisfies typeof promises.readFile;
 
@@ -621,7 +591,7 @@ export async function writeFile(
 	try {
 		const _data = typeof data == 'string' ? data : data;
 		if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
-			throw new ApiError(ErrorCode.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
+			throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
 		}
 		await handle.writeFile(_data, options);
 	} finally {
@@ -630,19 +600,6 @@ export async function writeFile(
 }
 writeFile satisfies typeof promises.writeFile;
 
-/**
- * Asynchronously append data to a file, creating the file if
- * it not yet exists.
- */
-async function _appendFile(path: fs.PathLike, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): Promise<void> {
-	const file = await _open(path, 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.
@@ -661,13 +618,19 @@ export async function appendFile(
 	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);
-	await _appendFile(path instanceof FileHandle ? path.file.path : path.toString(), encodedData, options.flag, options.mode, true);
+	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();
+	}
 }
 appendFile satisfies typeof promises.appendFile;
 
@@ -678,7 +641,14 @@ appendFile satisfies typeof promises.appendFile;
  * @param path
  */
 export async function rmdir(path: fs.PathLike): Promise<void> {
-	return doOp('rmdir', true, path.toString(), 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 as Error, { [resolved]: path });
+	}
 }
 rmdir satisfies typeof promises.rmdir;
 
@@ -692,8 +662,14 @@ export async function mkdir(path: fs.PathLike, options: fs.MakeDirectoryOptions
 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> {
-	await doOp('mkdir', true, path.toString(), normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
-	return;
+	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;
 
@@ -714,9 +690,15 @@ export async function readdir(
 	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) {
@@ -742,8 +724,14 @@ readdir satisfies typeof promises.readdir;
  * @param newpath
  */
 export async function link(existing: fs.PathLike, newpath: fs.PathLike): Promise<void> {
+	existing = normalizePath(existing);
 	newpath = normalizePath(newpath);
-	return doOp('link', false, existing.toString(), 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;
 
@@ -755,16 +743,16 @@ link satisfies typeof promises.link;
  */
 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 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.toString(), 'symlink');
+		throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
 	}
 
 	await writeFile(path, target.toString());
-	const file = await _open(path, 'r+', 0o644, false);
-	await file._setType(FileType.SYMLINK);
+	const handle = await _open(path, 'r+', 0o644, false);
+	await handle.file._setType(FileType.SYMLINK);
 }
 symlink satisfies typeof promises.symlink;
 
@@ -776,9 +764,14 @@ export async function readlink(path: fs.PathLike, options: fs.BufferEncodingOpti
 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 value: Buffer = Buffer.from(await _readFile(path.toString(), 'r', false));
-	const encoding = typeof options == 'object' ? options?.encoding : options;
-	return encoding == 'buffer' ? value : value.toString(encoding! as BufferEncoding);
+	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();
+	}
 }
 readlink satisfies typeof promises.readlink;
 
@@ -807,11 +800,11 @@ chown satisfies typeof promises.chown;
  * @param gid
  */
 export async function lchown(path: fs.PathLike, uid: number, gid: number): Promise<void> {
-	const file: File = await _open(path, 'r+', 0o644, false);
+	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
 	try {
-		await file.chown(uid, gid);
+		await handle.chown(uid, gid);
 	} finally {
-		await file.close();
+		await handle.close();
 	}
 }
 lchown satisfies typeof promises.lchown;
@@ -837,11 +830,11 @@ chmod satisfies typeof promises.chmod;
  * @param mode
  */
 export async function lchmod(path: fs.PathLike, mode: fs.Mode): Promise<void> {
-	const file: File = await _open(path, 'r+', 0o644, false);
+	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
 	try {
-		await new FileHandle(file2fd(file)).chmod(mode);
+		await handle.chmod(mode);
 	} finally {
-		await file.close();
+		await handle.close();
 	}
 }
 lchmod satisfies typeof promises.lchmod;
@@ -869,11 +862,11 @@ utimes satisfies typeof promises.utimes;
  * @param mtime
  */
 export async function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs.TimeLike): Promise<void> {
-	const file: File = await _open(path, 'r+', 0o644, false);
+	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
 	try {
-		await file.utimes(new Date(atime), new Date(mtime));
+		await handle.utimes(new Date(atime), new Date(mtime));
 	} finally {
-		await file.close();
+		await handle.close();
 	}
 }
 lutimes satisfies typeof promises.lutimes;
@@ -882,8 +875,6 @@ 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: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
@@ -901,7 +892,7 @@ export async function realpath(path: fs.PathLike, options?: fs.EncodingOption |
 
 		return realpath(mountPoint + (await readlink(lpath)));
 	} catch (e) {
-		throw fixError(<Error>e, { [resolvedPath]: lpath });
+		throw fixError(e as Error, { [resolvedPath]: lpath });
 	}
 }
 realpath satisfies typeof promises.realpath;
@@ -913,7 +904,7 @@ export function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferE
 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 ApiError.With('ENOSYS', filename.toString(), 'watch');
+	throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
 }
 watch satisfies typeof promises.watch;
 
@@ -925,7 +916,7 @@ watch satisfies typeof promises.watch;
 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;
@@ -958,7 +949,7 @@ export async function rm(path: fs.PathLike, options?: fs.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;
@@ -994,7 +985,7 @@ export async function copyFile(src: fs.PathLike, dest: fs.PathLike, mode?: numbe
 	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));
@@ -1032,13 +1023,13 @@ export async function cp(source: fs.PathLike, destination: fs.PathLike, opts?: f
 	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 })) {
@@ -1057,7 +1048,7 @@ export async function cp(source: fs.PathLike, destination: fs.PathLike, opts?: f
 		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
@@ -1075,5 +1066,5 @@ export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigi
 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 ApiError.With('ENOSYS', path.toString(), 'statfs');
+	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }