@zenfs/core 0.1.0 → 0.2.0

package/dist/backends/OverlayFS.js

@@ -1,30 +1,15 @@
-var _a;
-import { BaseFileSystem } from '../filesystem.js';
+import { FileSystem } from '../filesystem.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
-import { FileFlag, ActionType, PreloadFile } from '../file.js';
+import { FileFlag, PreloadFile } from '../file.js';
 import { Stats } from '../stats.js';
 import LockedFS from './Locked.js';
-import { resolve, dirname } from '../emulation/path.js';
+import { dirname } from '../emulation/path.js';
 import { Cred } from '../cred.js';
-import { CreateBackend } from './backend.js';
 import { decode, encode } from '../utils.js';
 /**
  * @internal
  */
-const deletionLogPath = '/.deletedFiles.log';
-/**
- * Given a read-only mode, makes it writable.
- * @internal
- */
-function makeModeWritable(mode) {
-    return 0o222 | mode;
-}
-/**
- * @internal
- */
-function getFlag(f) {
-    return FileFlag.getFileFlag(f);
-}
+const deletionLogPath = '/.deleted';
 /**
  * Overlays a RO file to make it writable.
  */
@@ -36,12 +21,12 @@ class OverlayFile extends PreloadFile {
         if (!this.isDirty()) {
             return;
         }
-        await this._fs._syncAsync(this);
+        await this.fs.sync(this.path, this.buffer, this.stats);
         this.resetDirty();
     }
     syncSync() {
         if (this.isDirty()) {
-            this._fs._syncSync(this);
+            this.fs.syncSync(this.path, this.buffer, this.stats);
             this.resetDirty();
         }
     }
@@ -53,37 +38,41 @@ class OverlayFile extends PreloadFile {
     }
 }
 /**
- * *INTERNAL, DO NOT USE DIRECTLY!*
+ * OverlayFS makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
  *
- * Core OverlayFS class that contains no locking whatsoever. We wrap these objects
- * in a LockedFS to prevent races.
+ * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
+ *
+ * @internal
  */
-export class UnlockedOverlayFS extends BaseFileSystem {
-    static isAvailable() {
-        return true;
+export class UnlockedOverlayFS extends FileSystem {
+    async ready() {
+        await this._readable.ready();
+        await this._writable.ready();
+        await this._ready;
+        return this;
     }
     constructor({ writable, readable }) {
         super();
         this._isInitialized = false;
-        this._deletedFiles = {};
+        this._deletedFiles = new Set();
         this._deleteLog = '';
         // If 'true', we have scheduled a delete log update.
         this._deleteLogUpdatePending = false;
         // If 'true', a delete log update is needed after the scheduled delete log
         // update finishes.
         this._deleteLogUpdateNeeded = false;
-        // If there was an error updating the delete log...
-        this._deleteLogError = null;
         this._writable = writable;
         this._readable = readable;
         if (this._writable.metadata.readonly) {
             throw new ApiError(ErrorCode.EINVAL, 'Writable file system must be writable.');
         }
+        this._ready = this._initialize();
     }
     get metadata() {
         return {
             ...super.metadata,
-            name: OverlayFS.Name,
+            name: OverlayFS.name,
             synchronous: this._readable.metadata.synchronous && this._writable.metadata.synchronous,
             supportsProperties: this._readable.metadata.supportsProperties && this._writable.metadata.supportsProperties,
         };
@@ -94,30 +83,30 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             writable: this._writable,
         };
     }
-    async _syncAsync(file) {
-        const stats = file.getStats();
-        await this.createParentDirectoriesAsync(file.getPath(), stats.getCred(0, 0));
-        return this._writable.writeFile(file.getPath(), file.getBuffer(), getFlag('w'), stats.mode, stats.getCred(0, 0));
+    async sync(path, data, stats) {
+        const cred = stats.getCred(0, 0);
+        await this.createParentDirectories(path, cred);
+        await this._writable.sync(path, data, stats);
     }
-    _syncSync(file) {
-        const stats = file.getStats();
-        this.createParentDirectories(file.getPath(), stats.getCred(0, 0));
-        this._writable.writeFileSync(file.getPath(), file.getBuffer(), getFlag('w'), stats.mode, stats.getCred(0, 0));
+    syncSync(path, data, stats) {
+        const cred = stats.getCred(0, 0);
+        this.createParentDirectoriesSync(path, cred);
+        this._writable.syncSync(path, data, stats);
     }
     /**
-     * **INTERNAL METHOD**
-     *
      * Called once to load up metadata stored on the writable file system.
+     * @internal
      */
     async _initialize() {
-        // if we're already initialized, immediately invoke the callback
         if (this._isInitialized) {
             return;
         }
         // Read deletion log, process into metadata.
         try {
-            const data = await this._writable.readFile(deletionLogPath, getFlag('r'), Cred.Root);
-            this._deleteLog = decode(data);
+            const file = await this._writable.openFile(deletionLogPath, FileFlag.FromString('r'), Cred.Root);
+            const { size } = await file.stat();
+            const { buffer } = await file.read(new Uint8Array(size));
+            this._deleteLog = decode(buffer);
         }
         catch (err) {
             if (err.errno !== ErrorCode.ENOENT) {
@@ -139,108 +128,26 @@ export class UnlockedOverlayFS extends BaseFileSystem {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
-        if (oldPath === deletionLogPath || newPath === deletionLogPath) {
-            throw ApiError.EPERM('Cannot rename deletion log.');
-        }
-        // Write newPath using oldPath's contents, delete oldPath.
-        const oldStats = await this.stat(oldPath, cred);
-        if (oldStats.isDirectory()) {
-            // Optimization: Don't bother moving if old === new.
-            if (oldPath === newPath) {
-                return;
-            }
-            let mode = 0o777;
-            if (await this.exists(newPath, cred)) {
-                const stats = await this.stat(newPath, cred);
-                mode = stats.mode;
-                if (stats.isDirectory()) {
-                    if ((await this.readdir(newPath, cred)).length > 0) {
-                        throw ApiError.ENOTEMPTY(newPath);
-                    }
-                }
-                else {
-                    throw ApiError.ENOTDIR(newPath);
-                }
-            }
-            // Take care of writable first. Move any files there, or create an empty directory
-            // if it doesn't exist.
-            if (await this._writable.exists(oldPath, cred)) {
-                await this._writable.rename(oldPath, newPath, cred);
-            }
-            else if (!(await this._writable.exists(newPath, cred))) {
-                await this._writable.mkdir(newPath, mode, cred);
-            }
-            // Need to move *every file/folder* currently stored on readable to its new location
-            // on writable.
-            if (await this._readable.exists(oldPath, cred)) {
-                for (const name of await this._readable.readdir(oldPath, cred)) {
-                    // Recursion! Should work for any nested files / folders.
-                    await this.rename(resolve(oldPath, name), resolve(newPath, name), cred);
-                }
-            }
+        try {
+            await this._writable.rename(oldPath, newPath, cred);
         }
-        else {
-            if ((await this.exists(newPath, cred)) && (await this.stat(newPath, cred)).isDirectory()) {
-                throw ApiError.EISDIR(newPath);
+        catch (e) {
+            if (this._deletedFiles.has(oldPath)) {
+                throw ApiError.ENOENT(oldPath);
             }
-            await this.writeFile(newPath, await this.readFile(oldPath, getFlag('r'), cred), getFlag('w'), oldStats.mode, cred);
-        }
-        if (oldPath !== newPath && (await this.exists(oldPath, cred))) {
-            await this.unlink(oldPath, cred);
         }
     }
     renameSync(oldPath, newPath, cred) {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
-        if (oldPath === deletionLogPath || newPath === deletionLogPath) {
-            throw ApiError.EPERM('Cannot rename deletion log.');
-        }
-        // Write newPath using oldPath's contents, delete oldPath.
-        const oldStats = this.statSync(oldPath, cred);
-        if (oldStats.isDirectory()) {
-            // Optimization: Don't bother moving if old === new.
-            if (oldPath === newPath) {
-                return;
-            }
-            let mode = 0o777;
-            if (this.existsSync(newPath, cred)) {
-                const stats = this.statSync(newPath, cred);
-                mode = stats.mode;
-                if (stats.isDirectory()) {
-                    if (this.readdirSync(newPath, cred).length > 0) {
-                        throw ApiError.ENOTEMPTY(newPath);
-                    }
-                }
-                else {
-                    throw ApiError.ENOTDIR(newPath);
-                }
-            }
-            // Take care of writable first. Move any files there, or create an empty directory
-            // if it doesn't exist.
-            if (this._writable.existsSync(oldPath, cred)) {
-                this._writable.renameSync(oldPath, newPath, cred);
-            }
-            else if (!this._writable.existsSync(newPath, cred)) {
-                this._writable.mkdirSync(newPath, mode, cred);
-            }
-            // Need to move *every file/folder* currently stored on readable to its new location
-            // on writable.
-            if (this._readable.existsSync(oldPath, cred)) {
-                this._readable.readdirSync(oldPath, cred).forEach(name => {
-                    // Recursion! Should work for any nested files / folders.
-                    this.renameSync(resolve(oldPath, name), resolve(newPath, name), cred);
-                });
-            }
+        try {
+            this._writable.renameSync(oldPath, newPath, cred);
         }
-        else {
-            if (this.existsSync(newPath, cred) && this.statSync(newPath, cred).isDirectory()) {
-                throw ApiError.EISDIR(newPath);
+        catch (e) {
+            if (this._deletedFiles.has(oldPath)) {
+                throw ApiError.ENOENT(oldPath);
             }
-            this.writeFileSync(newPath, this.readFileSync(oldPath, getFlag('r'), cred), getFlag('w'), oldStats.mode, cred);
-        }
-        if (oldPath !== newPath && this.existsSync(oldPath, cred)) {
-            this.unlinkSync(oldPath, cred);
         }
     }
     async stat(p, cred) {
@@ -249,13 +156,13 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             return this._writable.stat(p, cred);
         }
         catch (e) {
-            if (this._deletedFiles[p]) {
+            if (this._deletedFiles.has(p)) {
                 throw ApiError.ENOENT(p);
             }
             const oldStat = Stats.clone(await this._readable.stat(p, cred));
             // Make the oldStat's mode writable. Preserve the topmost part of the
             // mode, which specifies if it is a file or a directory.
-            oldStat.mode = makeModeWritable(oldStat.mode);
+            oldStat.mode |= 0o222;
             return oldStat;
         }
     }
@@ -265,183 +172,136 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             return this._writable.statSync(p, cred);
         }
         catch (e) {
-            if (this._deletedFiles[p]) {
+            if (this._deletedFiles.has(p)) {
                 throw ApiError.ENOENT(p);
             }
             const oldStat = Stats.clone(this._readable.statSync(p, cred));
             // Make the oldStat's mode writable. Preserve the topmost part of the
             // mode, which specifies if it is a file or a directory.
-            oldStat.mode = makeModeWritable(oldStat.mode);
+            oldStat.mode |= 0o222;
             return oldStat;
         }
     }
-    async open(p, flag, mode, cred) {
-        this.checkInitialized();
-        this.checkPath(p);
-        if (p === deletionLogPath) {
-            throw ApiError.EPERM('Cannot open deletion log.');
-        }
-        if (await this.exists(p, cred)) {
-            switch (flag.pathExistsAction()) {
-                case ActionType.TRUNCATE_FILE:
-                    await this.createParentDirectoriesAsync(p, cred);
-                    return this._writable.open(p, flag, mode, cred);
-                case ActionType.NOP:
-                    if (await this._writable.exists(p, cred)) {
-                        return this._writable.open(p, flag, mode, cred);
-                    }
-                    else {
-                        // Create an OverlayFile.
-                        const buf = await this._readable.readFile(p, getFlag('r'), cred);
-                        const stats = Stats.clone(await this._readable.stat(p, cred));
-                        stats.mode = mode;
-                        return new OverlayFile(this, p, flag, stats, buf);
-                    }
-                default:
-                    throw ApiError.EEXIST(p);
-            }
+    async openFile(path, flag, cred) {
+        if (await this._writable.exists(path, cred)) {
+            return this._writable.openFile(path, flag, cred);
         }
-        else {
-            switch (flag.pathNotExistsAction()) {
-                case ActionType.CREATE_FILE:
-                    await this.createParentDirectoriesAsync(p, cred);
-                    return this._writable.open(p, flag, mode, cred);
-                default:
-                    throw ApiError.ENOENT(p);
-            }
+        // Create an OverlayFile.
+        const file = await this._readable.openFile(path, FileFlag.FromString('r'), cred);
+        const stats = Stats.clone(await file.stat());
+        const { buffer } = await file.read(new Uint8Array(stats.size));
+        return new OverlayFile(this, path, flag, stats, buffer);
+    }
+    openFileSync(path, flag, cred) {
+        if (this._writable.existsSync(path, cred)) {
+            return this._writable.openFileSync(path, flag, cred);
         }
+        // Create an OverlayFile.
+        const file = this._readable.openFileSync(path, FileFlag.FromString('r'), cred);
+        const stats = Stats.clone(file.statSync());
+        const data = new Uint8Array(stats.size);
+        file.readSync(data);
+        return new OverlayFile(this, path, flag, stats, data);
     }
-    openSync(p, flag, mode, cred) {
+    async createFile(path, flag, mode, cred) {
         this.checkInitialized();
-        this.checkPath(p);
-        if (p === deletionLogPath) {
-            throw ApiError.EPERM('Cannot open deletion log.');
-        }
-        if (this.existsSync(p, cred)) {
-            switch (flag.pathExistsAction()) {
-                case ActionType.TRUNCATE_FILE:
-                    this.createParentDirectories(p, cred);
-                    return this._writable.openSync(p, flag, mode, cred);
-                case ActionType.NOP:
-                    if (this._writable.existsSync(p, cred)) {
-                        return this._writable.openSync(p, flag, mode, cred);
-                    }
-                    else {
-                        // Create an OverlayFile.
-                        const buf = this._readable.readFileSync(p, getFlag('r'), cred);
-                        const stats = Stats.clone(this._readable.statSync(p, cred));
-                        stats.mode = mode;
-                        return new OverlayFile(this, p, flag, stats, buf);
-                    }
-                default:
-                    throw ApiError.EEXIST(p);
-            }
-        }
-        else {
-            switch (flag.pathNotExistsAction()) {
-                case ActionType.CREATE_FILE:
-                    this.createParentDirectories(p, cred);
-                    return this._writable.openSync(p, flag, mode, cred);
-                default:
-                    throw ApiError.ENOENT(p);
-            }
-        }
+        await this._writable.createFile(path, flag, mode, cred);
+        return this.openFile(path, flag, cred);
+    }
+    createFileSync(path, flag, mode, cred) {
+        this.checkInitialized();
+        this._writable.createFileSync(path, flag, mode, cred);
+        return this.openFileSync(path, flag, cred);
+    }
+    async link(srcpath, dstpath, cred) {
+        this.checkInitialized();
+        await this._writable.link(srcpath, dstpath, cred);
+    }
+    linkSync(srcpath, dstpath, cred) {
+        this.checkInitialized();
+        this._writable.linkSync(srcpath, dstpath, cred);
     }
     async unlink(p, cred) {
         this.checkInitialized();
         this.checkPath(p);
-        if (await this.exists(p, cred)) {
-            if (await this._writable.exists(p, cred)) {
-                await this._writable.unlink(p, cred);
-            }
-            // if it still exists add to the delete log
-            if (await this.exists(p, cred)) {
-                this.deletePath(p, cred);
-            }
-        }
-        else {
+        if (!(await this.exists(p, cred))) {
             throw ApiError.ENOENT(p);
         }
+        if (await this._writable.exists(p, cred)) {
+            await this._writable.unlink(p, cred);
+        }
+        // if it still exists add to the delete log
+        if (await this.exists(p, cred)) {
+            this.deletePath(p, cred);
+        }
     }
     unlinkSync(p, cred) {
         this.checkInitialized();
         this.checkPath(p);
-        if (this.existsSync(p, cred)) {
-            if (this._writable.existsSync(p, cred)) {
-                this._writable.unlinkSync(p, cred);
-            }
-            // if it still exists add to the delete log
-            if (this.existsSync(p, cred)) {
-                this.deletePath(p, cred);
-            }
-        }
-        else {
+        if (!this.existsSync(p, cred)) {
             throw ApiError.ENOENT(p);
         }
+        if (this._writable.existsSync(p, cred)) {
+            this._writable.unlinkSync(p, cred);
+        }
+        // if it still exists add to the delete log
+        if (this.existsSync(p, cred)) {
+            this.deletePath(p, cred);
+        }
     }
     async rmdir(p, cred) {
         this.checkInitialized();
+        if (!(await this.exists(p, cred))) {
+            throw ApiError.ENOENT(p);
+        }
+        if (await this._writable.exists(p, cred)) {
+            await this._writable.rmdir(p, cred);
+        }
         if (await this.exists(p, cred)) {
-            if (await this._writable.exists(p, cred)) {
-                await this._writable.rmdir(p, cred);
+            // Check if directory is empty.
+            if ((await this.readdir(p, cred)).length > 0) {
+                throw ApiError.ENOTEMPTY(p);
             }
-            if (await this.exists(p, cred)) {
-                // Check if directory is empty.
-                if ((await this.readdir(p, cred)).length > 0) {
-                    throw ApiError.ENOTEMPTY(p);
-                }
-                else {
-                    this.deletePath(p, cred);
-                }
+            else {
+                this.deletePath(p, cred);
             }
         }
-        else {
-            throw ApiError.ENOENT(p);
-        }
     }
     rmdirSync(p, cred) {
         this.checkInitialized();
+        if (!this.existsSync(p, cred)) {
+            throw ApiError.ENOENT(p);
+        }
+        if (this._writable.existsSync(p, cred)) {
+            this._writable.rmdirSync(p, cred);
+        }
         if (this.existsSync(p, cred)) {
-            if (this._writable.existsSync(p, cred)) {
-                this._writable.rmdirSync(p, cred);
+            // Check if directory is empty.
+            if (this.readdirSync(p, cred).length > 0) {
+                throw ApiError.ENOTEMPTY(p);
             }
-            if (this.existsSync(p, cred)) {
-                // Check if directory is empty.
-                if (this.readdirSync(p, cred).length > 0) {
-                    throw ApiError.ENOTEMPTY(p);
-                }
-                else {
-                    this.deletePath(p, cred);
-                }
+            else {
+                this.deletePath(p, cred);
             }
         }
-        else {
-            throw ApiError.ENOENT(p);
-        }
     }
     async mkdir(p, mode, cred) {
         this.checkInitialized();
         if (await this.exists(p, cred)) {
             throw ApiError.EEXIST(p);
         }
-        else {
-            // The below will throw should any of the parent directories fail to exist
-            // on _writable.
-            await this.createParentDirectoriesAsync(p, cred);
-            await this._writable.mkdir(p, mode, cred);
-        }
+        // The below will throw should any of the parent directories fail to exist on _writable.
+        await this.createParentDirectories(p, cred);
+        await this._writable.mkdir(p, mode, cred);
     }
     mkdirSync(p, mode, cred) {
         this.checkInitialized();
         if (this.existsSync(p, cred)) {
             throw ApiError.EEXIST(p);
         }
-        else {
-            // The below will throw should any of the parent directories fail to exist
-            // on _writable.
-            this.createParentDirectories(p, cred);
-            this._writable.mkdirSync(p, mode, cred);
-        }
+        // The below will throw should any of the parent directories fail to exist on _writable.
+        this.createParentDirectoriesSync(p, cred);
+        this._writable.mkdirSync(p, mode, cred);
     }
     async readdir(p, cred) {
         this.checkInitialized();
@@ -452,13 +312,13 @@ export class UnlockedOverlayFS extends BaseFileSystem {
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         let contents = [];
         try {
-            contents = contents.concat(await this._writable.readdir(p, cred));
+            contents.push(...(await this._writable.readdir(p, cred)));
         }
         catch (e) {
             // NOP.
         }
         try {
-            contents = contents.concat((await this._readable.readdir(p, cred)).filter((fPath) => !this._deletedFiles[`${p}/${fPath}`]));
+            contents.push(...(await this._readable.readdir(p, cred)).filter((fPath) => !this._deletedFiles.has(`${p}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -485,7 +345,7 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             // NOP.
         }
         try {
-            contents = contents.concat(this._readable.readdirSync(p, cred).filter((fPath) => !this._deletedFiles[`${p}/${fPath}`]));
+            contents = contents.concat(this._readable.readdirSync(p, cred).filter((fPath) => !this._deletedFiles.has(`${p}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -497,98 +357,63 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             return result;
         });
     }
-    async exists(p, cred) {
-        this.checkInitialized();
-        return (await this._writable.exists(p, cred)) || ((await this._readable.exists(p, cred)) && this._deletedFiles[p] !== true);
-    }
-    existsSync(p, cred) {
-        this.checkInitialized();
-        return this._writable.existsSync(p, cred) || (this._readable.existsSync(p, cred) && this._deletedFiles[p] !== true);
-    }
-    async chmod(p, mode, cred) {
-        this.checkInitialized();
-        await this.operateOnWritableAsync(p, cred);
-        await this._writable.chmod(p, mode, cred);
-    }
-    chmodSync(p, mode, cred) {
-        this.checkInitialized();
-        this.operateOnWritable(p, cred);
-        this._writable.chmodSync(p, mode, cred);
-    }
-    async chown(p, new_uid, new_gid, cred) {
-        this.checkInitialized();
-        await this.operateOnWritableAsync(p, cred);
-        await this._writable.chown(p, new_uid, new_gid, cred);
-    }
-    chownSync(p, new_uid, new_gid, cred) {
-        this.checkInitialized();
-        this.operateOnWritable(p, cred);
-        this._writable.chownSync(p, new_uid, new_gid, cred);
-    }
-    async utimes(p, atime, mtime, cred) {
-        this.checkInitialized();
-        await this.operateOnWritableAsync(p, cred);
-        await this._writable.utimes(p, atime, mtime, cred);
-    }
-    utimesSync(p, atime, mtime, cred) {
-        this.checkInitialized();
-        this.operateOnWritable(p, cred);
-        this._writable.utimesSync(p, atime, mtime, cred);
-    }
     deletePath(p, cred) {
-        this._deletedFiles[p] = true;
+        this._deletedFiles.add(p);
         this.updateLog(`d${p}\n`, cred);
     }
-    updateLog(addition, cred) {
+    async updateLog(addition, cred) {
         this._deleteLog += addition;
         if (this._deleteLogUpdatePending) {
             this._deleteLogUpdateNeeded = true;
+            return;
         }
-        else {
-            this._deleteLogUpdatePending = true;
-            this._writable
-                .writeFile(deletionLogPath, encode(this._deleteLog), FileFlag.getFileFlag('w'), 0o644, cred)
-                .then(() => {
-                if (this._deleteLogUpdateNeeded) {
-                    this._deleteLogUpdateNeeded = false;
-                    this.updateLog('', cred);
-                }
-            })
-                .catch(e => {
-                this._deleteLogError = e;
-            })
-                .finally(() => {
-                this._deleteLogUpdatePending = false;
-            });
+        this._deleteLogUpdatePending = true;
+        const log = await this._writable.openFile(deletionLogPath, FileFlag.FromString('w'), cred);
+        try {
+            await log.write(encode(this._deleteLog));
+            if (this._deleteLogUpdateNeeded) {
+                this._deleteLogUpdateNeeded = false;
+                this.updateLog('', cred);
+            }
+        }
+        catch (e) {
+            this._deleteLogError = e;
+        }
+        finally {
+            this._deleteLogUpdatePending = false;
         }
     }
     _reparseDeletionLog() {
-        this._deletedFiles = {};
-        this._deleteLog.split('\n').forEach((path) => {
+        this._deletedFiles.clear();
+        for (const entry of this._deleteLog.split('\n')) {
+            if (!entry.startsWith('d')) {
+                continue;
+            }
             // If the log entry begins w/ 'd', it's a deletion.
-            this._deletedFiles[path.slice(1)] = path.slice(0, 1) === 'd';
-        });
+            this._deletedFiles.add(entry.slice(1));
+        }
     }
     checkInitialized() {
         if (!this._isInitialized) {
             throw new ApiError(ErrorCode.EPERM, 'OverlayFS is not initialized. Please initialize OverlayFS using its initialize() method before using it.');
         }
-        else if (this._deleteLogError !== null) {
-            const e = this._deleteLogError;
-            this._deleteLogError = null;
-            throw e;
+        if (!this._deleteLogError) {
+            return;
         }
+        const error = this._deleteLogError;
+        this._deleteLogError = null;
+        throw error;
     }
-    checkPath(p) {
-        if (p === deletionLogPath) {
-            throw ApiError.EPERM(p);
+    checkPath(path) {
+        if (path == deletionLogPath) {
+            throw ApiError.EPERM(path);
         }
     }
     /**
      * With the given path, create the needed parent directories on the writable storage
      * should they not exist. Use modes from the read-only storage.
      */
-    createParentDirectories(p, cred) {
+    createParentDirectoriesSync(p, cred) {
         let parent = dirname(p), toCreate = [];
         while (!this._writable.existsSync(parent, cred)) {
             toCreate.push(parent);
@@ -599,7 +424,7 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             this._writable.mkdirSync(p, this.statSync(p, cred).mode, cred);
         }
     }
-    async createParentDirectoriesAsync(p, cred) {
+    async createParentDirectories(p, cred) {
         let parent = dirname(p), toCreate = [];
         while (!(await this._writable.exists(parent, cred))) {
             toCreate.push(parent);
@@ -623,7 +448,7 @@ export class UnlockedOverlayFS extends BaseFileSystem {
         if (!this._writable.existsSync(p, cred)) {
             // File is on readable storage. Copy to writable storage before
             // changing its mode.
-            this.copyToWritable(p, cred);
+            this.copyToWritableSync(p, cred);
         }
     }
     async operateOnWritableAsync(p, cred) {
@@ -631,30 +456,40 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             throw ApiError.ENOENT(p);
         }
         if (!(await this._writable.exists(p, cred))) {
-            return this.copyToWritableAsync(p, cred);
+            return this.copyToWritable(p, cred);
         }
     }
     /**
      * Copy from readable to writable storage.
      * PRECONDITION: File does not exist on writable storage.
      */
-    copyToWritable(p, cred) {
-        const pStats = this.statSync(p, cred);
-        if (pStats.isDirectory()) {
-            this._writable.mkdirSync(p, pStats.mode, cred);
-        }
-        else {
-            this.writeFileSync(p, this._readable.readFileSync(p, getFlag('r'), cred), getFlag('w'), pStats.mode, cred);
-        }
-    }
-    async copyToWritableAsync(p, cred) {
-        const pStats = await this.stat(p, cred);
-        if (pStats.isDirectory()) {
-            await this._writable.mkdir(p, pStats.mode, cred);
+    copyToWritableSync(p, cred) {
+        const stats = this.statSync(p, cred);
+        if (stats.isDirectory()) {
+            this._writable.mkdirSync(p, stats.mode, cred);
+            return;
         }
-        else {
-            await this.writeFile(p, await this._readable.readFile(p, getFlag('r'), cred), getFlag('w'), pStats.mode, cred);
+        const data = new Uint8Array(stats.size);
+        const readable = this._readable.openFileSync(p, FileFlag.FromString('r'), cred);
+        readable.readSync(data);
+        readable.closeSync();
+        const writable = this._writable.openFileSync(p, FileFlag.FromString('w'), cred);
+        writable.writeSync(data);
+        writable.closeSync();
+    }
+    async copyToWritable(p, cred) {
+        const stats = await this.stat(p, cred);
+        if (stats.isDirectory()) {
+            await this._writable.mkdir(p, stats.mode, cred);
+            return;
         }
+        const data = new Uint8Array(stats.size);
+        const readable = await this._readable.openFile(p, FileFlag.FromString('r'), cred);
+        await readable.read(data);
+        await readable.close();
+        const writable = await this._writable.openFile(p, FileFlag.FromString('w'), cred);
+        await writable.write(data);
+        await writable.close();
     }
 }
 /**
@@ -663,15 +498,15 @@ export class UnlockedOverlayFS extends BaseFileSystem {
  * file system.
  */
 export class OverlayFS extends LockedFS {
-    static isAvailable() {
-        return UnlockedOverlayFS.isAvailable();
+    async ready() {
+        await super.ready();
+        return this;
     }
     /**
      * @param options The options to initialize the OverlayFS with
      */
     constructor(options) {
         super(new UnlockedOverlayFS(options));
-        this._ready = this._initialize();
     }
     getOverlayedFileSystems() {
         return super.fs.getOverlayedFileSystems();
@@ -685,21 +520,23 @@ export class OverlayFS extends LockedFS {
     unwrap() {
         return super.fs;
     }
-    async _initialize() {
-        await super.fs._initialize();
-        return this;
-    }
 }
-_a = OverlayFS;
-OverlayFS.Name = 'OverlayFS';
-OverlayFS.Create = CreateBackend.bind(_a);
-OverlayFS.Options = {
-    writable: {
-        type: 'object',
-        description: 'The file system to write modified files to.',
+export const Overlay = {
+    name: 'Overlay',
+    options: {
+        writable: {
+            type: 'object',
+            description: 'The file system to write modified files to.',
+        },
+        readable: {
+            type: 'object',
+            description: 'The file system that initially populates this file system.',
+        },
+    },
+    isAvailable() {
+        return true;
     },
-    readable: {
-        type: 'object',
-        description: 'The file system that initially populates this file system.',
+    create(options) {
+        return new OverlayFS(options);
     },
 };