@zenfs/core 0.9.7 → 0.10.0

package/src/emulation/shared.ts

@@ -1,12 +1,12 @@
 // Utilities and shared data
 
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { InMemory } from '../backends/InMemory.js';
 import { Cred, rootCred } from '../cred.js';
 import type { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { normalizePath } from '../utils.js';
-import { resolve } from './path.js';
+import { resolve, type AbsolutePath } from './path.js';
 
 // credentials
 export let cred: Cred = rootCred;
@@ -24,15 +24,13 @@ export function file2fd(file: File): number {
 }
 export function fd2file(fd: number): File {
 	if (!fdMap.has(fd)) {
-		throw new ApiError(ErrorCode.EBADF);
+		throw new ErrnoError(Errno.EBADF);
 	}
 	return fdMap.get(fd)!;
 }
 
 // mounting
-export interface MountMapping {
-	[point: string]: FileSystem;
-}
+export type MountObject = Record<AbsolutePath, FileSystem>;
 
 /**
  * The map of mount points
@@ -54,7 +52,7 @@ export function mount(mountPoint: string, fs: FileSystem): void {
 	}
 	mountPoint = resolve(mountPoint);
 	if (mounts.has(mountPoint)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
+		throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
 	}
 	mounts.set(mountPoint, fs);
 }
@@ -68,7 +66,7 @@ export function umount(mountPoint: string): void {
 	}
 	mountPoint = resolve(mountPoint);
 	if (!mounts.has(mountPoint)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
+		throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
 	}
 	mounts.delete(mountPoint);
 }
@@ -90,20 +88,20 @@ export function resolveMount(path: string): { fs: FileSystem; path: string; moun
 		}
 	}
 
-	throw new ApiError(ErrorCode.EIO, 'ZenFS not initialized with a file system');
+	throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
 }
 
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  */
-export function fixPaths(text: string, paths: { [from: string]: string }): string {
+export function fixPaths(text: string, paths: Record<string, string>): string {
 	for (const [from, to] of Object.entries(paths)) {
 		text = text?.replaceAll(from, to);
 	}
 	return text;
 }
 
-export function fixError<E extends Error>(e: E, paths: { [from: string]: string }): E {
+export function fixError<E extends Error>(e: E, paths: Record<string, string>): E {
 	if (typeof e.stack == 'string') {
 		e.stack = fixPaths(e.stack, paths);
 	}
@@ -111,11 +109,11 @@ export function fixError<E extends Error>(e: E, paths: { [from: string]: string
 	return e;
 }
 
-export function mountMapping(mountMapping: MountMapping): void {
-	if ('/' in mountMapping) {
+export function mountObject(mounts: MountObject): void {
+	if ('/' in mounts) {
 		umount('/');
 	}
-	for (const [point, fs] of Object.entries(mountMapping)) {
+	for (const [point, fs] of Object.entries(mounts)) {
 		mount(point, fs);
 	}
 }

package/src/emulation/streams.ts

@@ -1,7 +1,7 @@
 import type * as Node from 'fs';
 import { Readable, Writable } from 'readable-stream';
 import { Callback } from '../utils.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 
 export class ReadStream extends Readable implements Node.ReadStream {
 	close(callback: Callback = () => null): void {
@@ -10,7 +10,7 @@ export class ReadStream extends Readable implements Node.ReadStream {
 			super.emit('close');
 			callback();
 		} catch (err) {
-			callback(new ApiError(ErrorCode.EIO, (err as Error).toString()));
+			callback(new ErrnoError(Errno.EIO, (err as Error).toString()));
 		}
 	}
 	declare bytesRead: number;
@@ -25,7 +25,7 @@ export class WriteStream extends Writable implements Node.WriteStream {
 			super.emit('close');
 			callback();
 		} catch (err) {
-			callback(new ApiError(ErrorCode.EIO, (err as Error).toString()));
+			callback(new ErrnoError(Errno.EIO, (err as Error).toString()));
 		}
 	}
 	declare bytesWritten: number;

package/src/emulation/sync.ts

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
-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 { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
@@ -23,7 +23,7 @@ function doOp<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, re
 		// @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
 		return fs[name](resolvedPath, ...args) as RT;
 	} catch (e) {
-		throw fixError(<Error>e, { [resolvedPath]: path });
+		throw fixError(e as Error, { [resolvedPath]: path });
 	}
 }
 
@@ -46,7 +46,7 @@ export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 		writeFileSync(newPath, readFileSync(oldPath));
 		unlinkSync(oldPath);
 	} catch (e) {
-		throw fixError(<Error>e, paths);
+		throw fixError(e as Error, paths);
 	}
 }
 renameSync satisfies typeof fs.renameSync;
@@ -61,7 +61,7 @@ export function existsSync(path: fs.PathLike): boolean {
 		const { fs, path: resolvedPath } = resolveMount(realpathSync(path));
 		return fs.existsSync(resolvedPath, cred);
 	} catch (e) {
-		if ((e as ApiError).errno == ErrorCode.ENOENT) {
+		if ((e as ErrnoError).errno == Errno.ENOENT) {
 			return false;
 		}
 
@@ -136,23 +136,23 @@ function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | nul
 				// Ensure parent exists.
 				const parentStats: Stats = doOp('statSync', resolveSymlinks, dirname(path), cred);
 				if (!parentStats.isDirectory()) {
-					throw ApiError.With('ENOTDIR', dirname(path), '_open');
+					throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
 				}
 				return doOp('createFileSync', resolveSymlinks, path, 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 FileFlag object.');
+				throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
 		}
 	}
 	if (!stats.hasAccess(mode, cred)) {
-		throw ApiError.With('EACCES', path, '_open');
+		throw ErrnoError.With('EACCES', path, '_open');
 	}
 
 	// File exists.
 	switch (pathExistsAction(flag)) {
 		case ActionType.THROW:
-			throw ApiError.With('EEXIST', path, '_open');
+			throw ErrnoError.With('EEXIST', path, '_open');
 		case ActionType.TRUNCATE:
 			// Delete file.
 			doOp('unlinkSync', resolveSymlinks, path, cred);
@@ -166,7 +166,7 @@ function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | nul
 		case ActionType.NOP:
 			return doOp('openFileSync', resolveSymlinks, path, flag, cred);
 		default:
-			throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+			throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
 	}
 }
 
@@ -223,7 +223,7 @@ export function readFileSync(path: fs.PathOrFileDescriptor, _options: fs.WriteFi
 	const options = normalizeOptions(_options, null, 'r', 0o644);
 	const flag = parseFlag(options.flag);
 	if (!isReadable(flag)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
+		throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
 	}
 	const data: Buffer = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), options.flag, true));
 	return options.encoding ? data.toString(options.encoding) : data;
@@ -263,14 +263,14 @@ export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents,
 	const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
 	const flag = parseFlag(options.flag);
 	if (!isWriteable(flag)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
+		throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile 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!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 	if (!encodedData) {
-		throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
+		throw new ErrnoError(Errno.EINVAL, 'Data not specified');
 	}
 	_writeFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), encodedData, options.flag, options.mode, true);
 }
@@ -304,10 +304,10 @@ export function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileCont
 	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);
 	_appendFileSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), encodedData, options.flag, options.mode, true);
@@ -346,7 +346,7 @@ closeSync satisfies typeof fs.closeSync;
 export function ftruncateSync(fd: number, len: number | null = 0): void {
 	len ||= 0;
 	if (len < 0) {
-		throw new ApiError(ErrorCode.EINVAL);
+		throw new ErrnoError(Errno.EINVAL);
 	}
 	fd2file(fd).truncateSync(len);
 }
@@ -458,7 +458,7 @@ fchownSync satisfies typeof fs.fchownSync;
 export function fchmodSync(fd: number, mode: number | string): void {
 	const numMode = normalizeMode(mode, -1);
 	if (numMode < 0) {
-		throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+		throw new ErrnoError(Errno.EINVAL, `Invalid mode.`);
 	}
 	fd2file(fd).chmodSync(numMode);
 }
@@ -561,10 +561,10 @@ linkSync satisfies typeof fs.linkSync;
  */
 export function symlinkSync(target: fs.PathLike, path: fs.PathLike, type: fs.symlink.Type | null = 'file'): void {
 	if (!['file', 'dir', 'junction'].includes(type!)) {
-		throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
+		throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
 	}
 	if (existsSync(path)) {
-		throw ApiError.With('EEXIST', path.toString(), 'symlink');
+		throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
 	}
 
 	writeFileSync(path, target.toString());
@@ -691,7 +691,7 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 
 		return realpathSync(mountPoint + readlinkSync(lpath));
 	} catch (e) {
-		throw fixError(<Error>e, { [resolvedPath]: lpath });
+		throw fixError(e as Error, { [resolvedPath]: lpath });
 	}
 }
 realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
@@ -704,7 +704,7 @@ realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
 export function accessSync(path: fs.PathLike, mode: number = 0o600): void {
 	const stats = statSync(path);
 	if (!stats.hasAccess(mode, cred)) {
-		throw new ApiError(ErrorCode.EACCES);
+		throw new ErrnoError(Errno.EACCES);
 	}
 }
 accessSync satisfies typeof fs.accessSync;
@@ -737,7 +737,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 		case S_IFIFO:
 		case 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');
 	}
 }
 rmSync satisfies typeof fs.rmSync;
@@ -773,7 +773,7 @@ export function copyFileSync(src: fs.PathLike, dest: fs.PathLike, flags?: number
 	dest = normalizePath(dest);
 
 	if (flags && flags & COPYFILE_EXCL && existsSync(dest)) {
-		throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+		throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
 	}
 
 	writeFileSync(dest, readFileSync(src));
@@ -849,13 +849,13 @@ export function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.
 	const srcStats = lstatSync(source); // Use lstat to follow symlinks if not dereferencing
 
 	if (opts?.errorOnExist && existsSync(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 & S_IFMT) {
 		case 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');
 			}
 			mkdirSync(destination, { recursive: true }); // Ensure the destination directory exists
 			for (const dirent of readdirSync(source, { withFileTypes: true })) {
@@ -874,7 +874,7 @@ export function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.
 		case S_IFIFO:
 		case 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
@@ -894,5 +894,5 @@ export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & { big
 export function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }): BigIntStatsFs;
 export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
 export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs {
-	throw ApiError.With('ENOSYS', path.toString(), 'statfs');
+	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }

package/src/{ApiError.ts → error.ts}

@@ -1,9 +1,9 @@
 /**
- * Standard libc error codes. More will be added to this enum and ErrorStrings as they are
+ * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
  * @url https://en.wikipedia.org/wiki/Errno.h
  */
-export enum ErrorCode {
+export enum Errno {
 	/** Operation not permitted */
 	EPERM = 1,
 	/** No such file or directory */
@@ -157,88 +157,88 @@ export enum ErrorCode {
  * Strings associated with each error code.
  * @internal
  */
-export const errorMessages: { [K in ErrorCode]: string } = {
-	[ErrorCode.EPERM]: 'Operation not permitted',
-	[ErrorCode.ENOENT]: 'No such file or directory',
-	[ErrorCode.EINTR]: 'Interrupted system call',
-	[ErrorCode.EIO]: 'Input/output error',
-	[ErrorCode.ENXIO]: 'No such device or address',
-	[ErrorCode.EBADF]: 'Bad file descriptor',
-	[ErrorCode.EAGAIN]: 'Resource temporarily unavailable',
-	[ErrorCode.ENOMEM]: 'Cannot allocate memory',
-	[ErrorCode.EACCES]: 'Permission denied',
-	[ErrorCode.EFAULT]: 'Bad address',
-	[ErrorCode.ENOTBLK]: 'Block device required',
-	[ErrorCode.EBUSY]: 'Resource busy or locked',
-	[ErrorCode.EEXIST]: 'File exists',
-	[ErrorCode.EXDEV]: 'Invalid cross-device link',
-	[ErrorCode.ENODEV]: 'No such device',
-	[ErrorCode.ENOTDIR]: 'File is not a directory',
-	[ErrorCode.EISDIR]: 'File is a directory',
-	[ErrorCode.EINVAL]: 'Invalid argument',
-	[ErrorCode.ENFILE]: 'Too many open files in system',
-	[ErrorCode.EMFILE]: 'Too many open files',
-	[ErrorCode.ETXTBSY]: 'Text file busy',
-	[ErrorCode.EFBIG]: 'File is too big',
-	[ErrorCode.ENOSPC]: 'No space left on disk',
-	[ErrorCode.ESPIPE]: 'Illegal seek',
-	[ErrorCode.EROFS]: 'Cannot modify a read-only file system',
-	[ErrorCode.EMLINK]: 'Too many links',
-	[ErrorCode.EPIPE]: 'Broken pipe',
-	[ErrorCode.EDOM]: 'Numerical argument out of domain',
-	[ErrorCode.ERANGE]: 'Numerical result out of range',
-	[ErrorCode.EDEADLK]: 'Resource deadlock would occur',
-	[ErrorCode.ENAMETOOLONG]: 'File name too long',
-	[ErrorCode.ENOLCK]: 'No locks available',
-	[ErrorCode.ENOSYS]: 'Function not implemented',
-	[ErrorCode.ENOTEMPTY]: 'Directory is not empty',
-	[ErrorCode.ELOOP]: 'Too many levels of symbolic links',
-	[ErrorCode.ENOMSG]: 'No message of desired type',
-	[ErrorCode.EBADE]: 'Invalid exchange',
-	[ErrorCode.EBADR]: 'Invalid request descriptor',
-	[ErrorCode.EXFULL]: 'Exchange full',
-	[ErrorCode.ENOANO]: 'No anode',
-	[ErrorCode.EBADRQC]: 'Invalid request code',
-	[ErrorCode.ENOSTR]: 'Device not a stream',
-	[ErrorCode.ENODATA]: 'No data available',
-	[ErrorCode.ETIME]: 'Timer expired',
-	[ErrorCode.ENOSR]: 'Out of streams resources',
-	[ErrorCode.ENONET]: 'Machine is not on the network',
-	[ErrorCode.EREMOTE]: 'Object is remote',
-	[ErrorCode.ENOLINK]: 'Link has been severed',
-	[ErrorCode.ECOMM]: 'Communication error on send',
-	[ErrorCode.EPROTO]: 'Protocol error',
-	[ErrorCode.EBADMSG]: 'Bad message',
-	[ErrorCode.EOVERFLOW]: 'Value too large for defined data type',
-	[ErrorCode.EBADFD]: 'File descriptor in bad state',
-	[ErrorCode.ESTRPIPE]: 'Streams pipe error',
-	[ErrorCode.ENOTSOCK]: 'Socket operation on non-socket',
-	[ErrorCode.EDESTADDRREQ]: 'Destination address required',
-	[ErrorCode.EMSGSIZE]: 'Message too long',
-	[ErrorCode.EPROTOTYPE]: 'Protocol wrong type for socket',
-	[ErrorCode.ENOPROTOOPT]: 'Protocol not available',
-	[ErrorCode.EPROTONOSUPPORT]: 'Protocol not supported',
-	[ErrorCode.ESOCKTNOSUPPORT]: 'Socket type not supported',
-	[ErrorCode.ENOTSUP]: 'Operation is not supported',
-	[ErrorCode.ENETDOWN]: 'Network is down',
-	[ErrorCode.ENETUNREACH]: 'Network is unreachable',
-	[ErrorCode.ENETRESET]: 'Network dropped connection on reset',
-	[ErrorCode.ETIMEDOUT]: 'Connection timed out',
-	[ErrorCode.ECONNREFUSED]: 'Connection refused',
-	[ErrorCode.EHOSTDOWN]: 'Host is down',
-	[ErrorCode.EHOSTUNREACH]: 'No route to host',
-	[ErrorCode.EALREADY]: 'Operation already in progress',
-	[ErrorCode.EINPROGRESS]: 'Operation now in progress',
-	[ErrorCode.ESTALE]: 'Stale file handle',
-	[ErrorCode.EREMOTEIO]: 'Remote I/O error',
-	[ErrorCode.EDQUOT]: 'Disk quota exceeded',
+export const errorMessages: { [K in Errno]: string } = {
+	[Errno.EPERM]: 'Operation not permitted',
+	[Errno.ENOENT]: 'No such file or directory',
+	[Errno.EINTR]: 'Interrupted system call',
+	[Errno.EIO]: 'Input/output error',
+	[Errno.ENXIO]: 'No such device or address',
+	[Errno.EBADF]: 'Bad file descriptor',
+	[Errno.EAGAIN]: 'Resource temporarily unavailable',
+	[Errno.ENOMEM]: 'Cannot allocate memory',
+	[Errno.EACCES]: 'Permission denied',
+	[Errno.EFAULT]: 'Bad address',
+	[Errno.ENOTBLK]: 'Block device required',
+	[Errno.EBUSY]: 'Resource busy or locked',
+	[Errno.EEXIST]: 'File exists',
+	[Errno.EXDEV]: 'Invalid cross-device link',
+	[Errno.ENODEV]: 'No such device',
+	[Errno.ENOTDIR]: 'File is not a directory',
+	[Errno.EISDIR]: 'File is a directory',
+	[Errno.EINVAL]: 'Invalid argument',
+	[Errno.ENFILE]: 'Too many open files in system',
+	[Errno.EMFILE]: 'Too many open files',
+	[Errno.ETXTBSY]: 'Text file busy',
+	[Errno.EFBIG]: 'File is too big',
+	[Errno.ENOSPC]: 'No space left on disk',
+	[Errno.ESPIPE]: 'Illegal seek',
+	[Errno.EROFS]: 'Cannot modify a read-only file system',
+	[Errno.EMLINK]: 'Too many links',
+	[Errno.EPIPE]: 'Broken pipe',
+	[Errno.EDOM]: 'Numerical argument out of domain',
+	[Errno.ERANGE]: 'Numerical result out of range',
+	[Errno.EDEADLK]: 'Resource deadlock would occur',
+	[Errno.ENAMETOOLONG]: 'File name too long',
+	[Errno.ENOLCK]: 'No locks available',
+	[Errno.ENOSYS]: 'Function not implemented',
+	[Errno.ENOTEMPTY]: 'Directory is not empty',
+	[Errno.ELOOP]: 'Too many levels of symbolic links',
+	[Errno.ENOMSG]: 'No message of desired type',
+	[Errno.EBADE]: 'Invalid exchange',
+	[Errno.EBADR]: 'Invalid request descriptor',
+	[Errno.EXFULL]: 'Exchange full',
+	[Errno.ENOANO]: 'No anode',
+	[Errno.EBADRQC]: 'Invalid request code',
+	[Errno.ENOSTR]: 'Device not a stream',
+	[Errno.ENODATA]: 'No data available',
+	[Errno.ETIME]: 'Timer expired',
+	[Errno.ENOSR]: 'Out of streams resources',
+	[Errno.ENONET]: 'Machine is not on the network',
+	[Errno.EREMOTE]: 'Object is remote',
+	[Errno.ENOLINK]: 'Link has been severed',
+	[Errno.ECOMM]: 'Communication error on send',
+	[Errno.EPROTO]: 'Protocol error',
+	[Errno.EBADMSG]: 'Bad message',
+	[Errno.EOVERFLOW]: 'Value too large for defined data type',
+	[Errno.EBADFD]: 'File descriptor in bad state',
+	[Errno.ESTRPIPE]: 'Streams pipe error',
+	[Errno.ENOTSOCK]: 'Socket operation on non-socket',
+	[Errno.EDESTADDRREQ]: 'Destination address required',
+	[Errno.EMSGSIZE]: 'Message too long',
+	[Errno.EPROTOTYPE]: 'Protocol wrong type for socket',
+	[Errno.ENOPROTOOPT]: 'Protocol not available',
+	[Errno.EPROTONOSUPPORT]: 'Protocol not supported',
+	[Errno.ESOCKTNOSUPPORT]: 'Socket type not supported',
+	[Errno.ENOTSUP]: 'Operation is not supported',
+	[Errno.ENETDOWN]: 'Network is down',
+	[Errno.ENETUNREACH]: 'Network is unreachable',
+	[Errno.ENETRESET]: 'Network dropped connection on reset',
+	[Errno.ETIMEDOUT]: 'Connection timed out',
+	[Errno.ECONNREFUSED]: 'Connection refused',
+	[Errno.EHOSTDOWN]: 'Host is down',
+	[Errno.EHOSTUNREACH]: 'No route to host',
+	[Errno.EALREADY]: 'Operation already in progress',
+	[Errno.EINPROGRESS]: 'Operation now in progress',
+	[Errno.ESTALE]: 'Stale file handle',
+	[Errno.EREMOTEIO]: 'Remote I/O error',
+	[Errno.EDQUOT]: 'Disk quota exceeded',
 };
 
-interface ApiErrorJSON {
-	errno: ErrorCode;
+export interface ErrnoErrorJSON {
+	errno: Errno;
 	message: string;
 	path?: string;
-	code: keyof typeof ErrorCode;
+	code: keyof typeof Errno;
 	stack: string;
 	syscall: string;
 }
@@ -247,19 +247,19 @@ interface ApiErrorJSON {
  * Represents a ZenFS error. Passed back to applications after a failed
  * call to the ZenFS API.
  */
-export class ApiError extends Error implements NodeJS.ErrnoException {
-	public static fromJSON(json: ApiErrorJSON): ApiError {
-		const err = new ApiError(json.errno, json.message, json.path, json.syscall);
+export class ErrnoError extends Error implements NodeJS.ErrnoException {
+	public static fromJSON(json: ErrnoErrorJSON): ErrnoError {
+		const err = new ErrnoError(json.errno, json.message, json.path, json.syscall);
 		err.code = json.code;
 		err.stack = json.stack;
 		return err;
 	}
 
-	public static With(code: keyof typeof ErrorCode, path?: string, syscall?: string): ApiError {
-		return new ApiError(ErrorCode[code], errorMessages[ErrorCode[code]], path, syscall);
+	public static With(code: keyof typeof Errno, path?: string, syscall?: string): ErrnoError {
+		return new ErrnoError(Errno[code], errorMessages[Errno[code]], path, syscall);
 	}
 
-	public code: keyof typeof ErrorCode;
+	public code: keyof typeof Errno;
 
 	public declare stack: string;
 
@@ -274,13 +274,13 @@ export class ApiError extends Error implements NodeJS.ErrnoException {
 	 * @param message A descriptive error message.
 	 */
 	constructor(
-		public errno: ErrorCode,
+		public errno: Errno,
 		message: string = errorMessages[errno],
 		public path?: string,
 		public syscall: string = ''
 	) {
 		super(message);
-		this.code = <keyof typeof ErrorCode>ErrorCode[errno];
+		this.code = <keyof typeof Errno>Errno[errno];
 		this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
 	}
 
@@ -291,7 +291,7 @@ export class ApiError extends Error implements NodeJS.ErrnoException {
 		return this.message;
 	}
 
-	public toJSON(): ApiErrorJSON {
+	public toJSON(): ErrnoErrorJSON {
 		return {
 			errno: this.errno,
 			code: this.code,

package/src/file.ts

@@ -1,5 +1,5 @@
 import type { FileReadResult } from 'node:fs/promises';
-import { ApiError, ErrorCode } from './ApiError.js';
+import { ErrnoError, Errno } from './error.js';
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT } from './emulation/constants.js';
 import type { FileSystem } from './filesystem.js';
 import { size_max } from './inode.js';
@@ -208,6 +208,14 @@ export abstract class File {
 	 */
 	public abstract closeSync(): void;
 
+	public [Symbol.asyncDispose](): Promise<void> {
+		return this.close();
+	}
+
+	public [Symbol.dispose](): void {
+		return this.closeSync();
+	}
+
 	/**
 	 * Asynchronous truncate.
 	 */
@@ -482,7 +490,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	public truncateSync(len: number): void {
 		this._dirty = true;
 		if (!isWriteable(this.flag)) {
-			throw new ApiError(ErrorCode.EPERM, 'File not opened with a writeable mode.');
+			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
 		this.stats.mtimeMs = Date.now();
 		if (len > this._buffer.length) {
@@ -537,7 +545,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this._dirty = true;
 		position ??= this.position;
 		if (!isWriteable(this.flag)) {
-			throw new ApiError(ErrorCode.EPERM, 'File not opened with a writeable mode.');
+			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
 		const endFp = position + length;
 		if (endFp > this.stats.size) {
@@ -598,7 +606,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public readSync(buffer: ArrayBufferView, offset: number = 0, length: number = this.stats.size, position?: number): number {
 		if (!isReadable(this.flag)) {
-			throw new ApiError(ErrorCode.EPERM, 'File not opened with a readable mode.');
+			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
 		}
 		position ??= this.position;
 		let end = position + length;