@zenfs/core 1.11.4 → 2.1.0

package/dist/backends/store/fs.js

@@ -50,17 +50,17 @@ 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, serialize } 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 { LazyFile } from '../../internal/file.js';
 import { Index } from '../../internal/file_index.js';
 import { FileSystem } from '../../internal/filesystem.js';
-import { __inode_sz, Inode, rootIno } from '../../internal/inode.js';
-import { crit, debug, err, log_deprecated, notice, warn } from '../../internal/log.js';
-import { decodeDirListing, encodeDirListing, encodeUTF8 } from '../../utils.js';
-import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID, size_max } from '../../vfs/constants.js';
-import { basename, dirname, join, parse, relative } from '../../vfs/path.js';
+import { Inode, isDirectory, rootIno } from '../../internal/inode.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';
 import { WrappedTransaction } from './store.js';
 /**
  * A file system which uses a `Store`
@@ -132,8 +132,8 @@ export class StoreFS extends FileSystem {
         this._initialized = true;
     }
     constructor(store) {
-        var _a, _b;
-        super((_a = store.id) !== null && _a !== void 0 ? _a : 0x6b766673, store.name);
+        var _a, _b, _c;
+        super((_a = store.type) !== null && _a !== void 0 ? _a : 0x6b766673, store.name);
         this.store = store;
         /**
          * A map of paths to inode IDs
@@ -146,9 +146,10 @@ export class StoreFS extends FileSystem {
          */
         this._paths = new Map([[0, new Set('/')]]);
         this._initialized = false;
-        this.attributes.set('setid');
-        store._fs = this;
-        debug(this.name + ': supports features: ' + ((_b = this.store.flags) === null || _b === void 0 ? void 0 : _b.join(', ')));
+        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(', ')));
     }
     /**
      * @experimental
@@ -160,26 +161,6 @@ export class StoreFS extends FileSystem {
             freeSpace: 0,
         });
     }
-    /* node:coverage disable */
-    /**
-     * Delete all contents stored in the file system.
-     * @deprecated
-     */
-    async empty() {
-        log_deprecated('StoreFS#empty');
-        // Root always exists.
-        await this.checkRoot();
-    }
-    /**
-     * Delete all contents stored in the file system.
-     * @deprecated
-     */
-    emptySync() {
-        log_deprecated('StoreFS#emptySync');
-        // Root always exists.
-        this.checkRootSync();
-    }
-    /* node:coverage enable */
     /**
      * Load an index into the StoreFS.
      * You *must* manually add non-directory files
@@ -191,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)));
             }
@@ -218,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)));
             }
@@ -239,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]);
                     }
@@ -271,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]);
                     }
@@ -304,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}`);
@@ -317,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]);
             }
@@ -357,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}`);
@@ -370,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]);
             }
@@ -405,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')).toStats();
+            return await this.findInode(tx, path);
         }
         catch (e_7) {
             env_7.error = e_7;
@@ -421,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').toStats();
+            return this.findInodeSync(tx, path);
         }
         catch (e_8) {
             env_8.error = e_8;
@@ -431,20 +407,16 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_8);
         }
     }
-    async createFile(path, flag, mode, options) {
-        const node = await this.commitNew(path, { mode: mode | S_IFREG, ...options }, new Uint8Array(), 'createFile');
-        return new LazyFile(this, path, flag, node.toStats());
-    }
-    createFileSync(path, flag, mode, options) {
-        const node = this.commitNewSync(path, { mode: mode | S_IFREG, ...options }, new Uint8Array(), 'createFile');
-        return new LazyFile(this, path, flag, node.toStats());
-    }
-    async openFile(path, flag) {
+    async touch(path, metadata) {
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_9, this.transaction(), true);
-            const node = await this.findInode(tx, path, 'openFile');
-            return new LazyFile(this, path, flag, node.toStats());
+            const inode = await this.findInode(tx, path);
+            if (inode.update(metadata)) {
+                this._add(inode.ino, path);
+                tx.setSync(inode.ino, inode);
+            }
+            await tx.commit();
         }
         catch (e_9) {
             env_9.error = e_9;
@@ -456,12 +428,16 @@ export class StoreFS extends FileSystem {
                 await result_5;
         }
     }
-    openFileSync(path, flag) {
+    touchSync(path, metadata) {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_10, this.transaction(), false);
-            const node = this.findInodeSync(tx, path, 'openFile');
-            return new LazyFile(this, path, flag, node.toStats());
+            const inode = this.findInodeSync(tx, path);
+            if (inode.update(metadata)) {
+                this._add(inode.ino, path);
+                tx.setSync(inode.ino, inode);
+            }
+            tx.commitSync();
         }
         catch (e_10) {
             env_10.error = e_10;
@@ -471,6 +447,14 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_10);
         }
     }
+    async createFile(path, options) {
+        options.mode |= S_IFREG;
+        return await this.commitNew(path, options, new Uint8Array());
+    }
+    createFileSync(path, options) {
+        options.mode |= S_IFREG;
+        return this.commitNewSync(path, options, new Uint8Array());
+    }
     async unlink(path) {
         return this.remove(path, false);
     }
@@ -478,30 +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, mode, options) {
-        await this.commitNew(path, { mode: mode | S_IFDIR, ...options }, encodeUTF8('{}'), 'mkdir');
+    async mkdir(path, options) {
+        options.mode |= S_IFDIR;
+        return await this.commitNew(path, options, encodeUTF8('{}'));
     }
-    mkdirSync(path, mode, options) {
-        this.commitNewSync(path, { mode: mode | S_IFDIR, ...options }, encodeUTF8('{}'), 'mkdir');
+    mkdirSync(path, options) {
+        options.mode |= S_IFDIR;
+        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;
@@ -518,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;
@@ -531,19 +515,24 @@ export class StoreFS extends FileSystem {
     }
     /**
      * Updated the inode and data node at `path`
-     * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
      */
-    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) {
@@ -556,21 +545,18 @@ export class StoreFS extends FileSystem {
                 await result_7;
         }
     }
-    /**
-     * Updated the inode and data node at `path`
-     * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
-     */
-    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) {
@@ -581,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;
@@ -605,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);
@@ -686,27 +626,25 @@ export class StoreFS extends FileSystem {
                 offset = 0;
             }
             await tx.set(inode.data, buffer, offset);
-            inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
             this._add(inode.ino, path);
-            await tx.set(inode.ino, serialize(inode));
             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);
@@ -714,17 +652,15 @@ export class StoreFS extends FileSystem {
                 offset = 0;
             }
             tx.setSync(inode.data, buffer, offset);
-            inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
             this._add(inode.ino, path);
-            tx.setSync(inode.ino, serialize(inode));
             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);
         }
     }
     /**
@@ -738,73 +674,73 @@ 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;
             }
-            if (rootData.length != __inode_sz) {
+            if (rootData.length < sizeof(Inode)) {
                 crit('Store contains an invalid root inode. Refusing to populate tables');
                 return;
             }
@@ -823,7 +759,7 @@ export class StoreFS extends FileSystem {
                     warn('Store is missing data for inode: ' + ino);
                     continue;
                 }
-                if (inodeData.length != __inode_sz) {
+                if (inodeData.length < sizeof(Inode)) {
                     warn(`Invalid inode size for ino ${ino}: ${inodeData.length}`);
                     continue;
                 }
@@ -847,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`.
@@ -875,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;
     }
@@ -902,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.
@@ -912,25 +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,
-                mode: options.mode,
                 size: data.byteLength,
-                uid: parent.mode & S_ISUID ? parent.uid : options.uid,
-                gid: parent.mode & S_ISGID ? parent.gid : options.gid,
+                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;
@@ -938,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;
         }
     }
     /**
@@ -956,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.
@@ -966,122 +937,112 @@ 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,
-                mode: options.mode,
                 size: data.byteLength,
-                uid: parent.mode & S_ISUID ? parent.uid : options.uid,
-                gid: parent.mode & S_ISGID ? parent.gid : options.gid,
+                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);
         }
     }
     /**
      * Remove all traces of `path` from the file system.
      * @param path The path to remove from the file system.
      * @param isDir Does the path belong to a directory, or a file?
-     * @todo Update mtime.
      */
     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 fileIno = listing[fileName];
-            // Get file inode.
-            const fileNode = new Inode((_b = (await tx.get(fileIno))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', path, syscall)));
-            // Remove from directory listing of parent.
+            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(withErrno('ENOENT')));
             delete listing[fileName];
-            if (!isDir && fileNode.toStats().isDirectory())
-                throw ErrnoError.With('EISDIR', path, syscall);
+            if (!isDir && isDirectory(inode))
+                throw withErrno('EISDIR');
             await tx.set(parentNode.data, encodeDirListing(listing));
-            if (--fileNode.nlink < 1) {
-                // remove file
-                await tx.remove(fileNode.data);
-                await tx.remove(fileIno);
-                this._remove(fileIno);
+            if (inode.nlink > 1) {
+                inode.update({ nlink: inode.nlink - 1 });
+                await tx.set(inode.ino, inode);
+            }
+            else {
+                await tx.remove(inode.data);
+                await tx.remove(ino);
+                this._remove(ino);
             }
-            // Success.
             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;
         }
     }
     /**
      * Remove all traces of `path` from the file system.
      * @param path The path to remove from the file system.
      * @param isDir Does the path belong to a directory, or a file?
-     * @todo Update mtime.
      */
     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))), fileIno = listing[fileName];
-            if (!fileIno)
-                throw ErrnoError.With('ENOENT', path, syscall);
-            // Get file inode.
-            const fileNode = new Inode((_b = tx.getSync(fileIno)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', path, syscall)));
-            // Remove from directory listing of parent.
+            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 withErrno('ENOENT');
+            const inode = new Inode((_b = tx.getSync(ino)) !== null && _b !== void 0 ? _b : _throw(withErrno('ENOENT')));
             delete listing[fileName];
-            if (!isDir && fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('EISDIR', path, syscall);
-            }
-            // Update directory listing.
+            if (!isDir && isDirectory(inode))
+                throw withErrno('EISDIR');
             tx.setSync(parentNode.data, encodeDirListing(listing));
-            if (--fileNode.nlink < 1) {
-                // remove file
-                tx.removeSync(fileNode.data);
-                tx.removeSync(fileIno);
-                this._remove(fileIno);
+            if (inode.nlink > 1) {
+                inode.update({ nlink: inode.nlink - 1 });
+                tx.setSync(inode.ino, inode);
+            }
+            else {
+                tx.removeSync(inode.data);
+                tx.removeSync(ino);
+                this._remove(ino);
             }
-            // Success.
             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);
         }
     }
 }