@zenfs/core 2.0.0 → 2.1.1

package/dist/backends/store/fs.js

@@ -50,13 +50,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { _throw, canary, encodeUTF8, serialize, sizeof } from 'utilium';
+import { withErrno } from 'kerium';
+import { crit, debug, err, notice, warn } from 'kerium/log';
+import { sizeof } from 'memium';
+import { _throw, canary, encodeUTF8 } from 'utilium';
 import { extendBuffer } from 'utilium/buffer.js';
-import { Errno, ErrnoError } from '../../internal/error.js';
 import { Index } from '../../internal/file_index.js';
 import { FileSystem } from '../../internal/filesystem.js';
 import { Inode, isDirectory, rootIno } from '../../internal/inode.js';
-import { crit, debug, err, notice, warn } from '../../internal/log.js';
 import { basename, dirname, join, parse, relative } from '../../path.js';
 import { decodeDirListing, encodeDirListing } from '../../utils.js';
 import { S_IFDIR, S_IFREG, size_max } from '../../vfs/constants.js';
@@ -145,8 +146,9 @@ export class StoreFS extends FileSystem {
          */
         this._paths = new Map([[0, new Set('/')]]);
         this._initialized = false;
-        store._fs = this;
+        store.fs = this;
         this._uuid = (_b = store.uuid) !== null && _b !== void 0 ? _b : this.uuid;
+        this.label = store.label;
         debug(this.name + ': supports features: ' + ((_c = this.store.flags) === null || _c === void 0 ? void 0 : _c.join(', ')));
     }
     /**
@@ -170,7 +172,7 @@ export class StoreFS extends FileSystem {
             const dirs = index.directories();
             for (const [path, inode] of index) {
                 this._add(inode.ino, path);
-                await tx.set(inode.ino, serialize(inode));
+                await tx.set(inode.ino, inode);
                 if (dirs.has(path))
                     await tx.set(inode.data, encodeDirListing(dirs.get(path)));
             }
@@ -197,7 +199,7 @@ export class StoreFS extends FileSystem {
             const dirs = index.directories();
             for (const [path, inode] of index) {
                 this._add(inode.ino, path);
-                tx.setSync(inode.ino, serialize(inode));
+                tx.setSync(inode.ino, inode);
                 if (dirs.has(path))
                     tx.setSync(inode.data, encodeDirListing(dirs.get(path)));
             }
@@ -218,13 +220,13 @@ export class StoreFS extends FileSystem {
             const index = new Index();
             const tx = __addDisposableResource(env_3, this.transaction(), true);
             const queue = [['/', 0]];
-            const silence = canary(ErrnoError.With('EDEADLK'));
+            const silence = canary(withErrno('EDEADLK'));
             while (queue.length) {
                 const [path, ino] = queue.shift();
                 const inode = new Inode(await tx.get(ino));
                 index.set(path, inode);
                 if (inode.mode & S_IFDIR) {
-                    const dir = decodeDirListing((_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path)));
+                    const dir = decodeDirListing((_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA')));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
                     }
@@ -250,13 +252,13 @@ export class StoreFS extends FileSystem {
             const index = new Index();
             const tx = __addDisposableResource(env_4, this.transaction(), false);
             const queue = [['/', 0]];
-            const silence = canary(ErrnoError.With('EDEADLK'));
+            const silence = canary(withErrno('EDEADLK'));
             while (queue.length) {
                 const [path, ino] = queue.shift();
                 const inode = new Inode(tx.getSync(ino));
                 index.set(path, inode);
                 if (inode.mode & S_IFDIR) {
-                    const dir = decodeDirListing((_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path)));
+                    const dir = decodeDirListing((_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA')));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
                     }
@@ -283,9 +285,9 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_5, this.transaction(), true);
             const _old = parse(oldPath), _new = parse(newPath), 
             // Remove oldPath from parent's directory listing.
-            oldDirNode = await this.findInode(tx, _old.dir, 'rename'), oldDirList = decodeDirListing((_a = (await tx.get(oldDirNode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', _old.dir, 'rename')));
+            oldDirNode = await this.findInode(tx, _old.dir), oldDirList = decodeDirListing((_a = (await tx.get(oldDirNode.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA')));
             if (!oldDirList[_old.base])
-                throw ErrnoError.With('ENOENT', oldPath, 'rename');
+                throw withErrno('ENOENT');
             const ino = oldDirList[_old.base];
             if (ino != this._ids.get(oldPath))
                 err(`Ino mismatch while renaming ${oldPath} to ${newPath}`);
@@ -296,19 +298,17 @@ export class StoreFS extends FileSystem {
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
             if ((_new.dir + '/').startsWith(oldPath + '/'))
-                throw new ErrnoError(Errno.EBUSY, _old.dir);
-            // Add newPath to parent's directory listing.
+                throw withErrno('EBUSY');
             const sameParent = _new.dir == _old.dir;
             // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
-            const newDirNode = sameParent ? oldDirNode : await this.findInode(tx, _new.dir, 'rename');
+            const newDirNode = sameParent ? oldDirNode : await this.findInode(tx, _new.dir);
             const newDirList = sameParent
                 ? oldDirList
-                : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', _new.dir, 'rename')));
+                : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
-                // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const existing = new Inode((_c = (await tx.get(newDirList[_new.base]))) !== null && _c !== void 0 ? _c : _throw(ErrnoError.With('ENOENT', newPath, 'rename')));
+                const existing = new Inode((_c = (await tx.get(newDirList[_new.base]))) !== null && _c !== void 0 ? _c : _throw(withErrno('ENOENT')));
                 if (!existing.toStats().isFile())
-                    throw ErrnoError.With('EPERM', newPath, 'rename');
+                    throw withErrno('EISDIR');
                 await tx.remove(existing.data);
                 await tx.remove(newDirList[_new.base]);
             }
@@ -336,9 +336,9 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_6, this.transaction(), false);
             const _old = parse(oldPath), _new = parse(newPath), 
             // Remove oldPath from parent's directory listing.
-            oldDirNode = this.findInodeSync(tx, _old.dir, 'rename'), oldDirList = decodeDirListing((_a = tx.getSync(oldDirNode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', _old.dir, 'rename')));
+            oldDirNode = this.findInodeSync(tx, _old.dir), oldDirList = decodeDirListing((_a = tx.getSync(oldDirNode.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA')));
             if (!oldDirList[_old.base])
-                throw ErrnoError.With('ENOENT', oldPath, 'rename');
+                throw withErrno('ENOENT');
             const ino = oldDirList[_old.base];
             if (ino != this._ids.get(oldPath))
                 err(`Ino mismatch while renaming ${oldPath} to ${newPath}`);
@@ -349,19 +349,16 @@ export class StoreFS extends FileSystem {
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
             if ((_new.dir + '/').startsWith(oldPath + '/'))
-                throw new ErrnoError(Errno.EBUSY, _old.dir);
+                throw withErrno('EBUSY');
             // Add newPath to parent's directory listing.
             const sameParent = _new.dir === _old.dir;
             // Prevent us from re-grabbing the same directory listing, which still contains `old_path.base.`
-            const newDirNode = sameParent ? oldDirNode : this.findInodeSync(tx, _new.dir, 'rename');
-            const newDirList = sameParent
-                ? oldDirList
-                : decodeDirListing((_b = tx.getSync(newDirNode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', _new.dir, 'rename')));
+            const newDirNode = sameParent ? oldDirNode : this.findInodeSync(tx, _new.dir);
+            const newDirList = sameParent ? oldDirList : decodeDirListing((_b = tx.getSync(newDirNode.data)) !== null && _b !== void 0 ? _b : _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
-                // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const existing = new Inode((_c = tx.getSync(newDirList[_new.base])) !== null && _c !== void 0 ? _c : _throw(ErrnoError.With('ENOENT', newPath, 'rename')));
+                const existing = new Inode((_c = tx.getSync(newDirList[_new.base])) !== null && _c !== void 0 ? _c : _throw(withErrno('ENOENT')));
                 if (!existing.toStats().isFile())
-                    throw ErrnoError.With('EPERM', newPath, 'rename');
+                    throw withErrno('EISDIR');
                 tx.removeSync(existing.data);
                 tx.removeSync(newDirList[_new.base]);
             }
@@ -384,7 +381,7 @@ export class StoreFS extends FileSystem {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_7, this.transaction(), true);
-            return await this.findInode(tx, path, 'stat');
+            return await this.findInode(tx, path);
         }
         catch (e_7) {
             env_7.error = e_7;
@@ -400,7 +397,7 @@ export class StoreFS extends FileSystem {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_8, this.transaction(), false);
-            return this.findInodeSync(tx, path, 'stat');
+            return this.findInodeSync(tx, path);
         }
         catch (e_8) {
             env_8.error = e_8;
@@ -414,10 +411,10 @@ export class StoreFS extends FileSystem {
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_9, this.transaction(), true);
-            const inode = await this.findInode(tx, path, 'touch');
+            const inode = await this.findInode(tx, path);
             if (inode.update(metadata)) {
                 this._add(inode.ino, path);
-                tx.setSync(inode.ino, serialize(inode));
+                tx.setSync(inode.ino, inode);
             }
             await tx.commit();
         }
@@ -435,10 +432,10 @@ export class StoreFS extends FileSystem {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_10, this.transaction(), false);
-            const inode = this.findInodeSync(tx, path, 'touch');
+            const inode = this.findInodeSync(tx, path);
             if (inode.update(metadata)) {
                 this._add(inode.ino, path);
-                tx.setSync(inode.ino, serialize(inode));
+                tx.setSync(inode.ino, inode);
             }
             tx.commitSync();
         }
@@ -452,11 +449,11 @@ export class StoreFS extends FileSystem {
     }
     async createFile(path, options) {
         options.mode |= S_IFREG;
-        return await this.commitNew(path, options, new Uint8Array(), 'createFile');
+        return await this.commitNew(path, options, new Uint8Array());
     }
     createFileSync(path, options) {
         options.mode |= S_IFREG;
-        return this.commitNewSync(path, options, new Uint8Array(), 'createFile');
+        return this.commitNewSync(path, options, new Uint8Array());
     }
     async unlink(path) {
         return this.remove(path, false);
@@ -465,32 +462,30 @@ export class StoreFS extends FileSystem {
         this.removeSync(path, false);
     }
     async rmdir(path) {
-        if ((await this.readdir(path)).length) {
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        }
+        if ((await this.readdir(path)).length)
+            throw withErrno('ENOTEMPTY');
         await this.remove(path, true);
     }
     rmdirSync(path) {
-        if (this.readdirSync(path).length) {
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        }
+        if (this.readdirSync(path).length)
+            throw withErrno('ENOTEMPTY');
         this.removeSync(path, true);
     }
     async mkdir(path, options) {
         options.mode |= S_IFDIR;
-        return await this.commitNew(path, options, encodeUTF8('{}'), 'mkdir');
+        return await this.commitNew(path, options, encodeUTF8('{}'));
     }
     mkdirSync(path, options) {
         options.mode |= S_IFDIR;
-        return this.commitNewSync(path, options, encodeUTF8('{}'), 'mkdir');
+        return this.commitNewSync(path, options, encodeUTF8('{}'));
     }
     async readdir(path) {
         var _a;
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_11, this.transaction(), true);
-            const node = await this.findInode(tx, path, 'readdir');
-            return Object.keys(decodeDirListing((_a = (await tx.get(node.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'readdir'))));
+            const node = await this.findInode(tx, path);
+            return Object.keys(decodeDirListing((_a = (await tx.get(node.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT'))));
         }
         catch (e_11) {
             env_11.error = e_11;
@@ -507,8 +502,8 @@ export class StoreFS extends FileSystem {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_12, this.transaction(), false);
-            const node = this.findInodeSync(tx, path, 'readdir');
-            return Object.keys(decodeDirListing((_a = tx.getSync(node.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'readdir'))));
+            const node = this.findInodeSync(tx, path);
+            return Object.keys(decodeDirListing((_a = tx.getSync(node.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT'))));
         }
         catch (e_12) {
             env_12.error = e_12;
@@ -521,17 +516,23 @@ export class StoreFS extends FileSystem {
     /**
      * Updated the inode and data node at `path`
      */
-    async sync(path, data, metadata) {
+    async sync() { }
+    /**
+     * Updated the inode and data node at `path`
+     */
+    syncSync() { }
+    async link(target, link) {
+        var _a;
         const env_13 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_13, this.transaction(), true);
-            const inode = await this.findInode(tx, path, 'sync');
-            if (data)
-                await tx.set(inode.data, data);
-            if (inode.update(metadata)) {
-                this._add(inode.ino, path);
-                await tx.set(inode.ino, serialize(inode));
-            }
+            const newDir = dirname(link), newDirNode = await this.findInode(tx, newDir), listing = decodeDirListing((_a = (await tx.get(newDirNode.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
+            const inode = await this.findInode(tx, target);
+            inode.nlink++;
+            listing[basename(link)] = inode.ino;
+            this._add(inode.ino, link);
+            await tx.set(inode.ino, inode);
+            await tx.set(newDirNode.data, encodeDirListing(listing));
             await tx.commit();
         }
         catch (e_13) {
@@ -544,20 +545,18 @@ export class StoreFS extends FileSystem {
                 await result_7;
         }
     }
-    /**
-     * Updated the inode and data node at `path`
-     */
-    syncSync(path, data, metadata) {
+    linkSync(target, link) {
+        var _a;
         const env_14 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_14, this.transaction(), false);
-            const inode = this.findInodeSync(tx, path, 'sync');
-            if (data)
-                tx.setSync(inode.data, data);
-            if (inode.update(metadata)) {
-                this._add(inode.ino, path);
-                tx.setSync(inode.ino, serialize(inode));
-            }
+            const newDir = dirname(link), newDirNode = this.findInodeSync(tx, newDir), listing = decodeDirListing((_a = tx.getSync(newDirNode.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
+            const inode = this.findInodeSync(tx, target);
+            inode.nlink++;
+            listing[basename(link)] = inode.ino;
+            this._add(inode.ino, link);
+            tx.setSync(inode.ino, inode);
+            tx.setSync(newDirNode.data, encodeDirListing(listing));
             tx.commitSync();
         }
         catch (e_14) {
@@ -568,19 +567,19 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_14);
         }
     }
-    async link(target, link) {
+    async read(path, buffer, offset, end) {
         var _a;
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_15, this.transaction(), true);
-            const newDir = dirname(link), newDirNode = await this.findInode(tx, newDir, 'link'), listing = decodeDirListing((_a = (await tx.get(newDirNode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', newDir, 'link')));
-            const inode = await this.findInode(tx, target, 'link');
-            inode.nlink++;
-            listing[basename(link)] = inode.ino;
-            this._add(inode.ino, link);
-            await tx.set(inode.ino, serialize(inode));
-            await tx.set(newDirNode.data, encodeDirListing(listing));
-            await tx.commit();
+            const inode = await this.findInode(tx, path);
+            if (inode.size == 0)
+                return;
+            const data = (_a = (await tx.get(inode.data, offset, end))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA'));
+            const _ = tx.flag('partial') ? data : data.subarray(offset, end);
+            if (_.byteLength > buffer.byteLength)
+                err(`Trying to place ${_.byteLength} bytes into a ${buffer.byteLength} byte buffer on read`);
+            buffer.set(_);
         }
         catch (e_15) {
             env_15.error = e_15;
@@ -592,80 +591,34 @@ export class StoreFS extends FileSystem {
                 await result_8;
         }
     }
-    linkSync(target, link) {
+    readSync(path, buffer, offset, end) {
         var _a;
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_16, this.transaction(), false);
-            const newDir = dirname(link), newDirNode = this.findInodeSync(tx, newDir, 'link'), listing = decodeDirListing((_a = tx.getSync(newDirNode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', newDir, 'link')));
-            const inode = this.findInodeSync(tx, target, 'link');
-            inode.nlink++;
-            listing[basename(link)] = inode.ino;
-            this._add(inode.ino, link);
-            tx.setSync(inode.ino, serialize(inode));
-            tx.setSync(newDirNode.data, encodeDirListing(listing));
-            tx.commitSync();
-        }
-        catch (e_16) {
-            env_16.error = e_16;
-            env_16.hasError = true;
-        }
-        finally {
-            __disposeResources(env_16);
-        }
-    }
-    async read(path, buffer, offset, end) {
-        var _a;
-        const env_17 = { stack: [], error: void 0, hasError: false };
-        try {
-            const tx = __addDisposableResource(env_17, this.transaction(), true);
-            const inode = await this.findInode(tx, path, 'read');
+            const inode = this.findInodeSync(tx, path);
             if (inode.size == 0)
                 return;
-            const data = (_a = (await tx.get(inode.data, offset, end))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
+            const data = (_a = tx.getSync(inode.data, offset, end)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA'));
             const _ = tx.flag('partial') ? data : data.subarray(offset, end);
             if (_.byteLength > buffer.byteLength)
                 err(`Trying to place ${_.byteLength} bytes into a ${buffer.byteLength} byte buffer on read`);
             buffer.set(_);
         }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
-        }
-        finally {
-            const result_9 = __disposeResources(env_17);
-            if (result_9)
-                await result_9;
-        }
-    }
-    readSync(path, buffer, offset, end) {
-        var _a;
-        const env_18 = { stack: [], error: void 0, hasError: false };
-        try {
-            const tx = __addDisposableResource(env_18, this.transaction(), false);
-            const inode = this.findInodeSync(tx, path, 'read');
-            if (inode.size == 0)
-                return;
-            const data = (_a = tx.getSync(inode.data, offset, end)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
-            const _ = tx.flag('partial') ? data : data.subarray(offset, end);
-            if (_.byteLength > buffer.byteLength)
-                err(`Trying to place ${_.byteLength} bytes into a ${buffer.byteLength} byte buffer on read`);
-            buffer.set(_);
-        }
-        catch (e_18) {
-            env_18.error = e_18;
-            env_18.hasError = true;
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
         }
         finally {
-            __disposeResources(env_18);
+            __disposeResources(env_16);
         }
     }
     async write(path, data, offset) {
         var _a;
-        const env_19 = { stack: [], error: void 0, hasError: false };
+        const env_17 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_19, this.transaction(), true);
-            const inode = await this.findInode(tx, path, 'write');
+            const tx = __addDisposableResource(env_17, this.transaction(), true);
+            const inode = await this.findInode(tx, path);
             let buffer = data;
             if (!tx.flag('partial')) {
                 buffer = extendBuffer((_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : new Uint8Array(), offset + data.byteLength);
@@ -676,22 +629,22 @@ export class StoreFS extends FileSystem {
             this._add(inode.ino, path);
             await tx.commit();
         }
-        catch (e_19) {
-            env_19.error = e_19;
-            env_19.hasError = true;
+        catch (e_17) {
+            env_17.error = e_17;
+            env_17.hasError = true;
         }
         finally {
-            const result_10 = __disposeResources(env_19);
-            if (result_10)
-                await result_10;
+            const result_9 = __disposeResources(env_17);
+            if (result_9)
+                await result_9;
         }
     }
     writeSync(path, data, offset) {
         var _a;
-        const env_20 = { stack: [], error: void 0, hasError: false };
+        const env_18 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_20, this.transaction(), false);
-            const inode = this.findInodeSync(tx, path, 'write');
+            const tx = __addDisposableResource(env_18, this.transaction(), false);
+            const inode = this.findInodeSync(tx, path);
             let buffer = data;
             if (!tx.flag('partial')) {
                 buffer = extendBuffer((_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : new Uint8Array(), offset + data.byteLength);
@@ -702,12 +655,12 @@ export class StoreFS extends FileSystem {
             this._add(inode.ino, path);
             tx.commitSync();
         }
-        catch (e_20) {
-            env_20.error = e_20;
-            env_20.hasError = true;
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
         }
         finally {
-            __disposeResources(env_20);
+            __disposeResources(env_18);
         }
     }
     /**
@@ -721,69 +674,69 @@ export class StoreFS extends FileSystem {
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     async checkRoot() {
-        const env_21 = { stack: [], error: void 0, hasError: false };
+        const env_19 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_21, this.transaction(), true);
+            const tx = __addDisposableResource(env_19, this.transaction(), true);
             if (await tx.get(rootIno))
                 return;
             const inode = new Inode({ ino: rootIno, data: 1, mode: 0o777 | S_IFDIR });
             await tx.set(inode.data, encodeUTF8('{}'));
             this._add(rootIno, '/');
-            await tx.set(rootIno, serialize(inode));
+            await tx.set(rootIno, inode);
             await tx.commit();
         }
-        catch (e_21) {
-            env_21.error = e_21;
-            env_21.hasError = true;
+        catch (e_19) {
+            env_19.error = e_19;
+            env_19.hasError = true;
         }
         finally {
-            const result_11 = __disposeResources(env_21);
-            if (result_11)
-                await result_11;
+            const result_10 = __disposeResources(env_19);
+            if (result_10)
+                await result_10;
         }
     }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     checkRootSync() {
-        const env_22 = { stack: [], error: void 0, hasError: false };
+        const env_20 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_22, this.transaction(), false);
+            const tx = __addDisposableResource(env_20, this.transaction(), false);
             if (tx.getSync(rootIno))
                 return;
             const inode = new Inode({ ino: rootIno, data: 1, mode: 0o777 | S_IFDIR });
             tx.setSync(inode.data, encodeUTF8('{}'));
             this._add(rootIno, '/');
-            tx.setSync(rootIno, serialize(inode));
+            tx.setSync(rootIno, inode);
             tx.commitSync();
         }
-        catch (e_22) {
-            env_22.error = e_22;
-            env_22.hasError = true;
+        catch (e_20) {
+            env_20.error = e_20;
+            env_20.hasError = true;
         }
         finally {
-            __disposeResources(env_22);
+            __disposeResources(env_20);
         }
     }
     /**
      * Populates the `_ids` and `_paths` maps with all existing files stored in the underlying `Store`.
      */
     async _populate() {
-        const env_23 = { stack: [], error: void 0, hasError: false };
+        const env_21 = { stack: [], error: void 0, hasError: false };
         try {
             if (this._initialized) {
                 warn('Attempted to populate tables after initialization');
                 return;
             }
             debug('Populating tables with existing store metadata');
-            const tx = __addDisposableResource(env_23, this.transaction(), true);
+            const tx = __addDisposableResource(env_21, this.transaction(), true);
             const rootData = await tx.get(rootIno);
             if (!rootData) {
                 notice('Store does not have a root inode');
                 const inode = new Inode({ ino: rootIno, data: 1, mode: 0o777 | S_IFDIR });
                 await tx.set(inode.data, encodeUTF8('{}'));
                 this._add(rootIno, '/');
-                await tx.set(rootIno, serialize(inode));
+                await tx.set(rootIno, inode);
                 await tx.commit();
                 return;
             }
@@ -830,27 +783,63 @@ export class StoreFS extends FileSystem {
             }
             debug(`Added ${i} existing inode(s) from store`);
         }
-        catch (e_23) {
-            env_23.error = e_23;
-            env_23.hasError = true;
+        catch (e_21) {
+            env_21.error = e_21;
+            env_21.hasError = true;
         }
         finally {
-            const result_12 = __disposeResources(env_23);
-            if (result_12)
-                await result_12;
+            const result_11 = __disposeResources(env_21);
+            if (result_11)
+                await result_11;
         }
     }
+    /**
+     * Find an inode without using the ID tables
+     */
+    async _findInode(tx, path, visited = new Set()) {
+        var _a, _b, _c;
+        if (visited.has(path))
+            throw crit(withErrno('EIO', 'Infinite loop detected while finding inode'));
+        visited.add(path);
+        if (path == '/')
+            return new Inode((_a = (await tx.get(rootIno))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENODATA')));
+        const { dir: parent, base: filename } = parse(path);
+        const inode = await this._findInode(tx, parent, visited);
+        const dirList = decodeDirListing((_b = (await tx.get(inode.data))) !== null && _b !== void 0 ? _b : _throw(withErrno('ENODATA')));
+        if (!(filename in dirList))
+            throw withErrno('ENOENT');
+        return new Inode((_c = (await tx.get(dirList[filename]))) !== null && _c !== void 0 ? _c : _throw(withErrno('ENODATA')));
+    }
+    /**
+     * Find an inode without using the ID tables
+     */
+    _findInodeSync(tx, path, visited = new Set()) {
+        var _a, _b, _c;
+        if (visited.has(path))
+            throw crit(withErrno('EIO', 'Infinite loop detected while finding inode'));
+        visited.add(path);
+        if (path == '/')
+            return new Inode((_a = tx.getSync(rootIno)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
+        const { dir: parent, base: filename } = parse(path);
+        const inode = this._findInodeSync(tx, parent, visited);
+        const dir = decodeDirListing((_b = tx.getSync(inode.data)) !== null && _b !== void 0 ? _b : _throw(withErrno('ENODATA')));
+        if (!(filename in dir))
+            throw withErrno('ENOENT');
+        return new Inode((_c = tx.getSync(dir[filename])) !== null && _c !== void 0 ? _c : _throw(withErrno('ENODATA')));
+    }
     /**
      * Finds the Inode of `path`.
      * @param path The path to look up.
      * @todo memoize/cache
      */
-    async findInode(tx, path, syscall) {
+    async findInode(tx, path) {
         var _a;
+        if (this.attributes.has('no_id_tables'))
+            return await this._findInode(tx, path);
         const ino = this._ids.get(path);
         if (ino === undefined)
-            throw ErrnoError.With('ENOENT', path, syscall);
-        return new Inode((_a = (await tx.get(ino))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, syscall)));
+            throw withErrno('ENOENT');
+        return new Inode((_a = (await tx.get(ino))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
     }
     /**
      * Finds the Inode of `path`.
@@ -858,23 +847,23 @@ export class StoreFS extends FileSystem {
      * @return The Inode of the path p.
      * @todo memoize/cache
      */
-    findInodeSync(tx, path, syscall) {
+    findInodeSync(tx, path) {
         var _a;
+        if (this.attributes.has('no_id_tables'))
+            return this._findInodeSync(tx, path);
         const ino = this._ids.get(path);
         if (ino === undefined)
-            throw ErrnoError.With('ENOENT', path, syscall);
-        return new Inode((_a = tx.getSync(ino)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, syscall)));
+            throw withErrno('ENOENT');
+        return new Inode((_a = tx.getSync(ino)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
     }
-    /**
-     * Allocates a new ID and adds the ID/path
-     */
-    allocNew(path, syscall) {
+    /** Allocates a new ID and adds the ID/path */
+    allocNew(path) {
         var _a;
         (_a = this._lastID) !== null && _a !== void 0 ? _a : (this._lastID = Math.max(...this._paths.keys()));
         this._lastID += 2;
         const id = this._lastID;
         if (id > size_max)
-            throw err(new ErrnoError(Errno.ENOSPC, 'No IDs available', path, syscall), { fs: this });
+            throw err(withErrno('ENOSPC', 'No IDs available'));
         this._add(id, path);
         return id;
     }
@@ -885,9 +874,9 @@ export class StoreFS extends FileSystem {
      * @param options The options to create the new file with.
      * @param data The data to store at the file's data node.
      */
-    async commitNew(path, options, data, syscall) {
+    async commitNew(path, options, data) {
         var _a;
-        const env_24 = { stack: [], error: void 0, hasError: false };
+        const env_22 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
@@ -895,23 +884,24 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root if path is '/'.
             */
             if (path == '/')
-                throw ErrnoError.With('EEXIST', path, syscall);
-            const tx = __addDisposableResource(env_24, this.transaction(), true);
+                throw withErrno('EEXIST');
+            const tx = __addDisposableResource(env_22, this.transaction(), true);
             const { dir: parentPath, base: fname } = parse(path);
-            const parent = await this.findInode(tx, parentPath, syscall);
-            const listing = decodeDirListing((_a = (await tx.get(parent.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parentPath, syscall)));
+            const parent = await this.findInode(tx, parentPath);
+            const listing = decodeDirListing((_a = (await tx.get(parent.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
             // Check if file already exists.
             if (listing[fname])
-                throw ErrnoError.With('EEXIST', path, syscall);
-            const id = this.allocNew(path, syscall);
+                throw withErrno('EEXIST');
+            const id = this.allocNew(path);
             // Commit data.
             const inode = new Inode({
                 ...options,
                 ino: id,
                 data: id + 1,
                 size: data.byteLength,
+                nlink: 1,
             });
-            await tx.set(inode.ino, serialize(inode));
+            await tx.set(inode.ino, inode);
             await tx.set(inode.data, data);
             // Update and commit parent directory listing.
             listing[fname] = inode.ino;
@@ -919,14 +909,14 @@ export class StoreFS extends FileSystem {
             await tx.commit();
             return inode;
         }
-        catch (e_24) {
-            env_24.error = e_24;
-            env_24.hasError = true;
+        catch (e_22) {
+            env_22.error = e_22;
+            env_22.hasError = true;
         }
         finally {
-            const result_13 = __disposeResources(env_24);
-            if (result_13)
-                await result_13;
+            const result_12 = __disposeResources(env_22);
+            if (result_12)
+                await result_12;
         }
     }
     /**
@@ -937,9 +927,9 @@ export class StoreFS extends FileSystem {
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    commitNewSync(path, options, data, syscall) {
+    commitNewSync(path, options, data) {
         var _a;
-        const env_25 = { stack: [], error: void 0, hasError: false };
+        const env_23 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
@@ -947,36 +937,35 @@ export class StoreFS extends FileSystem {
                 we will create a file with name '' in root if path is '/'.
             */
             if (path == '/')
-                throw ErrnoError.With('EEXIST', path, syscall);
-            const tx = __addDisposableResource(env_25, this.transaction(), false);
+                throw withErrno('EEXIST');
+            const tx = __addDisposableResource(env_23, this.transaction(), false);
             const { dir: parentPath, base: fname } = parse(path);
-            const parent = this.findInodeSync(tx, parentPath, syscall);
-            const listing = decodeDirListing((_a = tx.getSync(parent.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parentPath, syscall)));
-            // Check if file already exists.
+            const parent = this.findInodeSync(tx, parentPath);
+            const listing = decodeDirListing((_a = tx.getSync(parent.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
             if (listing[fname])
-                throw ErrnoError.With('EEXIST', path, syscall);
-            const id = this.allocNew(path, syscall);
-            // Commit data.
+                throw withErrno('EEXIST');
+            const id = this.allocNew(path);
             const inode = new Inode({
                 ...options,
                 ino: id,
                 data: id + 1,
                 size: data.byteLength,
+                nlink: 1,
             });
             // Update and commit parent directory listing.
-            tx.setSync(inode.ino, serialize(inode));
+            tx.setSync(inode.ino, inode);
             tx.setSync(inode.data, data);
             listing[fname] = inode.ino;
             tx.setSync(parent.data, encodeDirListing(listing));
             tx.commitSync();
             return inode;
         }
-        catch (e_25) {
-            env_25.error = e_25;
-            env_25.hasError = true;
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
         }
         finally {
-            __disposeResources(env_25);
+            __disposeResources(env_23);
         }
     }
     /**
@@ -986,23 +975,21 @@ export class StoreFS extends FileSystem {
      */
     async remove(path, isDir) {
         var _a, _b;
-        const env_26 = { stack: [], error: void 0, hasError: false };
+        const env_24 = { stack: [], error: void 0, hasError: false };
         try {
-            const syscall = isDir ? 'rmdir' : 'unlink';
-            const tx = __addDisposableResource(env_26, this.transaction(), true);
-            const { dir: parent, base: fileName } = parse(path), parentNode = await this.findInode(tx, parent, syscall), listing = decodeDirListing((_a = (await tx.get(parentNode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall)));
-            if (!listing[fileName]) {
-                throw ErrnoError.With('ENOENT', path, syscall);
-            }
+            const tx = __addDisposableResource(env_24, this.transaction(), true);
+            const { dir: parent, base: fileName } = parse(path), parentNode = await this.findInode(tx, parent), listing = decodeDirListing((_a = (await tx.get(parentNode.data))) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT')));
+            if (!listing[fileName])
+                throw withErrno('ENOENT');
             const ino = listing[fileName];
-            const inode = new Inode((_b = (await tx.get(ino))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', path, syscall)));
+            const inode = new Inode((_b = (await tx.get(ino))) !== null && _b !== void 0 ? _b : _throw(withErrno('ENOENT')));
             delete listing[fileName];
             if (!isDir && isDirectory(inode))
-                throw ErrnoError.With('EISDIR', path, syscall);
+                throw withErrno('EISDIR');
             await tx.set(parentNode.data, encodeDirListing(listing));
             if (inode.nlink > 1) {
                 inode.update({ nlink: inode.nlink - 1 });
-                await tx.set(inode.ino, serialize(inode));
+                await tx.set(inode.ino, inode);
             }
             else {
                 await tx.remove(inode.data);
@@ -1011,14 +998,14 @@ export class StoreFS extends FileSystem {
             }
             await tx.commit();
         }
-        catch (e_26) {
-            env_26.error = e_26;
-            env_26.hasError = true;
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
         }
         finally {
-            const result_14 = __disposeResources(env_26);
-            if (result_14)
-                await result_14;
+            const result_13 = __disposeResources(env_24);
+            if (result_13)
+                await result_13;
         }
     }
     /**
@@ -1028,22 +1015,20 @@ export class StoreFS extends FileSystem {
      */
     removeSync(path, isDir) {
         var _a, _b;
-        const env_27 = { stack: [], error: void 0, hasError: false };
+        const env_25 = { stack: [], error: void 0, hasError: false };
         try {
-            const syscall = isDir ? 'rmdir' : 'unlink';
-            const tx = __addDisposableResource(env_27, this.transaction(), false);
-            const { dir: parent, base: fileName } = parse(path), parentNode = this.findInodeSync(tx, parent, syscall), listing = decodeDirListing((_a = tx.getSync(parentNode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall))), ino = listing[fileName];
+            const tx = __addDisposableResource(env_25, this.transaction(), false);
+            const { dir: parent, base: fileName } = parse(path), parentNode = this.findInodeSync(tx, parent), listing = decodeDirListing((_a = tx.getSync(parentNode.data)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT'))), ino = listing[fileName];
             if (!ino)
-                throw ErrnoError.With('ENOENT', path, syscall);
-            const inode = new Inode((_b = tx.getSync(ino)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', path, syscall)));
+                throw withErrno('ENOENT');
+            const inode = new Inode((_b = tx.getSync(ino)) !== null && _b !== void 0 ? _b : _throw(withErrno('ENOENT')));
             delete listing[fileName];
-            if (!isDir && isDirectory(inode)) {
-                throw ErrnoError.With('EISDIR', path, syscall);
-            }
+            if (!isDir && isDirectory(inode))
+                throw withErrno('EISDIR');
             tx.setSync(parentNode.data, encodeDirListing(listing));
             if (inode.nlink > 1) {
                 inode.update({ nlink: inode.nlink - 1 });
-                tx.setSync(inode.ino, serialize(inode));
+                tx.setSync(inode.ino, inode);
             }
             else {
                 tx.removeSync(inode.data);
@@ -1052,12 +1037,12 @@ export class StoreFS extends FileSystem {
             }
             tx.commitSync();
         }
-        catch (e_27) {
-            env_27.error = e_27;
-            env_27.hasError = true;
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
         }
         finally {
-            __disposeResources(env_27);
+            __disposeResources(env_25);
         }
     }
 }