@zenfs/core 0.9.7 → 0.10.0

package/dist/emulation/streams.js

@@ -1,5 +1,5 @@
 import { Readable, Writable } from 'readable-stream';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 export class ReadStream extends Readable {
     close(callback = () => null) {
         try {
@@ -8,7 +8,7 @@ export class ReadStream extends Readable {
             callback();
         }
         catch (err) {
-            callback(new ApiError(ErrorCode.EIO, err.toString()));
+            callback(new ErrnoError(Errno.EIO, err.toString()));
         }
     }
 }
@@ -20,7 +20,7 @@ export class WriteStream extends Writable {
             callback();
         }
         catch (err) {
-            callback(new ApiError(ErrorCode.EIO, err.toString()));
+            callback(new ErrnoError(Errno.EIO, err.toString()));
         }
     }
 }

package/dist/emulation/sync.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
@@ -52,7 +52,7 @@ export function existsSync(path) {
         return fs.existsSync(resolvedPath, cred);
     }
     catch (e) {
-        if (e.errno == ErrorCode.ENOENT) {
+        if (e.errno == Errno.ENOENT) {
             return false;
         }
         throw e;
@@ -106,22 +106,22 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
                 // Ensure parent exists.
                 const parentStats = 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);
@@ -135,7 +135,7 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
         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.');
     }
 }
 /**
@@ -179,7 +179,7 @@ export function readFileSync(path, _options = {}) {
     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.from(_readFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
     return options.encoding ? data.toString(options.encoding) : data;
@@ -204,14 +204,14 @@ export function writeFileSync(path, data, _options = {}) {
     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);
 }
@@ -244,10 +244,10 @@ export function appendFileSync(filename, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
     if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
     }
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     _appendFileSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), encodedData, options.flag, options.mode, true);
@@ -275,7 +275,7 @@ closeSync;
 export function ftruncateSync(fd, len = 0) {
     len || (len = 0);
     if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+        throw new ErrnoError(Errno.EINVAL);
     }
     fd2file(fd).truncateSync(len);
 }
@@ -350,7 +350,7 @@ fchownSync;
 export function fchmodSync(fd, mode) {
     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);
 }
@@ -424,10 +424,10 @@ linkSync;
  */
 export function symlinkSync(target, path, type = 'file') {
     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());
     const file = _openSync(path, 'r+', 0o644, false);
@@ -539,7 +539,7 @@ realpathSync;
 export function accessSync(path, mode = 0o600) {
     const stats = statSync(path);
     if (!stats.hasAccess(mode, cred)) {
-        throw new ApiError(ErrorCode.EACCES);
+        throw new ErrnoError(Errno.EACCES);
     }
 }
 accessSync;
@@ -568,7 +568,7 @@ export function rmSync(path, options) {
         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;
@@ -591,7 +591,7 @@ export function copyFileSync(src, dest, flags) {
     src = normalizePath(src);
     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));
 }
@@ -656,12 +656,12 @@ export function cpSync(source, destination, opts) {
     destination = normalizePath(destination);
     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 })) {
@@ -680,7 +680,7 @@ export function cpSync(source, destination, opts) {
         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
     if (opts?.preserveTimestamps) {
@@ -689,5 +689,5 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ApiError.With('ENOSYS', path.toString(), 'statfs');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }

package/dist/{ApiError.d.ts → error.d.ts}

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /**
- * 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 declare enum ErrorCode {
+export declare enum Errno {
     /** Operation not permitted */
     EPERM = 1,
     /** No such file or directory */
@@ -159,13 +159,13 @@ export declare enum ErrorCode {
  * @internal
  */
 export declare const errorMessages: {
-    [K in ErrorCode]: string;
+    [K in Errno]: string;
 };
-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;
 }
@@ -173,13 +173,13 @@ interface ApiErrorJSON {
  * Represents a ZenFS error. Passed back to applications after a failed
  * call to the ZenFS API.
  */
-export declare class ApiError extends Error implements NodeJS.ErrnoException {
-    errno: ErrorCode;
+export declare class ErrnoError extends Error implements NodeJS.ErrnoException {
+    errno: Errno;
     path?: string | undefined;
     syscall: string;
-    static fromJSON(json: ApiErrorJSON): ApiError;
-    static With(code: keyof typeof ErrorCode, path?: string, syscall?: string): ApiError;
-    code: keyof typeof ErrorCode;
+    static fromJSON(json: ErrnoErrorJSON): ErrnoError;
+    static With(code: keyof typeof Errno, path?: string, syscall?: string): ErrnoError;
+    code: keyof typeof Errno;
     stack: string;
     /**
      * Represents a ZenFS error. Passed back to applications after a failed
@@ -191,15 +191,14 @@ export declare class ApiError extends Error implements NodeJS.ErrnoException {
      * @param type The type of the error.
      * @param message A descriptive error message.
      */
-    constructor(errno: ErrorCode, message?: string, path?: string | undefined, syscall?: string);
+    constructor(errno: Errno, message?: string, path?: string | undefined, syscall?: string);
     /**
      * @return A friendly error message.
      */
     toString(): string;
-    toJSON(): ApiErrorJSON;
+    toJSON(): ErrnoErrorJSON;
     /**
      * The size of the API error in buffer-form in bytes.
      */
     bufferSize(): number;
 }
-export {};

package/dist/error.js

@@ -0,0 +1,292 @@
+/**
+ * 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 var Errno;
+(function (Errno) {
+    /** Operation not permitted */
+    Errno[Errno["EPERM"] = 1] = "EPERM";
+    /** No such file or directory */
+    Errno[Errno["ENOENT"] = 2] = "ENOENT";
+    /** Interrupted system call */
+    Errno[Errno["EINTR"] = 4] = "EINTR";
+    /** Input/output error */
+    Errno[Errno["EIO"] = 5] = "EIO";
+    /** No such device or address */
+    Errno[Errno["ENXIO"] = 6] = "ENXIO";
+    /** Bad file descriptor */
+    Errno[Errno["EBADF"] = 9] = "EBADF";
+    /** Resource temporarily unavailable */
+    Errno[Errno["EAGAIN"] = 11] = "EAGAIN";
+    /** Cannot allocate memory */
+    Errno[Errno["ENOMEM"] = 12] = "ENOMEM";
+    /** Permission denied */
+    Errno[Errno["EACCES"] = 13] = "EACCES";
+    /** Bad address */
+    Errno[Errno["EFAULT"] = 14] = "EFAULT";
+    /** Block device required */
+    Errno[Errno["ENOTBLK"] = 15] = "ENOTBLK";
+    /** Resource busy or locked */
+    Errno[Errno["EBUSY"] = 16] = "EBUSY";
+    /** File exists */
+    Errno[Errno["EEXIST"] = 17] = "EEXIST";
+    /** Invalid cross-device link */
+    Errno[Errno["EXDEV"] = 18] = "EXDEV";
+    /** No such device */
+    Errno[Errno["ENODEV"] = 19] = "ENODEV";
+    /** File is not a directory */
+    Errno[Errno["ENOTDIR"] = 20] = "ENOTDIR";
+    /** File is a directory */
+    Errno[Errno["EISDIR"] = 21] = "EISDIR";
+    /** Invalid argument */
+    Errno[Errno["EINVAL"] = 22] = "EINVAL";
+    /** Too many open files in system */
+    Errno[Errno["ENFILE"] = 23] = "ENFILE";
+    /** Too many open files */
+    Errno[Errno["EMFILE"] = 24] = "EMFILE";
+    /** Text file busy */
+    Errno[Errno["ETXTBSY"] = 26] = "ETXTBSY";
+    /** File is too big */
+    Errno[Errno["EFBIG"] = 27] = "EFBIG";
+    /** No space left on disk */
+    Errno[Errno["ENOSPC"] = 28] = "ENOSPC";
+    /** Illegal seek */
+    Errno[Errno["ESPIPE"] = 29] = "ESPIPE";
+    /** Cannot modify a read-only file system */
+    Errno[Errno["EROFS"] = 30] = "EROFS";
+    /** Too many links */
+    Errno[Errno["EMLINK"] = 31] = "EMLINK";
+    /** Broken pipe */
+    Errno[Errno["EPIPE"] = 32] = "EPIPE";
+    /** Numerical argument out of domain */
+    Errno[Errno["EDOM"] = 33] = "EDOM";
+    /** Numerical result out of range */
+    Errno[Errno["ERANGE"] = 34] = "ERANGE";
+    /** Resource deadlock would occur */
+    Errno[Errno["EDEADLK"] = 35] = "EDEADLK";
+    /** File name too long */
+    Errno[Errno["ENAMETOOLONG"] = 36] = "ENAMETOOLONG";
+    /** No locks available */
+    Errno[Errno["ENOLCK"] = 37] = "ENOLCK";
+    /** Function not implemented */
+    Errno[Errno["ENOSYS"] = 38] = "ENOSYS";
+    /** Directory is not empty */
+    Errno[Errno["ENOTEMPTY"] = 39] = "ENOTEMPTY";
+    /** Too many levels of symbolic links */
+    Errno[Errno["ELOOP"] = 40] = "ELOOP";
+    /** No message of desired type */
+    Errno[Errno["ENOMSG"] = 42] = "ENOMSG";
+    /** Invalid exchange */
+    Errno[Errno["EBADE"] = 52] = "EBADE";
+    /** Invalid request descriptor */
+    Errno[Errno["EBADR"] = 53] = "EBADR";
+    /** Exchange full */
+    Errno[Errno["EXFULL"] = 54] = "EXFULL";
+    /** No anode */
+    Errno[Errno["ENOANO"] = 55] = "ENOANO";
+    /** Invalid request code */
+    Errno[Errno["EBADRQC"] = 56] = "EBADRQC";
+    /** Device not a stream */
+    Errno[Errno["ENOSTR"] = 60] = "ENOSTR";
+    /** No data available */
+    Errno[Errno["ENODATA"] = 61] = "ENODATA";
+    /** Timer expired */
+    Errno[Errno["ETIME"] = 62] = "ETIME";
+    /** Out of streams resources */
+    Errno[Errno["ENOSR"] = 63] = "ENOSR";
+    /** Machine is not on the network */
+    Errno[Errno["ENONET"] = 64] = "ENONET";
+    /** Object is remote */
+    Errno[Errno["EREMOTE"] = 66] = "EREMOTE";
+    /** Link has been severed */
+    Errno[Errno["ENOLINK"] = 67] = "ENOLINK";
+    /** Communication error on send */
+    Errno[Errno["ECOMM"] = 70] = "ECOMM";
+    /** Protocol error */
+    Errno[Errno["EPROTO"] = 71] = "EPROTO";
+    /** Bad message */
+    Errno[Errno["EBADMSG"] = 74] = "EBADMSG";
+    /** Value too large for defined data type */
+    Errno[Errno["EOVERFLOW"] = 75] = "EOVERFLOW";
+    /** File descriptor in bad state */
+    Errno[Errno["EBADFD"] = 77] = "EBADFD";
+    /** Streams pipe error */
+    Errno[Errno["ESTRPIPE"] = 86] = "ESTRPIPE";
+    /** Socket operation on non-socket */
+    Errno[Errno["ENOTSOCK"] = 88] = "ENOTSOCK";
+    /** Destination address required */
+    Errno[Errno["EDESTADDRREQ"] = 89] = "EDESTADDRREQ";
+    /** Message too long */
+    Errno[Errno["EMSGSIZE"] = 90] = "EMSGSIZE";
+    /** Protocol wrong type for socket */
+    Errno[Errno["EPROTOTYPE"] = 91] = "EPROTOTYPE";
+    /** Protocol not available */
+    Errno[Errno["ENOPROTOOPT"] = 92] = "ENOPROTOOPT";
+    /** Protocol not supported */
+    Errno[Errno["EPROTONOSUPPORT"] = 93] = "EPROTONOSUPPORT";
+    /** Socket type not supported */
+    Errno[Errno["ESOCKTNOSUPPORT"] = 94] = "ESOCKTNOSUPPORT";
+    /** Operation is not supported */
+    Errno[Errno["ENOTSUP"] = 95] = "ENOTSUP";
+    /** Network is down */
+    Errno[Errno["ENETDOWN"] = 100] = "ENETDOWN";
+    /** Network is unreachable */
+    Errno[Errno["ENETUNREACH"] = 101] = "ENETUNREACH";
+    /** Network dropped connection on reset */
+    Errno[Errno["ENETRESET"] = 102] = "ENETRESET";
+    /** Connection timed out */
+    Errno[Errno["ETIMEDOUT"] = 110] = "ETIMEDOUT";
+    /** Connection refused */
+    Errno[Errno["ECONNREFUSED"] = 111] = "ECONNREFUSED";
+    /** Host is down */
+    Errno[Errno["EHOSTDOWN"] = 112] = "EHOSTDOWN";
+    /** No route to host */
+    Errno[Errno["EHOSTUNREACH"] = 113] = "EHOSTUNREACH";
+    /** Operation already in progress */
+    Errno[Errno["EALREADY"] = 114] = "EALREADY";
+    /** Operation now in progress */
+    Errno[Errno["EINPROGRESS"] = 115] = "EINPROGRESS";
+    /** Stale file handle */
+    Errno[Errno["ESTALE"] = 116] = "ESTALE";
+    /** Remote I/O error */
+    Errno[Errno["EREMOTEIO"] = 121] = "EREMOTEIO";
+    /** Disk quota exceeded */
+    Errno[Errno["EDQUOT"] = 122] = "EDQUOT";
+})(Errno || (Errno = {}));
+/**
+ * Strings associated with each error code.
+ * @internal
+ */
+export const errorMessages = {
+    [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',
+};
+/**
+ * Represents a ZenFS error. Passed back to applications after a failed
+ * call to the ZenFS API.
+ */
+export class ErrnoError extends Error {
+    static fromJSON(json) {
+        const err = new ErrnoError(json.errno, json.message, json.path, json.syscall);
+        err.code = json.code;
+        err.stack = json.stack;
+        return err;
+    }
+    static With(code, path, syscall) {
+        return new ErrnoError(Errno[code], errorMessages[Errno[code]], path, syscall);
+    }
+    /**
+     * Represents a ZenFS error. Passed back to applications after a failed
+     * call to the ZenFS API.
+     *
+     * Error codes mirror those returned by regular Unix file operations, which is
+     * what Node returns.
+     * @constructor ApiError
+     * @param type The type of the error.
+     * @param message A descriptive error message.
+     */
+    constructor(errno, message = errorMessages[errno], path, syscall = '') {
+        super(message);
+        this.errno = errno;
+        this.path = path;
+        this.syscall = syscall;
+        this.code = Errno[errno];
+        this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
+    }
+    /**
+     * @return A friendly error message.
+     */
+    toString() {
+        return this.message;
+    }
+    toJSON() {
+        return {
+            errno: this.errno,
+            code: this.code,
+            path: this.path,
+            stack: this.stack,
+            message: this.message,
+            syscall: this.syscall,
+        };
+    }
+    /**
+     * The size of the API error in buffer-form in bytes.
+     */
+    bufferSize() {
+        // 4 bytes for string length.
+        return 4 + JSON.stringify(this.toJSON()).length;
+    }
+}

package/dist/file.d.ts

@@ -70,6 +70,8 @@ export declare abstract class File {
      * Synchronous close.
      */
     abstract closeSync(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+    [Symbol.dispose](): void;
     /**
      * Asynchronous truncate.
      */

package/dist/file.js

@@ -1,4 +1,4 @@
-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 { size_max } from './inode.js';
 import { Stats } from './stats.js';
@@ -133,6 +133,12 @@ export function pathNotExistsAction(flag) {
     return ActionType.THROW;
 }
 export class File {
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+    [Symbol.dispose]() {
+        return this.closeSync();
+    }
     /**
      * Asynchronous `datasync`.
      *
@@ -276,7 +282,7 @@ export class PreloadFile extends File {
     truncateSync(len) {
         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) {
@@ -329,7 +335,7 @@ export class PreloadFile extends File {
         this._dirty = true;
         position ?? (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) {
@@ -384,7 +390,7 @@ export class PreloadFile extends File {
      */
     readSync(buffer, offset = 0, length = this.stats.size, position) {
         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 ?? (position = this.position);
         let end = position + length;