@zenfs/core 0.16.4 → 0.17.0

package/dist/backends/store/fs.js

@@ -1,3 +1,48 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { R_OK, S_IFDIR, S_IFREG, W_OK } from '../../emulation/constants.js';
 import { basename, dirname, join, resolve } from '../../emulation/path.js';
 import { Errno, ErrnoError } from '../../error.js';
@@ -55,175 +100,221 @@ export class StoreFS extends FileSystem {
      * @todo Make rename compatible with the cache.
      */
     async rename(oldPath, newPath, cred) {
-        const tx = this.store.transaction(), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
-        // Remove oldPath from parent's directory listing.
-        oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
-        if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', oldPath, 'rename');
-        }
-        if (!oldDirList[oldName]) {
-            throw ErrnoError.With('ENOENT', oldPath, 'rename');
-        }
-        const nodeId = oldDirList[oldName];
-        delete oldDirList[oldName];
-        // Invariant: Can't move a folder inside itself.
-        // This funny little hack ensures that the check passes only if oldPath
-        // is a subpath of newParent. We append '/' to avoid matching folders that
-        // are a substring of the bottom-most folder in the path.
-        if ((newParent + '/').indexOf(oldPath + '/') === 0) {
-            throw new ErrnoError(Errno.EBUSY, oldParent);
-        }
-        // Add newPath to parent's directory listing.
-        let newDirNode, newDirList;
-        if (newParent === oldParent) {
-            // Prevent us from re-grabbing the same directory listing, which still
-            // contains oldName.
-            newDirNode = oldDirNode;
-            newDirList = oldDirList;
-        }
-        else {
-            newDirNode = await this.findINode(tx, newParent);
-            newDirList = await this.getDirListing(tx, newDirNode, newParent);
-        }
-        if (newDirList[newName]) {
-            // If it's a file, delete it.
-            const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
-            if (newNameNode.toStats().isFile()) {
-                try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_1, this.store.transaction(), true);
+            const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
+            // Remove oldPath from parent's directory listing.
+            oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
+            if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', oldPath, 'rename');
+            }
+            if (!oldDirList[oldName]) {
+                throw ErrnoError.With('ENOENT', oldPath, 'rename');
+            }
+            const nodeId = oldDirList[oldName];
+            delete oldDirList[oldName];
+            // Invariant: Can't move a folder inside itself.
+            // This funny little hack ensures that the check passes only if oldPath
+            // is a subpath of newParent. We append '/' to avoid matching folders that
+            // are a substring of the bottom-most folder in the path.
+            if ((newParent + '/').indexOf(oldPath + '/') === 0) {
+                throw new ErrnoError(Errno.EBUSY, oldParent);
+            }
+            // Add newPath to parent's directory listing.
+            let newDirNode, newDirList;
+            if (newParent === oldParent) {
+                // Prevent us from re-grabbing the same directory listing, which still
+                // contains oldName.
+                newDirNode = oldDirNode;
+                newDirList = oldDirList;
+            }
+            else {
+                newDirNode = await this.findINode(tx, newParent);
+                newDirList = await this.getDirListing(tx, newDirNode, newParent);
+            }
+            if (newDirList[newName]) {
+                // If it's a file, delete it.
+                const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
+                if (newNameNode.toStats().isFile()) {
                     await tx.remove(newNameNode.ino);
                     await tx.remove(newDirList[newName]);
                 }
-                catch (e) {
-                    await tx.abort();
-                    throw e;
+                else {
+                    // If it's a directory, throw a permissions error.
+                    throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
             }
-            else {
-                // If it's a directory, throw a permissions error.
-                throw ErrnoError.With('EPERM', newPath, 'rename');
-            }
-        }
-        newDirList[newName] = nodeId;
-        // Commit the two changed directory listings.
-        try {
+            newDirList[newName] = nodeId;
+            // Commit the two changed directory listings.
             await tx.set(oldDirNode.ino, encodeDirListing(oldDirList));
             await tx.set(newDirNode.ino, encodeDirListing(newDirList));
+            await tx.commit();
         }
-        catch (e) {
-            await tx.abort();
-            throw e;
+        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;
         }
-        await tx.commit();
     }
     renameSync(oldPath, newPath, cred) {
-        const tx = this.store.transaction(), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
-        // Remove oldPath from parent's directory listing.
-        oldDirNode = this.findINodeSync(tx, oldParent), oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
-        if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', oldPath, 'rename');
-        }
-        if (!oldDirList[oldName]) {
-            throw ErrnoError.With('ENOENT', oldPath, 'rename');
-        }
-        const ino = oldDirList[oldName];
-        delete oldDirList[oldName];
-        // Invariant: Can't move a folder inside itself.
-        // This funny little hack ensures that the check passes only if oldPath
-        // is a subpath of newParent. We append '/' to avoid matching folders that
-        // are a substring of the bottom-most folder in the path.
-        if ((newParent + '/').indexOf(oldPath + '/') == 0) {
-            throw new ErrnoError(Errno.EBUSY, oldParent);
-        }
-        // Add newPath to parent's directory listing.
-        let newDirNode, newDirList;
-        if (newParent === oldParent) {
-            // Prevent us from re-grabbing the same directory listing, which still
-            // contains oldName.
-            newDirNode = oldDirNode;
-            newDirList = oldDirList;
-        }
-        else {
-            newDirNode = this.findINodeSync(tx, newParent);
-            newDirList = this.getDirListingSync(tx, newDirNode, newParent);
-        }
-        if (newDirList[newName]) {
-            // If it's a file, delete it.
-            const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
-            if (newNameNode.toStats().isFile()) {
-                try {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_2, this.store.transaction(), false);
+            const oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
+            // Remove oldPath from parent's directory listing.
+            oldDirNode = this.findINodeSync(tx, oldParent), oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
+            if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', oldPath, 'rename');
+            }
+            if (!oldDirList[oldName]) {
+                throw ErrnoError.With('ENOENT', oldPath, 'rename');
+            }
+            const ino = oldDirList[oldName];
+            delete oldDirList[oldName];
+            // Invariant: Can't move a folder inside itself.
+            // This funny little hack ensures that the check passes only if oldPath
+            // is a subpath of newParent. We append '/' to avoid matching folders that
+            // are a substring of the bottom-most folder in the path.
+            if ((newParent + '/').indexOf(oldPath + '/') == 0) {
+                throw new ErrnoError(Errno.EBUSY, oldParent);
+            }
+            // Add newPath to parent's directory listing.
+            let newDirNode, newDirList;
+            if (newParent === oldParent) {
+                // Prevent us from re-grabbing the same directory listing, which still
+                // contains oldName.
+                newDirNode = oldDirNode;
+                newDirList = oldDirList;
+            }
+            else {
+                newDirNode = this.findINodeSync(tx, newParent);
+                newDirList = this.getDirListingSync(tx, newDirNode, newParent);
+            }
+            if (newDirList[newName]) {
+                // If it's a file, delete it.
+                const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
+                if (newNameNode.toStats().isFile()) {
                     tx.removeSync(newNameNode.ino);
                     tx.removeSync(newDirList[newName]);
                 }
-                catch (e) {
-                    tx.abortSync();
-                    throw e;
+                else {
+                    // If it's a directory, throw a permissions error.
+                    throw ErrnoError.With('EPERM', newPath, 'rename');
                 }
             }
-            else {
-                // If it's a directory, throw a permissions error.
-                throw ErrnoError.With('EPERM', newPath, 'rename');
-            }
-        }
-        newDirList[newName] = ino;
-        // Commit the two changed directory listings.
-        try {
+            newDirList[newName] = ino;
+            // Commit the two changed directory listings.
             tx.setSync(oldDirNode.ino, encodeDirListing(oldDirList));
             tx.setSync(newDirNode.ino, encodeDirListing(newDirList));
+            tx.commitSync();
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        finally {
+            __disposeResources(env_2);
         }
-        tx.commitSync();
     }
     async stat(path, cred) {
-        const tx = this.store.transaction();
-        const inode = await this.findINode(tx, path);
-        if (!inode) {
-            throw ErrnoError.With('ENOENT', path, 'stat');
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_3, this.store.transaction(), true);
+            const inode = await this.findINode(tx, path);
+            if (!inode) {
+                throw ErrnoError.With('ENOENT', path, 'stat');
+            }
+            const stats = inode.toStats();
+            if (!stats.hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'stat');
+            }
+            return stats;
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
-        const stats = inode.toStats();
-        if (!stats.hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+        finally {
+            const result_2 = __disposeResources(env_3);
+            if (result_2)
+                await result_2;
         }
-        return stats;
     }
     statSync(path, cred) {
-        // Get the inode to the item, convert it into a Stats object.
-        const stats = this.findINodeSync(this.store.transaction(), path).toStats();
-        if (!stats.hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_4, this.store.transaction(), false);
+            // Get the inode to the item, convert it into a Stats object.
+            const stats = this.findINodeSync(tx, path).toStats();
+            if (!stats.hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'stat');
+            }
+            return stats;
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
         }
-        return stats;
     }
     async createFile(path, flag, mode, cred) {
-        const data = new Uint8Array(0);
-        const file = await this.commitNew(this.store.transaction(), path, S_IFREG, mode, cred, data);
-        return new PreloadFile(this, path, flag, file.toStats(), data);
+        const node = await this.commitNew(path, S_IFREG, mode, cred, new Uint8Array(0));
+        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array(0));
     }
     createFileSync(path, flag, mode, cred) {
         this.commitNewSync(path, S_IFREG, mode, cred);
         return this.openFileSync(path, flag, cred);
     }
     async openFile(path, flag, cred) {
-        const tx = this.store.transaction(), node = await this.findINode(tx, path), data = await tx.get(node.ino);
-        if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_5, this.store.transaction(), true);
+            const node = await this.findINode(tx, path), data = await tx.get(node.ino);
+            if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
+                throw ErrnoError.With('EACCES', path, 'openFile');
+            }
+            if (!data) {
+                throw ErrnoError.With('ENOENT', path, 'openFile');
+            }
+            return new PreloadFile(this, path, flag, node.toStats(), data);
         }
-        if (!data) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            const result_3 = __disposeResources(env_5);
+            if (result_3)
+                await result_3;
         }
-        return new PreloadFile(this, path, flag, node.toStats(), data);
     }
     openFileSync(path, flag, cred) {
-        const tx = this.store.transaction(), node = this.findINodeSync(tx, path), data = tx.getSync(node.ino);
-        if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_6, this.store.transaction(), false);
+            const node = this.findINodeSync(tx, path), data = tx.getSync(node.ino);
+            if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
+                throw ErrnoError.With('EACCES', path, 'openFile');
+            }
+            if (!data) {
+                throw ErrnoError.With('ENOENT', path, 'openFile');
+            }
+            return new PreloadFile(this, path, flag, node.toStats(), data);
         }
-        if (!data) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
         }
-        return new PreloadFile(this, path, flag, node.toStats(), data);
     }
     async unlink(path, cred) {
         return this.remove(path, false, cred);
@@ -249,155 +340,220 @@ export class StoreFS extends FileSystem {
         }
     }
     async mkdir(path, mode, cred) {
-        const tx = this.store.transaction(), data = encode('{}');
-        await this.commitNew(tx, path, S_IFDIR, mode, cred, data);
+        await this.commitNew(path, S_IFDIR, mode, cred, encode('{}'));
     }
     mkdirSync(path, mode, cred) {
         this.commitNewSync(path, S_IFDIR, mode, cred, encode('{}'));
     }
     async readdir(path, cred) {
-        const tx = this.store.transaction();
-        const node = await this.findINode(tx, path);
-        if (!node.toStats().hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'readdur');
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_7, this.store.transaction(), true);
+            const node = await this.findINode(tx, path);
+            if (!node.toStats().hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'readdur');
+            }
+            return Object.keys(await this.getDirListing(tx, node, path));
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            const result_4 = __disposeResources(env_7);
+            if (result_4)
+                await result_4;
         }
-        return Object.keys(await this.getDirListing(tx, node, path));
     }
     readdirSync(path, cred) {
-        const tx = this.store.transaction();
-        const node = this.findINodeSync(tx, path);
-        if (!node.toStats().hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'readdir');
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_8, this.store.transaction(), false);
+            const node = this.findINodeSync(tx, path);
+            if (!node.toStats().hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'readdir');
+            }
+            return Object.keys(this.getDirListingSync(tx, node, path));
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
+        }
+        finally {
+            __disposeResources(env_8);
         }
-        return Object.keys(this.getDirListingSync(tx, node, path));
     }
     /**
      * Updated the inode and data node at the given path
      * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
      */
     async sync(path, data, stats) {
-        const tx = this.store.transaction(), 
-        // We use _findInode because we actually need the INode id.
-        fileInodeId = await this._findINode(tx, dirname(path), basename(path)), fileInode = await this.getINode(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+        const env_9 = { 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, dirname(path), basename(path)), fileInode = await this.getINode(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
             // Sync data.
             await tx.set(fileInode.ino, data);
             // Sync metadata.
             if (inodeChanged) {
                 await tx.set(fileInodeId, fileInode.data);
             }
+            await tx.commit();
         }
-        catch (e) {
-            await tx.abort();
-            throw e;
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            const result_5 = __disposeResources(env_9);
+            if (result_5)
+                await result_5;
         }
-        await tx.commit();
     }
     /**
      * Updated the inode and data node at the given path
      * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
      */
     syncSync(path, data, stats) {
-        const tx = this.store.transaction(), 
-        // We use _findInode because we actually need the INode id.
-        fileInodeId = this._findINodeSync(tx, dirname(path), basename(path)), fileInode = this.getINodeSync(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+        const env_10 = { 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, dirname(path), basename(path)), fileInode = this.getINodeSync(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
             // Sync data.
             tx.setSync(fileInode.ino, data);
             // Sync metadata.
             if (inodeChanged) {
                 tx.setSync(fileInodeId, fileInode.data);
             }
+            tx.commitSync();
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        finally {
+            __disposeResources(env_10);
         }
-        tx.commitSync();
     }
     async link(existing, newpath, cred) {
-        const tx = this.store.transaction(), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
-        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', existingDir, 'link');
-        }
-        const newDir = dirname(newpath), newDirNode = await this.findINode(tx, newDir), newListing = await this.getDirListing(tx, newDirNode, newDir);
-        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', newDir, 'link');
-        }
-        const ino = await this._findINode(tx, existingDir, basename(existing));
-        const node = await this.getINode(tx, ino, existing);
-        if (!node.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', newpath, 'link');
-        }
-        node.nlink++;
-        newListing[basename(newpath)] = ino;
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_11, this.store.transaction(), true);
+            const existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
+            if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', existingDir, 'link');
+            }
+            const newDir = dirname(newpath), newDirNode = await this.findINode(tx, newDir), newListing = await this.getDirListing(tx, newDirNode, newDir);
+            if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', newDir, 'link');
+            }
+            const ino = await this._findINode(tx, existingDir, basename(existing));
+            const node = await this.getINode(tx, ino, existing);
+            if (!node.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', newpath, 'link');
+            }
+            node.nlink++;
+            newListing[basename(newpath)] = ino;
             tx.setSync(ino, node.data);
             tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+            tx.commitSync();
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            const result_6 = __disposeResources(env_11);
+            if (result_6)
+                await result_6;
         }
-        tx.commitSync();
     }
     linkSync(existing, newpath, cred) {
-        const tx = this.store.transaction(), existingDir = dirname(existing), existingDirNode = this.findINodeSync(tx, existingDir);
-        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-            throw ErrnoError.With('EACCES', existingDir, 'link');
-        }
-        const newDir = dirname(newpath), newDirNode = this.findINodeSync(tx, newDir), newListing = this.getDirListingSync(tx, newDirNode, newDir);
-        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', newDir, 'link');
-        }
-        const ino = this._findINodeSync(tx, existingDir, basename(existing));
-        const node = this.getINodeSync(tx, ino, existing);
-        if (!node.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', newpath, 'link');
-        }
-        node.nlink++;
-        newListing[basename(newpath)] = ino;
+        const env_12 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_12, this.store.transaction(), false);
+            const existingDir = dirname(existing), existingDirNode = this.findINodeSync(tx, existingDir);
+            if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+                throw ErrnoError.With('EACCES', existingDir, 'link');
+            }
+            const newDir = dirname(newpath), newDirNode = this.findINodeSync(tx, newDir), newListing = this.getDirListingSync(tx, newDirNode, newDir);
+            if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', newDir, 'link');
+            }
+            const ino = this._findINodeSync(tx, existingDir, basename(existing));
+            const node = this.getINodeSync(tx, ino, existing);
+            if (!node.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', newpath, 'link');
+            }
+            node.nlink++;
+            newListing[basename(newpath)] = ino;
             tx.setSync(ino, node.data);
             tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+            tx.commitSync();
+        }
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        finally {
+            __disposeResources(env_12);
         }
-        tx.commitSync();
     }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     async checkRoot() {
-        const tx = this.store.transaction();
-        if (await tx.get(rootIno)) {
-            return;
+        const env_13 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_13, this.store.transaction(), true);
+            if (await tx.get(rootIno)) {
+                return;
+            }
+            // Create new inode. o777, owned by root:root
+            const inode = new Inode();
+            inode.mode = 0o777 | S_IFDIR;
+            // If the root doesn't exist, the first random ID shouldn't exist either.
+            await tx.set(inode.ino, encode('{}'));
+            await tx.set(rootIno, inode.data);
+            await tx.commit();
+        }
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            const result_7 = __disposeResources(env_13);
+            if (result_7)
+                await result_7;
         }
-        // Create new inode. o777, owned by root:root
-        const inode = new Inode();
-        inode.mode = 0o777 | S_IFDIR;
-        // If the root doesn't exist, the first random ID shouldn't exist either.
-        await tx.set(inode.ino, encode('{}'));
-        await tx.set(rootIno, inode.data);
-        await tx.commit();
     }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     checkRootSync() {
-        const tx = this.store.transaction();
-        if (tx.getSync(rootIno)) {
-            return;
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = __addDisposableResource(env_14, this.store.transaction(), false);
+            if (tx.getSync(rootIno)) {
+                return;
+            }
+            // Create new inode, mode o777, owned by root:root
+            const inode = new Inode();
+            inode.mode = 0o777 | S_IFDIR;
+            // If the root doesn't exist, the first random ID shouldn't exist either.
+            tx.setSync(inode.ino, encode('{}'));
+            tx.setSync(rootIno, inode.data);
+            tx.commitSync();
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
+        }
+        finally {
+            __disposeResources(env_14);
         }
-        // Create new inode, mode o777, owned by root:root
-        const inode = new Inode();
-        inode.mode = 0o777 | S_IFDIR;
-        // If the root doesn't exist, the first random ID shouldn't exist either.
-        tx.setSync(inode.ino, encode('{}'));
-        tx.setSync(rootIno, inode.data);
-        tx.commitSync();
     }
     /**
      * Helper function for findINode.
@@ -563,27 +719,29 @@ export class StoreFS extends FileSystem {
      * @param cred The UID/GID to create the file with
      * @param data The data to store at the file's data node.
      */
-    async commitNew(tx, path, type, mode, cred, data) {
-        const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
-        //Check that the creater has correct access
-        if (!parent.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'commitNewFile');
-        }
-        const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
-        /*
-            The root always exists.
-            If we don't check this prior to taking steps below,
-            we will create a file with name '' in root should path == '/'.
-        */
-        if (path === '/') {
-            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
-        }
-        // Check if file already exists.
-        if (listing[fname]) {
-            await tx.abort();
-            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
-        }
+    async commitNew(path, type, mode, cred, data) {
+        const env_15 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_15, this.store.transaction(), true);
+            const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
+            //Check that the creater has correct access
+            if (!parent.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'commitNewFile');
+            }
+            const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
+            /*
+                The root always exists.
+                If we don't check this prior to taking steps below,
+                we will create a file with name '' in root should path == '/'.
+            */
+            if (path === '/') {
+                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+            }
+            // Check if file already exists.
+            if (listing[fname]) {
+                await tx.abort();
+                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+            }
             // Commit data.
             const inode = new Inode();
             inode.ino = await this.addNew(tx, data, path);
@@ -597,9 +755,14 @@ export class StoreFS extends FileSystem {
             await tx.commit();
             return inode;
         }
-        catch (e) {
-            await tx.abort();
-            throw e;
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
+        }
+        finally {
+            const result_8 = __disposeResources(env_15);
+            if (result_8)
+                await result_8;
         }
     }
     /**
@@ -612,27 +775,29 @@ export class StoreFS extends FileSystem {
      * @return The Inode for the new file.
      */
     commitNewSync(path, type, mode, cred, data = new Uint8Array()) {
-        const tx = this.store.transaction(), parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
-        //Check that the creater has correct access
-        if (!parent.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'commitNewFile');
-        }
-        const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
-        /*
-            The root always exists.
-            If we don't check this prior to taking steps below,
-            we will create a file with name '' in root should p == '/'.
-        */
-        if (path === '/') {
-            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
-        }
-        // Check if file already exists.
-        if (listing[fname]) {
-            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
-        }
-        const node = new Inode();
+        const env_16 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_16, this.store.transaction(), false);
+            const parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
+            //Check that the creater has correct access
+            if (!parent.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'commitNewFile');
+            }
+            const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
+            /*
+                The root always exists.
+                If we don't check this prior to taking steps below,
+                we will create a file with name '' in root should p == '/'.
+            */
+            if (path === '/') {
+                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+            }
+            // Check if file already exists.
+            if (listing[fname]) {
+                throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+            }
             // Commit data.
+            const node = new Inode();
             node.ino = this.addNewSync(tx, data, path);
             node.size = data.length;
             node.mode = mode | type;
@@ -641,13 +806,16 @@ export class StoreFS extends FileSystem {
             // Update and commit parent directory listing.
             listing[fname] = this.addNewSync(tx, node.data, path);
             tx.setSync(parent.ino, encodeDirListing(listing));
+            tx.commitSync();
+            return node;
+        }
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        finally {
+            __disposeResources(env_16);
         }
-        tx.commitSync();
-        return node;
     }
     /**
      * Remove all traces of the given path from the file system.
@@ -656,38 +824,45 @@ export class StoreFS extends FileSystem {
      * @todo Update mtime.
      */
     async remove(path, isDir, cred) {
-        const tx = this.store.transaction(), parent = dirname(path), parentNode = await this.findINode(tx, parent), listing = await this.getDirListing(tx, parentNode, parent), fileName = basename(path);
-        if (!listing[fileName]) {
-            throw ErrnoError.With('ENOENT', path, 'removeEntry');
-        }
-        const fileIno = listing[fileName];
-        // Get file inode.
-        const fileNode = await this.getINode(tx, fileIno, path);
-        if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'removeEntry');
-        }
-        // Remove from directory listing of parent.
-        delete listing[fileName];
-        if (!isDir && fileNode.toStats().isDirectory()) {
-            throw ErrnoError.With('EISDIR', path, 'removeEntry');
-        }
-        if (isDir && !fileNode.toStats().isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
-        }
+        const env_17 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_17, this.store.transaction(), true);
+            const parent = dirname(path), parentNode = await this.findINode(tx, parent), listing = await this.getDirListing(tx, parentNode, parent), fileName = basename(path);
+            if (!listing[fileName]) {
+                throw ErrnoError.With('ENOENT', path, 'removeEntry');
+            }
+            const fileIno = listing[fileName];
+            // Get file inode.
+            const fileNode = await this.getINode(tx, fileIno, path);
+            if (!fileNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'removeEntry');
+            }
+            // Remove from directory listing of parent.
+            delete listing[fileName];
+            if (!isDir && fileNode.toStats().isDirectory()) {
+                throw ErrnoError.With('EISDIR', path, 'removeEntry');
+            }
+            if (isDir && !fileNode.toStats().isDirectory()) {
+                throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+            }
             await tx.set(parentNode.ino, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
                 // remove file
                 await tx.remove(fileNode.ino);
                 await tx.remove(fileIno);
             }
+            // Success.
+            await tx.commit();
+        }
+        catch (e_17) {
+            env_17.error = e_17;
+            env_17.hasError = true;
         }
-        catch (e) {
-            await tx.abort();
-            throw e;
+        finally {
+            const result_9 = __disposeResources(env_17);
+            if (result_9)
+                await result_9;
         }
-        // Success.
-        await tx.commit();
     }
     /**
      * Remove all traces of the given path from the file system.
@@ -696,24 +871,26 @@ export class StoreFS extends FileSystem {
      * @todo Update mtime.
      */
     removeSync(path, isDir, cred) {
-        const tx = this.store.transaction(), parent = dirname(path), parentNode = this.findINodeSync(tx, parent), listing = this.getDirListingSync(tx, parentNode, parent), fileName = basename(path), fileIno = listing[fileName];
-        if (!fileIno) {
-            throw ErrnoError.With('ENOENT', path, 'removeEntry');
-        }
-        // Get file inode.
-        const fileNode = this.getINodeSync(tx, fileIno, path);
-        if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-            throw ErrnoError.With('EACCES', path, 'removeEntry');
-        }
-        // Remove from directory listing of parent.
-        delete listing[fileName];
-        if (!isDir && fileNode.toStats().isDirectory()) {
-            throw ErrnoError.With('EISDIR', path, 'removeEntry');
-        }
-        if (isDir && !fileNode.toStats().isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
-        }
+        const env_18 = { stack: [], error: void 0, hasError: false };
         try {
+            const tx = __addDisposableResource(env_18, this.store.transaction(), false);
+            const parent = dirname(path), parentNode = this.findINodeSync(tx, parent), listing = this.getDirListingSync(tx, parentNode, parent), fileName = basename(path), fileIno = listing[fileName];
+            if (!fileIno) {
+                throw ErrnoError.With('ENOENT', path, 'removeEntry');
+            }
+            // Get file inode.
+            const fileNode = this.getINodeSync(tx, fileIno, path);
+            if (!fileNode.toStats().hasAccess(W_OK, cred)) {
+                throw ErrnoError.With('EACCES', path, 'removeEntry');
+            }
+            // Remove from directory listing of parent.
+            delete listing[fileName];
+            if (!isDir && fileNode.toStats().isDirectory()) {
+                throw ErrnoError.With('EISDIR', path, 'removeEntry');
+            }
+            if (isDir && !fileNode.toStats().isDirectory()) {
+                throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+            }
             // Update directory listing.
             tx.setSync(parentNode.ino, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
@@ -721,12 +898,15 @@ export class StoreFS extends FileSystem {
                 tx.removeSync(fileNode.ino);
                 tx.removeSync(fileIno);
             }
+            // Success.
+            tx.commitSync();
+        }
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
         }
-        catch (e) {
-            tx.abortSync();
-            throw e;
+        finally {
+            __disposeResources(env_18);
         }
-        // Success.
-        tx.commitSync();
     }
 }