@zenfs/core 0.9.7 → 0.10.0

package/dist/backends/Locked.js

@@ -1,3 +1,4 @@
+import { ErrnoError } from '../error.js';
 import { Mutex } from '../mutex.js';
 /**
  * This class serializes access to an underlying async filesystem.
@@ -31,21 +32,21 @@ export class LockedFS {
     }
     renameSync(oldPath, newPath, cred) {
         if (this._mu.isLocked(oldPath)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', oldPath, 'rename');
         }
         return this.fs.renameSync(oldPath, newPath, cred);
     }
-    async stat(p, cred) {
-        await this._mu.lock(p);
-        const stats = await this.fs.stat(p, cred);
-        this._mu.unlock(p);
+    async stat(path, cred) {
+        await this._mu.lock(path);
+        const stats = await this.fs.stat(path, cred);
+        this._mu.unlock(path);
         return stats;
     }
-    statSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    statSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'stat');
         }
-        return this.fs.statSync(p, cred);
+        return this.fs.statSync(path, cred);
     }
     async openFile(path, flag, cred) {
         await this._mu.lock(path);
@@ -55,7 +56,7 @@ export class LockedFS {
     }
     openFileSync(path, flag, cred) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'openFile');
         }
         return this.fs.openFileSync(path, flag, cred);
     }
@@ -67,7 +68,7 @@ export class LockedFS {
     }
     createFileSync(path, flag, mode, cred) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'createFile');
         }
         return this.fs.createFileSync(path, flag, mode, cred);
     }
@@ -76,57 +77,57 @@ export class LockedFS {
         await this.fs.unlink(p, cred);
         this._mu.unlock(p);
     }
-    unlinkSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    unlinkSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'unlink');
         }
-        return this.fs.unlinkSync(p, cred);
+        return this.fs.unlinkSync(path, cred);
     }
-    async rmdir(p, cred) {
-        await this._mu.lock(p);
-        await this.fs.rmdir(p, cred);
-        this._mu.unlock(p);
+    async rmdir(path, cred) {
+        await this._mu.lock(path);
+        await this.fs.rmdir(path, cred);
+        this._mu.unlock(path);
     }
-    rmdirSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    rmdirSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'rmdir');
         }
-        return this.fs.rmdirSync(p, cred);
+        return this.fs.rmdirSync(path, cred);
     }
-    async mkdir(p, mode, cred) {
-        await this._mu.lock(p);
-        await this.fs.mkdir(p, mode, cred);
-        this._mu.unlock(p);
+    async mkdir(path, mode, cred) {
+        await this._mu.lock(path);
+        await this.fs.mkdir(path, mode, cred);
+        this._mu.unlock(path);
     }
-    mkdirSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    mkdirSync(path, mode, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'mkdir');
         }
-        return this.fs.mkdirSync(p, mode, cred);
+        return this.fs.mkdirSync(path, mode, cred);
     }
-    async readdir(p, cred) {
-        await this._mu.lock(p);
-        const files = await this.fs.readdir(p, cred);
-        this._mu.unlock(p);
+    async readdir(path, cred) {
+        await this._mu.lock(path);
+        const files = await this.fs.readdir(path, cred);
+        this._mu.unlock(path);
         return files;
     }
-    readdirSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    readdirSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'readdir');
         }
-        return this.fs.readdirSync(p, cred);
+        return this.fs.readdirSync(path, cred);
     }
-    async exists(p, cred) {
-        await this._mu.lock(p);
-        const exists = await this.fs.exists(p, cred);
-        this._mu.unlock(p);
+    async exists(path, cred) {
+        await this._mu.lock(path);
+        const exists = await this.fs.exists(path, cred);
+        this._mu.unlock(path);
         return exists;
     }
-    existsSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    existsSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'exists');
         }
-        return this.fs.existsSync(p, cred);
+        return this.fs.existsSync(path, cred);
     }
     async link(srcpath, dstpath, cred) {
         await this._mu.lock(srcpath);
@@ -135,7 +136,7 @@ export class LockedFS {
     }
     linkSync(srcpath, dstpath, cred) {
         if (this._mu.isLocked(srcpath)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', srcpath, 'link');
         }
         return this.fs.linkSync(srcpath, dstpath, cred);
     }
@@ -146,7 +147,7 @@ export class LockedFS {
     }
     syncSync(path, data, stats) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'sync');
         }
         return this.fs.syncSync(path, data, stats);
     }

package/dist/backends/Overlay.js

@@ -1,5 +1,5 @@
 import { FileSystem } from '../filesystem.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
 import { Stats } from '../stats.js';
 import { LockedFS } from './Locked.js';
@@ -38,7 +38,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this._writable = writable;
         this._readable = readable;
         if (this._writable.metadata().readonly) {
-            throw new ApiError(ErrorCode.EINVAL, 'Writable file system must be writable.');
+            throw new ErrnoError(Errno.EINVAL, 'Writable file system must be writable.');
         }
         this._ready = this._initialize();
     }
@@ -80,7 +80,7 @@ export class UnlockedOverlayFS extends FileSystem {
             this._deleteLog = decode(buffer);
         }
         catch (err) {
-            if (err.errno !== ErrorCode.ENOENT) {
+            if (err.errno !== Errno.ENOENT) {
                 throw err;
             }
         }
@@ -104,7 +104,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
-                throw ApiError.With('ENOENT', oldPath, 'rename');
+                throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
         }
     }
@@ -117,7 +117,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
-                throw ApiError.With('ENOENT', oldPath, 'rename');
+                throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
         }
     }
@@ -128,7 +128,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         catch (e) {
             if (this._deletedFiles.has(p)) {
-                throw ApiError.With('ENOENT', p, 'stat');
+                throw ErrnoError.With('ENOENT', p, 'stat');
             }
             const oldStat = new Stats(await this._readable.stat(p, cred));
             // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type
@@ -143,7 +143,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         catch (e) {
             if (this._deletedFiles.has(p)) {
-                throw ApiError.With('ENOENT', p, 'stat');
+                throw ErrnoError.With('ENOENT', p, 'stat');
             }
             const oldStat = new Stats(this._readable.statSync(p, cred));
             // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type.
@@ -194,7 +194,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkInitialized();
         this.checkPath(p);
         if (!(await this.exists(p, cred))) {
-            throw ApiError.With('ENOENT', p, 'unlink');
+            throw ErrnoError.With('ENOENT', p, 'unlink');
         }
         if (await this._writable.exists(p, cred)) {
             await this._writable.unlink(p, cred);
@@ -208,7 +208,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkInitialized();
         this.checkPath(p);
         if (!this.existsSync(p, cred)) {
-            throw ApiError.With('ENOENT', p, 'unlink');
+            throw ErrnoError.With('ENOENT', p, 'unlink');
         }
         if (this._writable.existsSync(p, cred)) {
             this._writable.unlinkSync(p, cred);
@@ -221,7 +221,7 @@ export class UnlockedOverlayFS extends FileSystem {
     async rmdir(p, cred) {
         this.checkInitialized();
         if (!(await this.exists(p, cred))) {
-            throw ApiError.With('ENOENT', p, 'rmdir');
+            throw ErrnoError.With('ENOENT', p, 'rmdir');
         }
         if (await this._writable.exists(p, cred)) {
             await this._writable.rmdir(p, cred);
@@ -229,7 +229,7 @@ export class UnlockedOverlayFS extends FileSystem {
         if (await this.exists(p, cred)) {
             // Check if directory is empty.
             if ((await this.readdir(p, cred)).length > 0) {
-                throw ApiError.With('ENOTEMPTY', p, 'rmdir');
+                throw ErrnoError.With('ENOTEMPTY', p, 'rmdir');
             }
             else {
                 this.deletePath(p, cred);
@@ -239,7 +239,7 @@ export class UnlockedOverlayFS extends FileSystem {
     rmdirSync(p, cred) {
         this.checkInitialized();
         if (!this.existsSync(p, cred)) {
-            throw ApiError.With('ENOENT', p, 'rmdir');
+            throw ErrnoError.With('ENOENT', p, 'rmdir');
         }
         if (this._writable.existsSync(p, cred)) {
             this._writable.rmdirSync(p, cred);
@@ -247,7 +247,7 @@ export class UnlockedOverlayFS extends FileSystem {
         if (this.existsSync(p, cred)) {
             // Check if directory is empty.
             if (this.readdirSync(p, cred).length > 0) {
-                throw ApiError.With('ENOTEMPTY', p, 'rmdir');
+                throw ErrnoError.With('ENOTEMPTY', p, 'rmdir');
             }
             else {
                 this.deletePath(p, cred);
@@ -257,7 +257,7 @@ export class UnlockedOverlayFS extends FileSystem {
     async mkdir(p, mode, cred) {
         this.checkInitialized();
         if (await this.exists(p, cred)) {
-            throw ApiError.With('EEXIST', p, 'mkdir');
+            throw ErrnoError.With('EEXIST', p, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
         await this.createParentDirectories(p, cred);
@@ -266,7 +266,7 @@ export class UnlockedOverlayFS extends FileSystem {
     mkdirSync(p, mode, cred) {
         this.checkInitialized();
         if (this.existsSync(p, cred)) {
-            throw ApiError.With('EEXIST', p, 'mkdir');
+            throw ErrnoError.With('EEXIST', p, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
         this.createParentDirectoriesSync(p, cred);
@@ -276,7 +276,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkInitialized();
         const dirStats = await this.stat(p, cred);
         if (!dirStats.isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'readdir');
+            throw ErrnoError.With('ENOTDIR', p, 'readdir');
         }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         const contents = [];
@@ -303,7 +303,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkInitialized();
         const dirStats = this.statSync(p, cred);
         if (!dirStats.isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'readdir');
+            throw ErrnoError.With('ENOTDIR', p, 'readdir');
         }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         let contents = [];
@@ -364,7 +364,7 @@ export class UnlockedOverlayFS extends FileSystem {
     }
     checkInitialized() {
         if (!this._isInitialized) {
-            throw new ApiError(ErrorCode.EPERM, 'OverlayFS is not initialized. Please initialize OverlayFS using its initialize() method before using it.');
+            throw new ErrnoError(Errno.EPERM, 'OverlayFS is not initialized. Please initialize OverlayFS using its initialize() method before using it.');
         }
         if (!this._deleteLogError) {
             return;
@@ -375,7 +375,7 @@ export class UnlockedOverlayFS extends FileSystem {
     }
     checkPath(path) {
         if (path == deletionLogPath) {
-            throw ApiError.With('EPERM', path, 'checkPath');
+            throw ErrnoError.With('EPERM', path, 'checkPath');
         }
     }
     /**
@@ -412,7 +412,7 @@ export class UnlockedOverlayFS extends FileSystem {
      */
     operateOnWritable(p, cred) {
         if (!this.existsSync(p, cred)) {
-            throw ApiError.With('ENOENT', p, 'operateOnWriteable');
+            throw ErrnoError.With('ENOENT', p, 'operateOnWriteable');
         }
         if (!this._writable.existsSync(p, cred)) {
             // File is on readable storage. Copy to writable storage before
@@ -422,7 +422,7 @@ export class UnlockedOverlayFS extends FileSystem {
     }
     async operateOnWritableAsync(p, cred) {
         if (!(await this.exists(p, cred))) {
-            throw ApiError.With('ENOENT', p, 'operateOnWritable');
+            throw ErrnoError.With('ENOENT', p, 'operateOnWritable');
         }
         if (!(await this._writable.exists(p, cred))) {
             return this.copyToWritable(p, cred);

package/dist/backends/SyncStore.js

@@ -1,5 +1,5 @@
 import { dirname, basename, join, resolve, sep } from '../emulation/path.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { W_OK, R_OK } from '../emulation/constants.js';
 import { PreloadFile, flagToMode } from '../file.js';
 import { FileSystem, Sync } from '../filesystem.js';
@@ -110,10 +110,10 @@ export class SyncStoreFS extends Sync(FileSystem) {
         // Remove oldPath from parent's directory listing.
         oldDirNode = this.findINode(tx, oldParent), oldDirList = this.getDirListing(tx, oldDirNode, oldParent);
         if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', oldPath, 'rename');
+            throw ErrnoError.With('EACCES', oldPath, 'rename');
         }
         if (!oldDirList[oldName]) {
-            throw ApiError.With('ENOENT', oldPath, 'rename');
+            throw ErrnoError.With('ENOENT', oldPath, 'rename');
         }
         const ino = oldDirList[oldName];
         delete oldDirList[oldName];
@@ -122,7 +122,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
         // is a subpath of newParent. We append '/' to avoid matching folders that
         // are a substring of the bottom-most folder in the path.
         if ((newParent + '/').indexOf(oldPath + '/') == 0) {
-            throw new ApiError(ErrorCode.EBUSY, oldParent);
+            throw new ErrnoError(Errno.EBUSY, oldParent);
         }
         // Add newPath to parent's directory listing.
         let newDirNode, newDirList;
@@ -151,7 +151,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
             }
             else {
                 // If it's a directory, throw a permissions error.
-                throw ApiError.With('EPERM', newPath, 'rename');
+                throw ErrnoError.With('EPERM', newPath, 'rename');
             }
         }
         newDirList[newName] = ino;
@@ -170,7 +170,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
         // Get the inode to the item, convert it into a Stats object.
         const stats = this.findINode(this.store.beginTransaction(), p).toStats();
         if (!stats.hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'stat');
+            throw ErrnoError.With('EACCES', p, 'stat');
         }
         return stats;
     }
@@ -181,10 +181,10 @@ export class SyncStoreFS extends Sync(FileSystem) {
     openFileSync(p, flag, cred) {
         const tx = this.store.beginTransaction(), node = this.findINode(tx, p), data = tx.get(node.ino);
         if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ApiError.With('EACCES', p, 'openFile');
+            throw ErrnoError.With('EACCES', p, 'openFile');
         }
         if (!data) {
-            throw ApiError.With('ENOENT', p, 'openFile');
+            throw ErrnoError.With('ENOENT', p, 'openFile');
         }
         return new PreloadFile(this, p, flag, node.toStats(), data);
     }
@@ -194,7 +194,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
     rmdirSync(p, cred) {
         // Check first if directory is empty.
         if (this.readdirSync(p, cred).length > 0) {
-            throw ApiError.With('ENOTEMPTY', p, 'rmdir');
+            throw ErrnoError.With('ENOTEMPTY', p, 'rmdir');
         }
         else {
             this.removeEntry(p, true, cred);
@@ -207,7 +207,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
         const tx = this.store.beginTransaction();
         const node = this.findINode(tx, p);
         if (!node.toStats().hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'readdir');
+            throw ErrnoError.With('EACCES', p, 'readdir');
         }
         return Object.keys(this.getDirListing(tx, node, p));
     }
@@ -234,16 +234,16 @@ export class SyncStoreFS extends Sync(FileSystem) {
     linkSync(existing, newpath, cred) {
         const tx = this.store.beginTransaction(), existingDir = dirname(existing), existingDirNode = this.findINode(tx, existingDir);
         if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', existingDir, 'link');
+            throw ErrnoError.With('EACCES', existingDir, 'link');
         }
         const newDir = dirname(newpath), newDirNode = this.findINode(tx, newDir), newListing = this.getDirListing(tx, newDirNode, newDir);
         if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', newDir, 'link');
+            throw ErrnoError.With('EACCES', newDir, 'link');
         }
         const ino = this._findINode(tx, existingDir, basename(existing));
         const node = this.getINode(tx, ino, existing);
         if (!node.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', newpath, 'link');
+            throw ErrnoError.With('EACCES', newpath, 'link');
         }
         node.nlink++;
         newListing[basename(newpath)] = ino;
@@ -283,14 +283,14 @@ export class SyncStoreFS extends Sync(FileSystem) {
     _findINode(tx, parent, filename, visited = new Set()) {
         const currentPath = join(parent, filename);
         if (visited.has(currentPath)) {
-            throw new ApiError(ErrorCode.EIO, 'Infinite loop detected while finding inode', currentPath);
+            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
         }
         visited.add(currentPath);
         if (parent != '/') {
             const ino = this._findINode(tx, dirname(parent), basename(parent), visited);
             const dir = this.getDirListing(tx, this.getINode(tx, ino, parent + sep + filename), parent);
             if (!(filename in dir)) {
-                throw ApiError.With('ENOENT', resolve(parent, filename), '_findINode');
+                throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
             }
             return dir[filename];
         }
@@ -298,7 +298,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
             // Find the item in the root node.
             const dir = this.getDirListing(tx, this.getINode(tx, rootIno, parent), parent);
             if (!(filename in dir)) {
-                throw ApiError.With('ENOENT', resolve(parent, filename), '_findINode');
+                throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
             }
             return dir[filename];
         }
@@ -324,7 +324,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
     getINode(tx, id, path) {
         const data = tx.get(id);
         if (!data) {
-            throw ApiError.With('ENOENT', path, 'getINode');
+            throw ErrnoError.With('ENOENT', path, 'getINode');
         }
         const inode = new Inode(data.buffer);
         return inode;
@@ -334,11 +334,11 @@ export class SyncStoreFS extends Sync(FileSystem) {
      */
     getDirListing(tx, inode, p) {
         if (!inode.toStats().isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'getDirListing');
+            throw ErrnoError.With('ENOTDIR', p, 'getDirListing');
         }
         const data = tx.get(inode.ino);
         if (!data) {
-            throw ApiError.With('ENOENT', p, 'getDirListing');
+            throw ErrnoError.With('ENOENT', p, 'getDirListing');
         }
         return decodeDirListing(data);
     }
@@ -355,7 +355,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
             }
             return ino;
         }
-        throw new ApiError(ErrorCode.EIO, 'Unable to commit data to key-value store.');
+        throw new ErrnoError(Errno.EIO, 'Unable to commit data to key-value store.');
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with the given mode.
@@ -370,18 +370,18 @@ export class SyncStoreFS extends Sync(FileSystem) {
         const tx = this.store.beginTransaction(), parentDir = dirname(p), fname = basename(p), parentNode = this.findINode(tx, parentDir), dirListing = this.getDirListing(tx, parentNode, parentDir);
         //Check that the creater has correct access
         if (!parentNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'commitNewFile');
+            throw ErrnoError.With('EACCES', p, 'commitNewFile');
         }
         /* Invariant: The root always exists.
         If we don't check this prior to taking steps below,
         we will create a file with name '' in root should p == '/'.
         */
         if (p === '/') {
-            throw ApiError.With('EEXIST', p, 'commitNewFile');
+            throw ErrnoError.With('EEXIST', p, 'commitNewFile');
         }
         // Check if file already exists.
         if (dirListing[fname]) {
-            throw ApiError.With('EEXIST', p, 'commitNewFile');
+            throw ErrnoError.With('EEXIST', p, 'commitNewFile');
         }
         const fileNode = new Inode();
         try {
@@ -411,20 +411,20 @@ export class SyncStoreFS extends Sync(FileSystem) {
     removeEntry(p, isDir, cred) {
         const tx = this.store.beginTransaction(), parent = dirname(p), parentNode = this.findINode(tx, parent), parentListing = this.getDirListing(tx, parentNode, parent), fileName = basename(p), fileIno = parentListing[fileName];
         if (!fileIno) {
-            throw ApiError.With('ENOENT', p, 'removeEntry');
+            throw ErrnoError.With('ENOENT', p, 'removeEntry');
         }
         // Get file inode.
         const fileNode = this.getINode(tx, fileIno, p);
         if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'removeEntry');
+            throw ErrnoError.With('EACCES', p, 'removeEntry');
         }
         // Remove from directory listing of parent.
         delete parentListing[fileName];
         if (!isDir && fileNode.toStats().isDirectory()) {
-            throw ApiError.With('EISDIR', p, 'removeEntry');
+            throw ErrnoError.With('EISDIR', p, 'removeEntry');
         }
         if (isDir && !fileNode.toStats().isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'removeEntry');
+            throw ErrnoError.With('ENOTDIR', p, 'removeEntry');
         }
         try {
             // Update directory listing.

package/dist/backends/backend.js

@@ -1,4 +1,4 @@
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { levenshtein } from '../utils.js';
 /**
  * @internal
@@ -12,7 +12,7 @@ export function isBackend(arg) {
  */
 export async function checkOptions(backend, opts) {
     if (typeof opts != 'object' || opts === null) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid options');
+        throw new ErrnoError(Errno.EINVAL, 'Invalid options');
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
@@ -31,12 +31,12 @@ export async function checkOptions(backend, opts) {
             })
                 .filter(o => o.distance < 5)
                 .sort((a, b) => a.distance - b.distance);
-            throw new ApiError(ErrorCode.EINVAL, `${backend.name}: Required option '${optName}' not provided.${incorrectOptions.length > 0 ? ` You provided '${incorrectOptions[0].str}', did you mean '${optName}'.` : ''}`);
+            throw new ErrnoError(Errno.EINVAL, `${backend.name}: Required option '${optName}' not provided.${incorrectOptions.length > 0 ? ` You provided '${incorrectOptions[0].str}', did you mean '${optName}'.` : ''}`);
         }
         // Option provided, check type.
         const typeMatches = Array.isArray(opt.type) ? opt.type.indexOf(typeof providedValue) != -1 : typeof providedValue == opt.type;
         if (!typeMatches) {
-            throw new ApiError(ErrorCode.EINVAL, `${backend.name}: Value provided for option ${optName} is not the proper type. Expected ${Array.isArray(opt.type) ? `one of {${opt.type.join(', ')}}` : opt.type}, but received ${typeof providedValue}`);
+            throw new ErrnoError(Errno.EINVAL, `${backend.name}: Value provided for option ${optName} is not the proper type. Expected ${Array.isArray(opt.type) ? `one of {${opt.type.join(', ')}}` : opt.type}, but received ${typeof providedValue}`);
         }
         if (opt.validator) {
             await opt.validator(providedValue);