@zenfs/core 1.8.8 → 1.9.1

package/dist/backends/store/fs.js

@@ -50,16 +50,18 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { randomInt, serialize } from 'utilium';
-import { Errno, ErrnoError } from '../../error.js';
-import { LazyFile } from '../../file.js';
-import { FileSystem } from '../../filesystem.js';
-import { _throw, canary, decodeDirListing, encodeDirListing, encodeUTF8, growBuffer } from '../../utils.js';
+import { _throw, canary, serialize } 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, resolve } from '../../vfs/path.js';
-import { Index } from './file_index.js';
-import { Inode, rootIno } from './inode.js';
-const maxInodeAllocTries = 5;
+import { basename, dirname, join, parse, relative } from '../../vfs/path.js';
+import { WrappedTransaction } from './store.js';
 /**
  * A file system which uses a key-value store.
  *
@@ -70,24 +72,85 @@ const maxInodeAllocTries = 5;
  * @internal
  */
 export class StoreFS extends FileSystem {
+    /**
+     * Gets the first path associated with an inode
+     */
+    _path(id) {
+        var _a;
+        const [path] = (_a = this._paths.get(id)) !== null && _a !== void 0 ? _a : [];
+        return path;
+    }
+    /**
+     * Add a inode/path pair
+     */
+    _add(ino, path) {
+        if (!this._paths.has(ino))
+            this._paths.set(ino, new Set());
+        this._paths.get(ino).add(path);
+        this._ids.set(path, ino);
+    }
+    /**
+     * Remove a inode/path pair
+     */
+    _remove(ino) {
+        var _a;
+        for (const path of (_a = this._paths.get(ino)) !== null && _a !== void 0 ? _a : []) {
+            this._ids.delete(path);
+        }
+        this._paths.delete(ino);
+    }
+    /**
+     * Move paths in the tables
+     */
+    _move(from, to) {
+        const toMove = [];
+        for (const [path, ino] of this._ids) {
+            const rel = relative(from, path);
+            if (rel.startsWith('..'))
+                continue;
+            let newKey = join(to, rel);
+            if (newKey.endsWith('/'))
+                newKey = newKey.slice(0, -1);
+            toMove.push({ oldKey: path, newKey, ino });
+        }
+        for (const { oldKey, newKey, ino } of toMove) {
+            this._ids.delete(oldKey);
+            this._ids.set(newKey, ino);
+            const p = this._paths.get(ino);
+            if (!p) {
+                warn('Missing paths in table for ino ' + ino);
+                continue;
+            }
+            p.delete(oldKey);
+            p.add(newKey);
+        }
+    }
     async ready() {
-        if (this._initialized) {
+        if (this._initialized)
             return;
-        }
+        this.checkRootSync();
         await this.checkRoot();
+        await this._populate();
         this._initialized = true;
     }
     constructor(store) {
-        super();
+        var _a, _b;
+        super((_a = store.id) !== null && _a !== void 0 ? _a : 0x6b766673, store.name);
         this.store = store;
+        /**
+         * A map of paths to inode IDs
+         * @internal @hidden
+         */
+        this._ids = new Map([['/', 0]]);
+        /**
+         * A map of inode IDs to paths
+         * @internal @hidden
+         */
+        this._paths = new Map([[0, new Set('/')]]);
         this._initialized = false;
-    }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: this.store.name,
-            features: ['setid'],
-        };
+        this.attributes.set('setid');
+        store._fs = this;
+        debug(this.name + ': supports features: ' + ((_b = this.store.flags) === null || _b === void 0 ? void 0 : _b.join(', ')));
     }
     /* node:coverage disable */
     /**
@@ -95,7 +158,7 @@ export class StoreFS extends FileSystem {
      * @deprecated
      */
     async empty() {
-        await this.store.clear();
+        log_deprecated('StoreFS#empty');
         // Root always exists.
         await this.checkRoot();
     }
@@ -104,7 +167,7 @@ export class StoreFS extends FileSystem {
      * @deprecated
      */
     emptySync() {
-        this.store.clearSync();
+        log_deprecated('StoreFS#emptySync');
         // Root always exists.
         this.checkRootSync();
     }
@@ -116,9 +179,10 @@ export class StoreFS extends FileSystem {
     async loadIndex(index) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_1, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_1, this.transaction(), true);
             const dirs = index.directories();
             for (const [path, inode] of index) {
+                this._add(inode.ino, path);
                 await tx.set(inode.ino, serialize(inode));
                 if (dirs.has(path))
                     await tx.set(inode.data, encodeDirListing(dirs.get(path)));
@@ -142,9 +206,10 @@ export class StoreFS extends FileSystem {
     loadIndexSync(index) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_2, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_2, this.transaction(), false);
             const dirs = index.directories();
             for (const [path, inode] of index) {
+                this._add(inode.ino, path);
                 tx.setSync(inode.ino, serialize(inode));
                 if (dirs.has(path))
                     tx.setSync(inode.data, encodeDirListing(dirs.get(path)));
@@ -160,18 +225,19 @@ export class StoreFS extends FileSystem {
         }
     }
     async createIndex() {
+        var _a;
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const index = new Index();
-            const tx = __addDisposableResource(env_3, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_3, this.transaction(), true);
             const queue = [['/', 0]];
-            const silence = canary();
+            const silence = canary(ErrnoError.With('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(await tx.get(inode.data));
+                    const dir = decodeDirListing((_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path)));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
                     }
@@ -191,18 +257,19 @@ export class StoreFS extends FileSystem {
         }
     }
     createIndexSync() {
+        var _a;
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
             const index = new Index();
-            const tx = __addDisposableResource(env_4, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_4, this.transaction(), false);
             const queue = [['/', 0]];
-            const silence = canary();
+            const silence = canary(ErrnoError.With('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(tx.getSync(inode.data));
+                    const dir = decodeDirListing((_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path)));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
                     }
@@ -226,36 +293,35 @@ export class StoreFS extends FileSystem {
         var _a, _b, _c;
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_5, this.store.transaction(), true);
+            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('ENOENT', _old.dir, 'rename')));
-            if (!oldDirList[_old.base]) {
+            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')));
+            if (!oldDirList[_old.base])
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
-            }
             const ino = oldDirList[_old.base];
+            if (ino != this._ids.get(oldPath))
+                err(`Ino mismatch while renaming ${oldPath} to ${newPath}`);
             delete oldDirList[_old.base];
             /*
                 Can't move a folder inside itself.
                 This ensures that the check passes only if `oldPath` is a subpath of `_new.dir`.
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
-            if ((_new.dir + '/').indexOf(oldPath + '/') === 0) {
+            if ((_new.dir + '/').startsWith(oldPath + '/'))
                 throw new ErrnoError(Errno.EBUSY, _old.dir);
-            }
             // 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 : await this.findInode(tx, _new.dir, 'rename');
             const newDirList = sameParent
                 ? oldDirList
-                : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENOENT', _new.dir, 'rename')));
+                : decodeDirListing((_b = (await tx.get(newDirNode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', _new.dir, 'rename')));
             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')));
-                if (!existing.toStats().isFile()) {
+                if (!existing.toStats().isFile())
                     throw ErrnoError.With('EPERM', newPath, 'rename');
-                }
                 await tx.remove(existing.data);
                 await tx.remove(newDirList[_new.base]);
             }
@@ -264,6 +330,7 @@ export class StoreFS extends FileSystem {
             await tx.set(oldDirNode.data, encodeDirListing(oldDirList));
             await tx.set(newDirNode.data, encodeDirListing(newDirList));
             await tx.commit();
+            this._move(oldPath, newPath);
         }
         catch (e_5) {
             env_5.error = e_5;
@@ -279,36 +346,35 @@ export class StoreFS extends FileSystem {
         var _a, _b, _c;
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_6, this.store.transaction(), false);
+            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('ENOENT', _old.dir, 'rename')));
-            if (!oldDirList[_old.base]) {
+            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')));
+            if (!oldDirList[_old.base])
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
-            }
             const ino = oldDirList[_old.base];
+            if (ino != this._ids.get(oldPath))
+                err(`Ino mismatch while renaming ${oldPath} to ${newPath}`);
             delete oldDirList[_old.base];
             /*
                 Can't move a folder inside itself.
                 This ensures that the check passes only if `oldPath` is a subpath of `_new.dir`.
                 We append '/' to avoid matching folders that are a substring of the bottom-most folder in the path.
             */
-            if ((_new.dir + '/').indexOf(oldPath + '/') == 0) {
+            if ((_new.dir + '/').startsWith(oldPath + '/'))
                 throw new ErrnoError(Errno.EBUSY, _old.dir);
-            }
             // 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('ENOENT', _new.dir, 'rename')));
+                : decodeDirListing((_b = tx.getSync(newDirNode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', _new.dir, 'rename')));
             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')));
-                if (!existing.toStats().isFile()) {
+                if (!existing.toStats().isFile())
                     throw ErrnoError.With('EPERM', newPath, 'rename');
-                }
                 tx.removeSync(existing.data);
                 tx.removeSync(newDirList[_new.base]);
             }
@@ -317,6 +383,7 @@ export class StoreFS extends FileSystem {
             tx.setSync(oldDirNode.data, encodeDirListing(oldDirList));
             tx.setSync(newDirNode.data, encodeDirListing(newDirList));
             tx.commitSync();
+            this._move(oldPath, newPath);
         }
         catch (e_6) {
             env_6.error = e_6;
@@ -329,7 +396,7 @@ export class StoreFS extends FileSystem {
     async stat(path) {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_7, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_7, this.transaction(), true);
             return (await this.findInode(tx, path, 'stat')).toStats();
         }
         catch (e_7) {
@@ -345,7 +412,7 @@ export class StoreFS extends FileSystem {
     statSync(path) {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_8, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_8, this.transaction(), false);
             return this.findInodeSync(tx, path, 'stat').toStats();
         }
         catch (e_8) {
@@ -357,19 +424,18 @@ export class StoreFS extends FileSystem {
         }
     }
     async createFile(path, flag, mode, options) {
-        const node = await this.commitNew(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
+        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, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
+        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) {
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_9, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_9, this.transaction(), true);
             const node = await this.findInode(tx, path, 'openFile');
-            //const data = (await tx.get(node.data)) ?? _throw(ErrnoError.With('ENODATA', path, 'openFile'));
             return new LazyFile(this, path, flag, node.toStats());
         }
         catch (e_9) {
@@ -385,9 +451,8 @@ export class StoreFS extends FileSystem {
     openFileSync(path, flag) {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_10, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_10, this.transaction(), false);
             const node = this.findInodeSync(tx, path, 'openFile');
-            //const data = tx.getSync(node.data) ?? _throw(ErrnoError.With('ENODATA', path, 'openFile'));
             return new LazyFile(this, path, flag, node.toStats());
         }
         catch (e_10) {
@@ -399,34 +464,34 @@ export class StoreFS extends FileSystem {
         }
     }
     async unlink(path) {
-        return this.remove(path, false, 'unlink');
+        return this.remove(path, false);
     }
     unlinkSync(path) {
-        this.removeSync(path, false, 'unlink');
+        this.removeSync(path, false);
     }
     async rmdir(path) {
         if ((await this.readdir(path)).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        await this.remove(path, true, 'rmdir');
+        await this.remove(path, true);
     }
     rmdirSync(path) {
         if (this.readdirSync(path).length) {
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
         }
-        this.removeSync(path, true, 'rmdir');
+        this.removeSync(path, true);
     }
     async mkdir(path, mode, options) {
-        await this.commitNew(path, S_IFDIR, { mode, ...options }, encodeUTF8('{}'), 'mkdir');
+        await this.commitNew(path, { mode: mode | S_IFDIR, ...options }, encodeUTF8('{}'), 'mkdir');
     }
     mkdirSync(path, mode, options) {
-        this.commitNewSync(path, S_IFDIR, { mode, ...options }, encodeUTF8('{}'), 'mkdir');
+        this.commitNewSync(path, { mode: mode | S_IFDIR, ...options }, encodeUTF8('{}'), 'mkdir');
     }
     async readdir(path) {
         var _a;
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_11, this.store.transaction(), true);
+            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'))));
         }
@@ -444,7 +509,7 @@ export class StoreFS extends FileSystem {
         var _a;
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_12, this.store.transaction(), false);
+            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'))));
         }
@@ -463,12 +528,14 @@ export class StoreFS extends FileSystem {
     async sync(path, data, metadata) {
         const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_13, this.store.transaction(), true);
+            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))
+            if (inode.update(metadata)) {
+                this._add(inode.ino, path);
                 await tx.set(inode.ino, serialize(inode));
+            }
             await tx.commit();
         }
         catch (e_13) {
@@ -488,12 +555,14 @@ export class StoreFS extends FileSystem {
     syncSync(path, data, metadata) {
         const env_14 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_14, this.store.transaction(), false);
+            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))
+            if (inode.update(metadata)) {
+                this._add(inode.ino, path);
                 tx.setSync(inode.ino, serialize(inode));
+            }
             tx.commitSync();
         }
         catch (e_14) {
@@ -508,14 +577,15 @@ export class StoreFS extends FileSystem {
         var _a;
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_15, this.store.transaction(), true);
+            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;
-            tx.setSync(inode.ino, serialize(inode));
-            tx.setSync(newDirNode.data, encodeDirListing(listing));
-            tx.commitSync();
+            this._add(inode.ino, link);
+            await tx.set(inode.ino, serialize(inode));
+            await tx.set(newDirNode.data, encodeDirListing(listing));
+            await tx.commit();
         }
         catch (e_15) {
             env_15.error = e_15;
@@ -531,11 +601,12 @@ export class StoreFS extends FileSystem {
         var _a;
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_16, this.store.transaction(), false);
+            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();
@@ -552,10 +623,15 @@ export class StoreFS extends FileSystem {
         var _a;
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_17, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_17, this.transaction(), true);
             const inode = await this.findInode(tx, path, 'read');
-            const data = (_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
-            buffer.set(data.subarray(offset, end));
+            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 _ = 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;
@@ -571,10 +647,15 @@ export class StoreFS extends FileSystem {
         var _a;
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_18, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_18, this.transaction(), false);
             const inode = this.findInodeSync(tx, path, 'read');
-            const data = (_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
-            buffer.set(data.subarray(offset, end));
+            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;
@@ -585,15 +666,21 @@ export class StoreFS extends FileSystem {
         }
     }
     async write(path, data, offset) {
+        var _a;
         const env_19 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_19, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_19, this.transaction(), true);
             const inode = await this.findInode(tx, path, 'write');
-            const buffer = growBuffer(await tx.get(inode.data), offset + data.byteLength);
-            buffer.set(data, offset);
-            inode.update({ mtimeMs: Date.now(), size: buffer.byteLength });
+            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);
+                buffer.set(data, offset);
+                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.set(inode.data, buffer);
             await tx.commit();
         }
         catch (e_19) {
@@ -607,15 +694,21 @@ export class StoreFS extends FileSystem {
         }
     }
     writeSync(path, data, offset) {
+        var _a;
         const env_20 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_20, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_20, this.transaction(), false);
             const inode = this.findInodeSync(tx, path, 'write');
-            const buffer = growBuffer(tx.getSync(inode.data), offset + data.byteLength);
-            buffer.set(data, offset);
-            inode.update({ mtimeMs: Date.now(), size: buffer.byteLength });
+            let buffer = data;
+            if (!tx.flag('partial')) {
+                buffer = extendBuffer((_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : new Uint8Array(), offset + data.byteLength);
+                buffer.set(data, offset);
+                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.setSync(inode.data, buffer);
             tx.commitSync();
         }
         catch (e_20) {
@@ -626,21 +719,25 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_20);
         }
     }
+    /**
+     * Wraps a transaction
+     * @internal @hidden
+     */
+    transaction() {
+        return new WrappedTransaction(this.store.transaction(), this);
+    }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     async checkRoot() {
         const env_21 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_21, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_21, this.transaction(), true);
             if (await tx.get(rootIno))
                 return;
-            // Create new inode. o777, owned by root:root
-            const inode = new Inode();
-            inode.ino = rootIno;
-            inode.mode = 0o777 | S_IFDIR;
-            // If the root doesn't exist, the first random ID shouldn't exist either.
+            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.commit();
         }
@@ -660,15 +757,12 @@ export class StoreFS extends FileSystem {
     checkRootSync() {
         const env_22 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_22, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_22, this.transaction(), false);
             if (tx.getSync(rootIno))
                 return;
-            // Create new inode, mode o777, owned by root:root
-            const inode = new Inode();
-            inode.ino = rootIno;
-            inode.mode = 0o777 | S_IFDIR;
-            // If the root doesn't exist, the first random ID shouldn't exist either.
+            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.commitSync();
         }
@@ -681,64 +775,90 @@ export class StoreFS extends FileSystem {
         }
     }
     /**
-     * Helper function for findINode.
-     * @param parent The parent directory of the file we are attempting to find.
-     * @param filename The filename of the inode we are attempting to find, minus
-     *   the parent.
-     */
-    async _findInode(tx, path, syscall, visited = new Set()) {
-        var _a, _b;
-        if (visited.has(path)) {
-            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
-        }
-        visited.add(path);
-        if (path == '/') {
-            return rootIno;
-        }
-        const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/'
-            ? new Inode((_a = (await tx.get(rootIno))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall)))
-            : await this.findInode(tx, parent, syscall, visited);
-        const dirList = decodeDirListing((_b = (await tx.get(inode.data))) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', parent, syscall)));
-        if (!(filename in dirList)) {
-            throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);
-        }
-        return dirList[filename];
-    }
-    /**
-     * Helper function for findINode.
-     * @param parent The parent directory of the file we are attempting to find.
-     * @param filename The filename of the inode we are attempting to find, minus
-     *   the parent.
-     * @return string The ID of the file's inode in the file system.
+     * Populates the `_ids` and `_paths` maps with all existing files stored in the underlying `Store`.
      */
-    _findInodeSync(tx, path, syscall, visited = new Set()) {
-        var _a, _b;
-        if (visited.has(path)) {
-            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', path);
+    async _populate() {
+        const env_23 = { 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 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.commit();
+                return;
+            }
+            if (rootData.length != __inode_sz) {
+                crit('Store contains an invalid root inode. Refusing to populate tables.');
+                return;
+            }
+            // Keep track of directories we have already traversed to avoid loops
+            const visitedDirectories = new Set();
+            let i = 0;
+            // Start BFS from root
+            const queue = [['/', rootIno]];
+            while (queue.length > 0) {
+                i++;
+                const [path, ino] = queue.shift();
+                this._add(ino, path);
+                // Get the inode data from the store
+                const inodeData = await tx.get(ino);
+                if (!inodeData) {
+                    warn('Store is missing data for inode: ' + ino);
+                    continue;
+                }
+                if (inodeData.length != __inode_sz) {
+                    warn(`Invalid inode size for ino ${ino}: ${inodeData.length}`);
+                    continue;
+                }
+                // Parse the raw data into our Inode object
+                const inode = new Inode(inodeData);
+                // If it is a directory and not yet visited, read its directory listing
+                if ((inode.mode & S_IFDIR) != S_IFDIR || visitedDirectories.has(ino)) {
+                    continue;
+                }
+                visitedDirectories.add(ino);
+                // Grab the directory listing from the store
+                const dirData = await tx.get(inode.data);
+                if (!dirData) {
+                    warn('Store is missing directory data: ' + inode.data);
+                    continue;
+                }
+                const dirListing = decodeDirListing(dirData);
+                for (const [entryName, childIno] of Object.entries(dirListing)) {
+                    queue.push([join(path, entryName), childIno]);
+                }
+            }
+            debug(`Added ${i} existing inode(s) from store`);
         }
-        visited.add(path);
-        if (path == '/') {
-            return rootIno;
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
         }
-        const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/'
-            ? new Inode((_a = tx.getSync(rootIno)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', parent, syscall)))
-            : this.findInodeSync(tx, parent, syscall, visited);
-        const dir = decodeDirListing((_b = tx.getSync(inode.data)) !== null && _b !== void 0 ? _b : _throw(ErrnoError.With('ENODATA', parent, syscall)));
-        if (!(filename in dir)) {
-            throw ErrnoError.With('ENOENT', resolve(parent, filename), syscall);
+        finally {
+            const result_12 = __disposeResources(env_23);
+            if (result_12)
+                await result_12;
         }
-        return dir[filename];
     }
     /**
      * Finds the Inode of `path`.
      * @param path The path to look up.
      * @todo memoize/cache
      */
-    async findInode(tx, path, syscall, visited = new Set()) {
+    async findInode(tx, path, syscall) {
         var _a;
-        const ino = await this._findInode(tx, path, syscall, visited);
+        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)));
     }
     /**
@@ -747,76 +867,61 @@ export class StoreFS extends FileSystem {
      * @return The Inode of the path p.
      * @todo memoize/cache
      */
-    findInodeSync(tx, path, syscall, visited = new Set()) {
+    findInodeSync(tx, path, syscall) {
         var _a;
-        const ino = this._findInodeSync(tx, path, syscall, visited);
+        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)));
     }
     /**
-     * Adds a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random id.
-     */
-    async allocNew(tx, path, syscall) {
-        for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomInt(0, size_max);
-            if (await tx.get(ino)) {
-                continue;
-            }
-            return ino;
-        }
-        throw new ErrnoError(Errno.ENOSPC, 'No IDs available', path, syscall);
-    }
-    /**
-     * Creates a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random id.
-     * @return The ino that the data was stored under.
+     * Allocates a new ID and adds the ID/path
      */
-    allocNewSync(tx, path, syscall) {
-        for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomInt(0, size_max);
-            if (tx.getSync(ino)) {
-                continue;
-            }
-            return ino;
-        }
-        throw new ErrnoError(Errno.ENOSPC, 'No IDs available', path, syscall);
+    allocNew(path, syscall) {
+        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 });
+        this._add(id, path);
+        return id;
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.
      * @param path The path to the new file.
-     * @param type The type of the new file.
-     * @param mode The mode to create the new file with.
+     * @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, type, options, data, syscall) {
+    async commitNew(path, options, data, syscall) {
         var _a;
-        const env_23 = { stack: [], error: void 0, hasError: false };
+        const env_24 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
                 If we don't check this prior to taking steps below,
                 we will create a file with name '' in root if path is '/'.
             */
-            if (path == '/') {
+            if (path == '/')
                 throw ErrnoError.With('EEXIST', path, syscall);
-            }
-            const tx = __addDisposableResource(env_23, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_24, 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)));
             // Check if file already exists.
-            if (listing[fname]) {
+            if (listing[fname])
                 throw ErrnoError.With('EEXIST', path, syscall);
-            }
+            const id = this.allocNew(path, syscall);
             // Commit data.
-            const inode = new Inode();
-            inode.ino = await this.allocNew(tx, path, syscall);
-            inode.data = await this.allocNew(tx, path, syscall);
-            inode.mode = options.mode | type;
-            inode.uid = parent.mode & S_ISUID ? parent.uid : options.uid;
-            inode.gid = parent.mode & S_ISGID ? parent.gid : options.gid;
-            inode.size = data.length;
+            const inode = new Inode({
+                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,
+            });
             await tx.set(inode.ino, serialize(inode));
             await tx.set(inode.data, data);
             // Update and commit parent directory listing.
@@ -825,53 +930,52 @@ export class StoreFS extends FileSystem {
             await tx.commit();
             return inode;
         }
-        catch (e_23) {
-            env_23.error = e_23;
-            env_23.hasError = true;
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
         }
         finally {
-            const result_12 = __disposeResources(env_23);
-            if (result_12)
-                await result_12;
+            const result_13 = __disposeResources(env_24);
+            if (result_13)
+                await result_13;
         }
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.
      * @param path The path to the new file.
-     * @param type The type of the new file.
-     * @param mode The mode to create the new file with.
+     * @param options The options to create the new file with.
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    commitNewSync(path, type, options, data, syscall) {
+    commitNewSync(path, options, data, syscall) {
         var _a;
-        const env_24 = { stack: [], error: void 0, hasError: false };
+        const env_25 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
                 If we don't check this prior to taking steps below,
                 we will create a file with name '' in root if path is '/'.
             */
-            if (path == '/') {
+            if (path == '/')
                 throw ErrnoError.With('EEXIST', path, syscall);
-            }
-            const tx = __addDisposableResource(env_24, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_25, 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.
-            if (listing[fname]) {
+            if (listing[fname])
                 throw ErrnoError.With('EEXIST', path, syscall);
-            }
+            const id = this.allocNew(path, syscall);
             // Commit data.
-            const inode = new Inode();
-            inode.ino = this.allocNewSync(tx, path, syscall);
-            inode.data = this.allocNewSync(tx, path, syscall);
-            inode.size = data.length;
-            inode.mode = options.mode | type;
-            inode.uid = parent.mode & S_ISUID ? parent.uid : options.uid;
-            inode.gid = parent.mode & S_ISGID ? parent.gid : options.gid;
+            const inode = new Inode({
+                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,
+            });
             // Update and commit parent directory listing.
             tx.setSync(inode.ino, serialize(inode));
             tx.setSync(inode.data, data);
@@ -880,12 +984,12 @@ export class StoreFS extends FileSystem {
             tx.commitSync();
             return inode;
         }
-        catch (e_24) {
-            env_24.error = e_24;
-            env_24.hasError = true;
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
         }
         finally {
-            __disposeResources(env_24);
+            __disposeResources(env_25);
         }
     }
     /**
@@ -894,40 +998,41 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    async remove(path, isDir, syscall) {
+    async remove(path, isDir) {
         var _a, _b;
-        const env_25 = { stack: [], error: void 0, hasError: false };
+        const env_26 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_25, this.store.transaction(), true);
+            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, 'remove');
+                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.
             delete listing[fileName];
-            if (!isDir && fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('EISDIR', path, 'remove');
-            }
+            if (!isDir && fileNode.toStats().isDirectory())
+                throw ErrnoError.With('EISDIR', path, syscall);
             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);
             }
             // Success.
             await tx.commit();
         }
-        catch (e_25) {
-            env_25.error = e_25;
-            env_25.hasError = true;
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
         }
         finally {
-            const result_13 = __disposeResources(env_25);
-            if (result_13)
-                await result_13;
+            const result_14 = __disposeResources(env_26);
+            if (result_14)
+                await result_14;
         }
     }
     /**
@@ -936,21 +1041,21 @@ export class StoreFS extends FileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    removeSync(path, isDir, syscall) {
+    removeSync(path, isDir) {
         var _a, _b;
-        const env_26 = { stack: [], error: void 0, hasError: false };
+        const env_27 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_26, this.store.transaction(), false);
+            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, 'remove');
-            }
+            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.
             delete listing[fileName];
             if (!isDir && fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('EISDIR', path, 'remove');
+                throw ErrnoError.With('EISDIR', path, syscall);
             }
             // Update directory listing.
             tx.setSync(parentNode.data, encodeDirListing(listing));
@@ -958,16 +1063,17 @@ export class StoreFS extends FileSystem {
                 // remove file
                 tx.removeSync(fileNode.data);
                 tx.removeSync(fileIno);
+                this._remove(fileIno);
             }
             // Success.
             tx.commitSync();
         }
-        catch (e_26) {
-            env_26.error = e_26;
-            env_26.hasError = true;
+        catch (e_27) {
+            env_27.error = e_27;
+            env_27.hasError = true;
         }
         finally {
-            __disposeResources(env_26);
+            __disposeResources(env_27);
         }
     }
 }