@zenfs/core 1.7.2 → 1.8.0

package/dist/backends/store/fs.js

@@ -50,22 +50,23 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { credentials } from '../../credentials.js';
-import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID } from '../../vfs/constants.js';
-import { basename, dirname, parse, resolve } from '../../vfs/path.js';
+import { randomInt, serialize } from 'utilium';
 import { Errno, ErrnoError } from '../../error.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
+import { _throw, canary, 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';
-import { decodeDirListing, encodeDirListing, encodeUTF8, randomBigInt } from '../../utils.js';
-import { serialize } from 'utilium';
 const maxInodeAllocTries = 5;
 /**
  * A file system which uses a key-value store.
  *
  * We use a unique ID for each node in the file system. The root node has a fixed ID.
- * @todo Introduce Node ID caching.
- * @todo Check modes.
+ *
+ * @todo Introduce Node ID caching?
+ * @todo Check modes?
  * @internal
  */
 export class StoreFS extends FileSystem {
@@ -88,6 +89,7 @@ export class StoreFS extends FileSystem {
             features: ['setid'],
         };
     }
+    /* node:coverage disable */
     /**
      * Delete all contents stored in the file system.
      * @deprecated
@@ -106,16 +108,128 @@ export class StoreFS extends FileSystem {
         // Root always exists.
         this.checkRootSync();
     }
+    /* node:coverage enable */
     /**
-     * @todo Make rename compatible with the cache.
+     * Load an index into the StoreFS.
+     * You *must* manually add non-directory files
      */
-    async rename(oldPath, newPath) {
+    async loadIndex(index) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_1, this.store.transaction(), true);
+            const dirs = index.directories();
+            for (const [path, inode] of index) {
+                await tx.set(inode.ino, serialize(inode));
+                if (dirs.has(path))
+                    await tx.set(inode.data, encodeDirListing(dirs.get(path)));
+            }
+            await tx.commit();
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    /**
+     * Load an index into the StoreFS.
+     * You *must* manually add non-directory files
+     */
+    loadIndexSync(index) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_2, this.store.transaction(), false);
+            const dirs = index.directories();
+            for (const [path, inode] of index) {
+                tx.setSync(inode.ino, serialize(inode));
+                if (dirs.has(path))
+                    tx.setSync(inode.data, encodeDirListing(dirs.get(path)));
+            }
+            tx.commitSync();
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    async createIndex() {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const index = new Index();
+            const tx = __addDisposableResource(env_3, this.store.transaction(), true);
+            const queue = [['/', 0]];
+            const silence = canary();
+            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));
+                    for (const [name, id] of Object.entries(dir)) {
+                        queue.push([join(path, name), id]);
+                    }
+                }
+            }
+            silence();
+            return index;
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_3);
+            if (result_2)
+                await result_2;
+        }
+    }
+    createIndexSync() {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const index = new Index();
+            const tx = __addDisposableResource(env_4, this.store.transaction(), false);
+            const queue = [['/', 0]];
+            const silence = canary();
+            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));
+                    for (const [name, id] of Object.entries(dir)) {
+                        queue.push([join(path, name), id]);
+                    }
+                }
+            }
+            silence();
+            return index;
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    }
+    /**
+     * @todo Make rename compatible with the cache.
+     */
+    async rename(oldPath, newPath) {
+        var _a, _b, _c;
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_5, this.store.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(await this.get(tx, oldDirNode.data, _old.dir, 'rename'));
+            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]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -133,10 +247,10 @@ export class StoreFS extends FileSystem {
             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(await this.get(tx, newDirNode.data, _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')));
             if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const existing = new Inode(await this.get(tx, newDirList[_new.base], newPath, 'rename'));
+                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()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
@@ -149,23 +263,24 @@ export class StoreFS extends FileSystem {
             await tx.set(newDirNode.data, encodeDirListing(newDirList));
             await tx.commit();
         }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
         }
         finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
+            const result_3 = __disposeResources(env_5);
+            if (result_3)
+                await result_3;
         }
     }
     renameSync(oldPath, newPath) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
+        var _a, _b, _c;
+        const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_2, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_6, this.store.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(this.getSync(tx, oldDirNode.data, _old.dir, 'rename'));
+            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]) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -183,10 +298,10 @@ export class StoreFS extends FileSystem {
             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(this.getSync(tx, newDirNode.data, _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')));
             if (newDirList[_new.base]) {
                 // If it's a file, delete it, if it's a directory, throw a permissions error.
-                const existing = new Inode(this.getSync(tx, newDirList[_new.base], newPath, 'rename'));
+                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()) {
                     throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
@@ -199,84 +314,86 @@ export class StoreFS extends FileSystem {
             tx.setSync(newDirNode.data, encodeDirListing(newDirList));
             tx.commitSync();
         }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
         }
         finally {
-            __disposeResources(env_2);
+            __disposeResources(env_6);
         }
     }
     async stat(path) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_3, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_7, this.store.transaction(), true);
             return (await this.findInode(tx, path, 'stat')).toStats();
         }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
         }
         finally {
-            const result_2 = __disposeResources(env_3);
-            if (result_2)
-                await result_2;
+            const result_4 = __disposeResources(env_7);
+            if (result_4)
+                await result_4;
         }
     }
     statSync(path) {
-        const env_4 = { stack: [], error: void 0, hasError: false };
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_4, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_8, this.store.transaction(), false);
             return this.findInodeSync(tx, path, 'stat').toStats();
         }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            __disposeResources(env_4);
+            __disposeResources(env_8);
         }
     }
-    async createFile(path, flag, mode) {
-        const node = await this.commitNew(path, S_IFREG, mode, new Uint8Array(), 'createFile');
+    async createFile(path, flag, mode, options) {
+        const node = await this.commitNew(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
         return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
     }
-    createFileSync(path, flag, mode) {
-        const node = this.commitNewSync(path, S_IFREG, mode, new Uint8Array(), 'createFile');
+    createFileSync(path, flag, mode, options) {
+        const node = this.commitNewSync(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
         return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
     }
     async openFile(path, flag) {
-        const env_5 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_5, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_9, this.store.transaction(), true);
             const node = await this.findInode(tx, path, 'openFile');
-            const data = await this.get(tx, node.data, path, 'openFile');
+            const data = (_a = (await tx.get(node.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'openFile'));
             return new PreloadFile(this, path, flag, node.toStats(), data);
         }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
         }
         finally {
-            const result_3 = __disposeResources(env_5);
-            if (result_3)
-                await result_3;
+            const result_5 = __disposeResources(env_9);
+            if (result_5)
+                await result_5;
         }
     }
     openFileSync(path, flag) {
-        const env_6 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_6, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_10, this.store.transaction(), false);
             const node = this.findInodeSync(tx, path, 'openFile');
-            const data = this.getSync(tx, node.data, path, 'openFile');
+            const data = (_a = tx.getSync(node.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
             return new PreloadFile(this, path, flag, node.toStats(), data);
         }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
         }
         finally {
-            __disposeResources(env_6);
+            __disposeResources(env_10);
         }
     }
     async unlink(path) {
@@ -297,152 +414,238 @@ export class StoreFS extends FileSystem {
         }
         this.removeSync(path, true, 'rmdir');
     }
-    async mkdir(path, mode) {
-        await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
+    async mkdir(path, mode, options) {
+        await this.commitNew(path, S_IFDIR, { mode, ...options }, encodeUTF8('{}'), 'mkdir');
     }
-    mkdirSync(path, mode) {
-        this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'), 'mkdir');
+    mkdirSync(path, mode, options) {
+        this.commitNewSync(path, S_IFDIR, { mode, ...options }, encodeUTF8('{}'), 'mkdir');
     }
     async readdir(path) {
-        const env_7 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_7, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_11, this.store.transaction(), true);
             const node = await this.findInode(tx, path, 'readdir');
-            return Object.keys(decodeDirListing(await this.get(tx, node.data, path, 'readdir')));
+            return Object.keys(decodeDirListing((_a = (await tx.get(node.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'readdir'))));
         }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
         }
         finally {
-            const result_4 = __disposeResources(env_7);
-            if (result_4)
-                await result_4;
+            const result_6 = __disposeResources(env_11);
+            if (result_6)
+                await result_6;
         }
     }
     readdirSync(path) {
-        const env_8 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_8, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_12, this.store.transaction(), false);
             const node = this.findInodeSync(tx, path, 'readdir');
-            return Object.keys(decodeDirListing(this.getSync(tx, node.data, path, 'readdir')));
+            return Object.keys(decodeDirListing((_a = tx.getSync(node.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'readdir'))));
         }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
         }
         finally {
-            __disposeResources(env_8);
+            __disposeResources(env_12);
         }
     }
     /**
      * 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, stats) {
-        const env_9 = { stack: [], error: void 0, hasError: false };
+    async sync(path, data, metadata) {
+        const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_9, this.store.transaction(), true);
-            // We use _findInode because we actually need the INode id.
-            const fileInodeId = await this._findInode(tx, path, 'sync'), fileInode = new Inode(await this.get(tx, fileInodeId, path, 'sync')), inodeChanged = fileInode.update(stats);
-            // Sync data.
-            await tx.set(fileInode.data, data);
-            // Sync metadata.
-            if (inodeChanged) {
-                await tx.set(fileInodeId, serialize(fileInode));
-            }
+            const tx = __addDisposableResource(env_13, this.store.transaction(), true);
+            const inode = await this.findInode(tx, path, 'sync');
+            if (data)
+                await tx.set(inode.data, data);
+            if (inode.update(metadata))
+                await tx.set(inode.ino, serialize(inode));
             await tx.commit();
         }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
         }
         finally {
-            const result_5 = __disposeResources(env_9);
-            if (result_5)
-                await result_5;
+            const result_7 = __disposeResources(env_13);
+            if (result_7)
+                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, stats) {
-        const env_10 = { stack: [], error: void 0, hasError: false };
+    syncSync(path, data, metadata) {
+        const env_14 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_10, this.store.transaction(), false);
-            // We use _findInode because we actually need the INode id.
-            const fileInodeId = this._findInodeSync(tx, path, 'sync'), fileInode = new Inode(this.getSync(tx, fileInodeId, path, 'sync')), inodeChanged = fileInode.update(stats);
-            // Sync data.
-            tx.setSync(fileInode.data, data);
-            // Sync metadata.
-            if (inodeChanged) {
-                tx.setSync(fileInodeId, serialize(fileInode));
-            }
+            const tx = __addDisposableResource(env_14, this.store.transaction(), false);
+            const inode = this.findInodeSync(tx, path, 'sync');
+            if (data)
+                tx.setSync(inode.data, data);
+            if (inode.update(metadata))
+                tx.setSync(inode.ino, serialize(inode));
             tx.commitSync();
         }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
         }
         finally {
-            __disposeResources(env_10);
+            __disposeResources(env_14);
         }
     }
     async link(target, link) {
-        const env_11 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_11, this.store.transaction(), true);
-            const newDir = dirname(link), newDirNode = await this.findInode(tx, newDir, 'link'), listing = decodeDirListing(await this.get(tx, newDirNode.data, newDir, 'link'));
-            const ino = await this._findInode(tx, target, 'link');
-            const node = new Inode(await this.get(tx, ino, target, 'link'));
-            node.nlink++;
-            listing[basename(link)] = ino;
-            tx.setSync(ino, serialize(node));
+            const tx = __addDisposableResource(env_15, this.store.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();
         }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
         }
         finally {
-            const result_6 = __disposeResources(env_11);
-            if (result_6)
-                await result_6;
+            const result_8 = __disposeResources(env_15);
+            if (result_8)
+                await result_8;
         }
     }
     linkSync(target, link) {
-        const env_12 = { stack: [], error: void 0, hasError: false };
+        var _a;
+        const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_12, this.store.transaction(), false);
-            const newDir = dirname(link), newDirNode = this.findInodeSync(tx, newDir, 'link'), listing = decodeDirListing(this.getSync(tx, newDirNode.data, newDir, 'link'));
-            const ino = this._findInodeSync(tx, target, 'link');
-            const node = new Inode(this.getSync(tx, ino, target, 'link'));
-            node.nlink++;
-            listing[basename(link)] = ino;
-            tx.setSync(ino, serialize(node));
+            const tx = __addDisposableResource(env_16, this.store.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;
+            tx.setSync(inode.ino, serialize(inode));
             tx.setSync(newDirNode.data, encodeDirListing(listing));
             tx.commitSync();
         }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
         }
         finally {
-            __disposeResources(env_12);
+            __disposeResources(env_16);
+        }
+    }
+    /**
+     * Used by lazy file
+     * @internal
+     */
+    async read(path, offset, length) {
+        var _a;
+        const env_17 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_17, this.store.transaction(), true);
+            const inode = await this.findInode(tx, path, 'read');
+            const buffer = (_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
+            return buffer.slice(offset, offset + length);
+        }
+        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;
+        }
+    }
+    /**
+     * Used by lazy file
+     * @internal
+     */
+    readSync(path, offset, length) {
+        var _a;
+        const env_18 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_18, this.store.transaction(), false);
+            const inode = this.findInodeSync(tx, path, 'read');
+            const buffer = (_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
+            return buffer.slice(offset, offset + length);
+        }
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
+        }
+        finally {
+            __disposeResources(env_18);
+        }
+    }
+    /**
+     * Used by lazy file
+     * @internal
+     */
+    async write(path, data, offset) {
+        const env_19 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_19, this.store.transaction(), true);
+            const inode = await this.findInode(tx, path, 'write');
+            const buffer = await tx.get(inode.data);
+            buffer.set(data, offset);
+            await this.sync(path, buffer, inode);
+        }
+        catch (e_19) {
+            env_19.error = e_19;
+            env_19.hasError = true;
+        }
+        finally {
+            const result_10 = __disposeResources(env_19);
+            if (result_10)
+                await result_10;
+        }
+    }
+    /**
+     * Used by lazy file
+     * @internal
+     */
+    writeSync(path, data, offset) {
+        const env_20 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_20, this.store.transaction(), false);
+            const inode = this.findInodeSync(tx, path, 'write');
+            inode.update({ mtimeMs: Date.now() });
+            const buffer = tx.getSync(inode.data);
+            buffer.set(data, offset);
+            tx.setSync(inode.ino, serialize(inode));
+            tx.setSync(inode.data, buffer);
+            tx.commitSync();
+        }
+        catch (e_20) {
+            env_20.error = e_20;
+            env_20.hasError = true;
+        }
+        finally {
+            __disposeResources(env_20);
         }
     }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     async checkRoot() {
-        const env_13 = { stack: [], error: void 0, hasError: false };
+        const env_21 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_13, this.store.transaction(), true);
-            if (await tx.get(rootIno)) {
+            const tx = __addDisposableResource(env_21, this.store.transaction(), true);
+            if (await tx.get(rootIno))
                 return;
-            }
             // Create new inode. o777, owned by root:root
             const inode = new Inode();
             inode.ino = rootIno;
@@ -452,26 +655,25 @@ export class StoreFS extends FileSystem {
             await tx.set(rootIno, serialize(inode));
             await tx.commit();
         }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
+        catch (e_21) {
+            env_21.error = e_21;
+            env_21.hasError = true;
         }
         finally {
-            const result_7 = __disposeResources(env_13);
-            if (result_7)
-                await result_7;
+            const result_11 = __disposeResources(env_21);
+            if (result_11)
+                await result_11;
         }
     }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     checkRootSync() {
-        const env_14 = { stack: [], error: void 0, hasError: false };
+        const env_22 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_14, this.store.transaction(), false);
-            if (tx.getSync(rootIno)) {
+            const tx = __addDisposableResource(env_22, this.store.transaction(), false);
+            if (tx.getSync(rootIno))
                 return;
-            }
             // Create new inode, mode o777, owned by root:root
             const inode = new Inode();
             inode.ino = rootIno;
@@ -481,12 +683,12 @@ export class StoreFS extends FileSystem {
             tx.setSync(rootIno, serialize(inode));
             tx.commitSync();
         }
-        catch (e_14) {
-            env_14.error = e_14;
-            env_14.hasError = true;
+        catch (e_22) {
+            env_22.error = e_22;
+            env_22.hasError = true;
         }
         finally {
-            __disposeResources(env_14);
+            __disposeResources(env_22);
         }
     }
     /**
@@ -496,6 +698,7 @@ export class StoreFS extends FileSystem {
      *   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);
         }
@@ -504,8 +707,8 @@ export class StoreFS extends FileSystem {
             return rootIno;
         }
         const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/' ? new Inode(await this.get(tx, rootIno, parent, syscall)) : await this.findInode(tx, parent, syscall, visited);
-        const dirList = decodeDirListing(await this.get(tx, inode.data, parent, syscall));
+        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);
         }
@@ -519,6 +722,7 @@ export class StoreFS extends FileSystem {
      * @return string The ID of the file's inode in the file system.
      */
     _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);
         }
@@ -527,8 +731,8 @@ export class StoreFS extends FileSystem {
             return rootIno;
         }
         const { dir: parent, base: filename } = parse(path);
-        const inode = parent == '/' ? new Inode(this.getSync(tx, rootIno, parent, syscall)) : this.findInodeSync(tx, parent, syscall, visited);
-        const dir = decodeDirListing(this.getSync(tx, inode.data, parent, syscall));
+        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);
         }
@@ -540,8 +744,9 @@ export class StoreFS extends FileSystem {
      * @todo memoize/cache
      */
     async findInode(tx, path, syscall, visited = new Set()) {
+        var _a;
         const ino = await this._findInode(tx, path, syscall, visited);
-        return new Inode(await this.get(tx, ino, path, syscall));
+        return new Inode((_a = (await tx.get(ino))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, syscall)));
     }
     /**
      * Finds the Inode of `path`.
@@ -550,34 +755,9 @@ export class StoreFS extends FileSystem {
      * @todo memoize/cache
      */
     findInodeSync(tx, path, syscall, visited = new Set()) {
+        var _a;
         const ino = this._findInodeSync(tx, path, syscall, visited);
-        return new Inode(this.getSync(tx, ino, path, syscall));
-    }
-    /**
-     * Given an ID, retrieves the corresponding data.
-     * @param tx The transaction to use.
-     * @param path The corresponding path to the file (used for error messages).
-     * @param id The ID to look up.
-     */
-    async get(tx, id, path, syscall) {
-        const data = await tx.get(id);
-        if (!data) {
-            throw ErrnoError.With('ENOENT', path, syscall);
-        }
-        return data;
-    }
-    /**
-     * Given an ID, retrieves the corresponding data.
-     * @param tx The transaction to use.
-     * @param path The corresponding path to the file (used for error messages).
-     * @param id The ID to look up.
-     */
-    getSync(tx, id, path, syscall) {
-        const data = tx.getSync(id);
-        if (!data) {
-            throw ErrnoError.With('ENOENT', path, syscall);
-        }
-        return data;
+        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
@@ -585,7 +765,7 @@ export class StoreFS extends FileSystem {
      */
     async allocNew(tx, path, syscall) {
         for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomBigInt();
+            const ino = randomInt(0, size_max);
             if (await tx.get(ino)) {
                 continue;
             }
@@ -600,7 +780,7 @@ export class StoreFS extends FileSystem {
      */
     allocNewSync(tx, path, syscall) {
         for (let i = 0; i < maxInodeAllocTries; i++) {
-            const ino = randomBigInt();
+            const ino = randomInt(0, size_max);
             if (tx.getSync(ino)) {
                 continue;
             }
@@ -616,8 +796,9 @@ export class StoreFS extends FileSystem {
      * @param mode The mode to create the new file with.
      * @param data The data to store at the file's data node.
      */
-    async commitNew(path, type, mode, data, syscall) {
-        const env_15 = { stack: [], error: void 0, hasError: false };
+    async commitNew(path, type, options, data, syscall) {
+        var _a;
+        const env_23 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
@@ -627,10 +808,10 @@ export class StoreFS extends FileSystem {
             if (path == '/') {
                 throw ErrnoError.With('EEXIST', path, syscall);
             }
-            const tx = __addDisposableResource(env_15, this.store.transaction(), true);
+            const tx = __addDisposableResource(env_23, this.store.transaction(), true);
             const { dir: parentPath, base: fname } = parse(path);
             const parent = await this.findInode(tx, parentPath, syscall);
-            const listing = decodeDirListing(await this.get(tx, parent.data, 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]) {
                 throw ErrnoError.With('EEXIST', path, syscall);
@@ -639,9 +820,9 @@ export class StoreFS extends FileSystem {
             const inode = new Inode();
             inode.ino = await this.allocNew(tx, path, syscall);
             inode.data = await this.allocNew(tx, path, syscall);
-            inode.mode = mode | type;
-            inode.uid = parent.mode & S_ISUID ? parent.uid : credentials.uid;
-            inode.gid = parent.mode & S_ISGID ? parent.gid : credentials.gid;
+            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;
             await tx.set(inode.ino, serialize(inode));
             await tx.set(inode.data, data);
@@ -651,14 +832,14 @@ export class StoreFS extends FileSystem {
             await tx.commit();
             return inode;
         }
-        catch (e_15) {
-            env_15.error = e_15;
-            env_15.hasError = true;
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
         }
         finally {
-            const result_8 = __disposeResources(env_15);
-            if (result_8)
-                await result_8;
+            const result_12 = __disposeResources(env_23);
+            if (result_12)
+                await result_12;
         }
     }
     /**
@@ -670,8 +851,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, type, mode, data, syscall) {
-        const env_16 = { stack: [], error: void 0, hasError: false };
+    commitNewSync(path, type, options, data, syscall) {
+        var _a;
+        const env_24 = { stack: [], error: void 0, hasError: false };
         try {
             /*
                 The root always exists.
@@ -681,10 +863,10 @@ export class StoreFS extends FileSystem {
             if (path == '/') {
                 throw ErrnoError.With('EEXIST', path, syscall);
             }
-            const tx = __addDisposableResource(env_16, this.store.transaction(), false);
+            const tx = __addDisposableResource(env_24, this.store.transaction(), false);
             const { dir: parentPath, base: fname } = parse(path);
             const parent = this.findInodeSync(tx, parentPath, syscall);
-            const listing = decodeDirListing(this.getSync(tx, parent.data, 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]) {
                 throw ErrnoError.With('EEXIST', path, syscall);
@@ -694,9 +876,9 @@ export class StoreFS extends FileSystem {
             inode.ino = this.allocNewSync(tx, path, syscall);
             inode.data = this.allocNewSync(tx, path, syscall);
             inode.size = data.length;
-            inode.mode = mode | type;
-            inode.uid = parent.mode & S_ISUID ? parent.uid : credentials.uid;
-            inode.gid = parent.mode & S_ISGID ? parent.gid : credentials.gid;
+            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;
             // Update and commit parent directory listing.
             tx.setSync(inode.ino, serialize(inode));
             tx.setSync(inode.data, data);
@@ -705,12 +887,12 @@ export class StoreFS extends FileSystem {
             tx.commitSync();
             return inode;
         }
-        catch (e_16) {
-            env_16.error = e_16;
-            env_16.hasError = true;
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
         }
         finally {
-            __disposeResources(env_16);
+            __disposeResources(env_24);
         }
     }
     /**
@@ -720,16 +902,17 @@ export class StoreFS extends FileSystem {
      * @todo Update mtime.
      */
     async remove(path, isDir, syscall) {
-        const env_17 = { stack: [], error: void 0, hasError: false };
+        var _a, _b;
+        const env_25 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_17, this.store.transaction(), true);
-            const { dir: parent, base: fileName } = parse(path), parentNode = await this.findInode(tx, parent, syscall), listing = decodeDirListing(await this.get(tx, parentNode.data, parent, syscall));
+            const tx = __addDisposableResource(env_25, this.store.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');
             }
             const fileIno = listing[fileName];
             // Get file inode.
-            const fileNode = new Inode(await this.get(tx, fileIno, path, syscall));
+            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()) {
@@ -744,14 +927,14 @@ export class StoreFS extends FileSystem {
             // Success.
             await tx.commit();
         }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
         }
         finally {
-            const result_9 = __disposeResources(env_17);
-            if (result_9)
-                await result_9;
+            const result_13 = __disposeResources(env_25);
+            if (result_13)
+                await result_13;
         }
     }
     /**
@@ -761,15 +944,16 @@ export class StoreFS extends FileSystem {
      * @todo Update mtime.
      */
     removeSync(path, isDir, syscall) {
-        const env_18 = { stack: [], error: void 0, hasError: false };
+        var _a, _b;
+        const env_26 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_18, this.store.transaction(), false);
-            const { dir: parent, base: fileName } = parse(path), parentNode = this.findInodeSync(tx, parent, syscall), listing = decodeDirListing(this.getSync(tx, parentNode.data, parent, syscall)), fileIno = listing[fileName];
+            const tx = __addDisposableResource(env_26, this.store.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');
             }
             // Get file inode.
-            const fileNode = new Inode(this.getSync(tx, fileIno, path, syscall));
+            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()) {
@@ -785,12 +969,12 @@ export class StoreFS extends FileSystem {
             // Success.
             tx.commitSync();
         }
-        catch (e_18) {
-            env_18.error = e_18;
-            env_18.hasError = true;
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
         }
         finally {
-            __disposeResources(env_18);
+            __disposeResources(env_26);
         }
     }
 }