@zenfs/core 0.0.12 → 0.2.0

package/dist/backends/OverlayFS.js

@@ -1,39 +1,15 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-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.
  */
@@ -41,60 +17,65 @@ class OverlayFile extends PreloadFile {
     constructor(fs, path, flag, stats, data) {
         super(fs, path, flag, stats, data);
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isDirty()) {
-                return;
-            }
-            yield this._fs._syncAsync(this);
-            this.resetDirty();
-        });
+    async sync() {
+        if (!this.isDirty()) {
+            return;
+        }
+        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();
         }
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sync();
-        });
+    async close() {
+        await this.sync();
     }
     closeSync() {
         this.syncSync();
     }
 }
 /**
- * *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.
+ *
+ * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
  *
- * Core OverlayFS class that contains no locking whatsoever. We wrap these objects
- * 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 Object.assign(Object.assign({}, super.metadata), { name: OverlayFS.Name, synchronous: this._readable.metadata.synchronous && this._writable.metadata.synchronous, supportsProperties: this._readable.metadata.supportsProperties && this._writable.metadata.supportsProperties });
+        return {
+            ...super.metadata,
+            name: OverlayFS.name,
+            synchronous: this._readable.metadata.synchronous && this._writable.metadata.synchronous,
+            supportsProperties: this._readable.metadata.supportsProperties && this._writable.metadata.supportsProperties,
+        };
     }
     getOverlayedFileSystems() {
         return {
@@ -102,42 +83,38 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             writable: this._writable,
         };
     }
-    _syncAsync(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stats = file.getStats();
-            yield 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
      */
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // if we're already initialized, immediately invoke the callback
-            if (this._isInitialized) {
-                return;
-            }
-            // Read deletion log, process into metadata.
-            try {
-                const data = yield this._writable.readFile(deletionLogPath, getFlag('r'), Cred.Root);
-                this._deleteLog = decode(data);
-            }
-            catch (err) {
-                if (err.errno !== ErrorCode.ENOENT) {
-                    throw err;
-                }
+    async _initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        // Read deletion log, process into metadata.
+        try {
+            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) {
+                throw err;
             }
-            this._isInitialized = true;
-            this._reparseDeletionLog();
-        });
+        }
+        this._isInitialized = true;
+        this._reparseDeletionLog();
     }
     getDeletionLog() {
         return this._deleteLog;
@@ -147,133 +124,47 @@ export class UnlockedOverlayFS extends BaseFileSystem {
         this._reparseDeletionLog();
         this.updateLog('', cred);
     }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = yield this.stat(oldPath, cred);
-            if (oldStats.isDirectory()) {
-                // Optimization: Don't bother moving if old === new.
-                if (oldPath === newPath) {
-                    return;
-                }
-                let mode = 0o777;
-                if (yield this.exists(newPath, cred)) {
-                    const stats = yield this.stat(newPath, cred);
-                    mode = stats.mode;
-                    if (stats.isDirectory()) {
-                        if ((yield 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 (yield this._writable.exists(oldPath, cred)) {
-                    yield this._writable.rename(oldPath, newPath, cred);
-                }
-                else if (!(yield this._writable.exists(newPath, cred))) {
-                    yield this._writable.mkdir(newPath, mode, cred);
-                }
-                // Need to move *every file/folder* currently stored on readable to its new location
-                // on writable.
-                if (yield this._readable.exists(oldPath, cred)) {
-                    for (const name of yield this._readable.readdir(oldPath, cred)) {
-                        // Recursion! Should work for any nested files / folders.
-                        yield this.rename(resolve(oldPath, name), resolve(newPath, name), cred);
-                    }
-                }
-            }
-            else {
-                if ((yield this.exists(newPath, cred)) && (yield this.stat(newPath, cred)).isDirectory()) {
-                    throw ApiError.EISDIR(newPath);
-                }
-                yield this.writeFile(newPath, yield this.readFile(oldPath, getFlag('r'), cred), getFlag('w'), oldStats.mode, cred);
-            }
-            if (oldPath !== newPath && (yield this.exists(oldPath, cred))) {
-                yield this.unlink(oldPath, cred);
+    async rename(oldPath, newPath, cred) {
+        this.checkInitialized();
+        this.checkPath(oldPath);
+        this.checkPath(newPath);
+        try {
+            await this._writable.rename(oldPath, newPath, cred);
+        }
+        catch (e) {
+            if (this._deletedFiles.has(oldPath)) {
+                throw ApiError.ENOENT(oldPath);
             }
-        });
+        }
     }
     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);
         }
     }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            try {
-                return this._writable.stat(p, cred);
-            }
-            catch (e) {
-                if (this._deletedFiles[p]) {
-                    throw ApiError.ENOENT(p);
-                }
-                const oldStat = Stats.clone(yield 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);
-                return oldStat;
+    async stat(p, cred) {
+        this.checkInitialized();
+        try {
+            return this._writable.stat(p, cred);
+        }
+        catch (e) {
+            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 |= 0o222;
+            return oldStat;
+        }
     }
     statSync(p, cred) {
         this.checkInitialized();
@@ -281,219 +172,162 @@ 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;
         }
     }
-    open(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            this.checkPath(p);
-            if (p === deletionLogPath) {
-                throw ApiError.EPERM('Cannot open deletion log.');
-            }
-            if (yield this.exists(p, cred)) {
-                switch (flag.pathExistsAction()) {
-                    case ActionType.TRUNCATE_FILE:
-                        yield this.createParentDirectoriesAsync(p, cred);
-                        return this._writable.open(p, flag, mode, cred);
-                    case ActionType.NOP:
-                        if (yield this._writable.exists(p, cred)) {
-                            return this._writable.open(p, flag, mode, cred);
-                        }
-                        else {
-                            // Create an OverlayFile.
-                            const buf = yield this._readable.readFile(p, getFlag('r'), cred);
-                            const stats = Stats.clone(yield this._readable.stat(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:
-                        yield this.createParentDirectoriesAsync(p, cred);
-                        return this._writable.open(p, flag, mode, cred);
-                    default:
-                        throw ApiError.ENOENT(p);
-                }
-            }
-        });
+    async openFile(path, flag, cred) {
+        if (await this._writable.exists(path, cred)) {
+            return this._writable.openFile(path, flag, cred);
+        }
+        // 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);
+    }
+    async createFile(path, flag, mode, cred) {
+        this.checkInitialized();
+        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);
     }
-    openSync(p, flag, mode, cred) {
+    linkSync(srcpath, dstpath, cred) {
+        this.checkInitialized();
+        this._writable.linkSync(srcpath, dstpath, cred);
+    }
+    async unlink(p, cred) {
         this.checkInitialized();
         this.checkPath(p);
-        if (p === deletionLogPath) {
-            throw ApiError.EPERM('Cannot open deletion log.');
+        if (!(await this.exists(p, cred))) {
+            throw ApiError.ENOENT(p);
         }
-        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);
-            }
+        if (await this._writable.exists(p, cred)) {
+            await this._writable.unlink(p, cred);
         }
-        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);
-            }
+        // if it still exists add to the delete log
+        if (await this.exists(p, cred)) {
+            this.deletePath(p, cred);
         }
     }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            this.checkPath(p);
-            if (yield this.exists(p, cred)) {
-                if (yield this._writable.exists(p, cred)) {
-                    yield this._writable.unlink(p, cred);
-                }
-                // if it still exists add to the delete log
-                if (yield this.exists(p, cred)) {
-                    this.deletePath(p, cred);
-                }
-            }
-            else {
-                throw ApiError.ENOENT(p);
-            }
-        });
-    }
     unlinkSync(p, cred) {
         this.checkInitialized();
         this.checkPath(p);
+        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)) {
-            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);
-            }
+            this.deletePath(p, cred);
         }
-        else {
+    }
+    async rmdir(p, cred) {
+        this.checkInitialized();
+        if (!(await this.exists(p, cred))) {
             throw ApiError.ENOENT(p);
         }
-    }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            if (yield this.exists(p, cred)) {
-                if (yield this._writable.exists(p, cred)) {
-                    yield this._writable.rmdir(p, cred);
-                }
-                if (yield this.exists(p, cred)) {
-                    // Check if directory is empty.
-                    if ((yield this.readdir(p, cred)).length > 0) {
-                        throw ApiError.ENOTEMPTY(p);
-                    }
-                    else {
-                        this.deletePath(p, cred);
-                    }
-                }
+        if (await this._writable.exists(p, cred)) {
+            await this._writable.rmdir(p, cred);
+        }
+        if (await this.exists(p, cred)) {
+            // Check if directory is empty.
+            if ((await this.readdir(p, cred)).length > 0) {
+                throw ApiError.ENOTEMPTY(p);
             }
             else {
-                throw ApiError.ENOENT(p);
+                this.deletePath(p, cred);
             }
-        });
+        }
     }
     rmdirSync(p, cred) {
         this.checkInitialized();
-        if (this.existsSync(p, cred)) {
-            if (this._writable.existsSync(p, cred)) {
-                this._writable.rmdirSync(p, cred);
-            }
-            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 {
+        if (!this.existsSync(p, cred)) {
             throw ApiError.ENOENT(p);
         }
-    }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            if (yield this.exists(p, cred)) {
-                throw ApiError.EEXIST(p);
+        if (this._writable.existsSync(p, cred)) {
+            this._writable.rmdirSync(p, cred);
+        }
+        if (this.existsSync(p, cred)) {
+            // Check if directory is empty.
+            if (this.readdirSync(p, cred).length > 0) {
+                throw ApiError.ENOTEMPTY(p);
             }
             else {
-                // The below will throw should any of the parent directories fail to exist
-                // on _writable.
-                yield this.createParentDirectoriesAsync(p, cred);
-                yield this._writable.mkdir(p, mode, cred);
+                this.deletePath(p, cred);
             }
-        });
+        }
+    }
+    async mkdir(p, mode, cred) {
+        this.checkInitialized();
+        if (await this.exists(p, cred)) {
+            throw ApiError.EEXIST(p);
+        }
+        // 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);
     }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            const dirStats = yield this.stat(p, cred);
-            if (!dirStats.isDirectory()) {
-                throw ApiError.ENOTDIR(p);
-            }
-            // Readdir in both, check delete log on RO file system's listing, merge, return.
-            let contents = [];
-            try {
-                contents = contents.concat(yield this._writable.readdir(p, cred));
-            }
-            catch (e) {
-                // NOP.
-            }
-            try {
-                contents = contents.concat((yield this._readable.readdir(p, cred)).filter((fPath) => !this._deletedFiles[`${p}/${fPath}`]));
-            }
-            catch (e) {
-                // NOP.
-            }
-            const seenMap = {};
-            return contents.filter((fileP) => {
-                const result = !seenMap[fileP];
-                seenMap[fileP] = true;
-                return result;
-            });
+    async readdir(p, cred) {
+        this.checkInitialized();
+        const dirStats = await this.stat(p, cred);
+        if (!dirStats.isDirectory()) {
+            throw ApiError.ENOTDIR(p);
+        }
+        // Readdir in both, check delete log on RO file system's listing, merge, return.
+        let contents = [];
+        try {
+            contents.push(...(await this._writable.readdir(p, cred)));
+        }
+        catch (e) {
+            // NOP.
+        }
+        try {
+            contents.push(...(await this._readable.readdir(p, cred)).filter((fPath) => !this._deletedFiles.has(`${p}/${fPath}`)));
+        }
+        catch (e) {
+            // NOP.
+        }
+        const seenMap = {};
+        return contents.filter((fileP) => {
+            const result = !seenMap[fileP];
+            seenMap[fileP] = true;
+            return result;
         });
     }
     readdirSync(p, cred) {
@@ -511,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.
@@ -523,106 +357,63 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             return result;
         });
     }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            return (yield this._writable.exists(p, cred)) || ((yield 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);
-    }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            yield this.operateOnWritableAsync(p, cred);
-            yield this._writable.chmod(p, mode, cred);
-        });
-    }
-    chmodSync(p, mode, cred) {
-        this.checkInitialized();
-        this.operateOnWritable(p, cred);
-        this._writable.chmodSync(p, mode, cred);
-    }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            yield this.operateOnWritableAsync(p, cred);
-            yield 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);
-    }
-    utimes(p, atime, mtime, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.checkInitialized();
-            yield this.operateOnWritableAsync(p, cred);
-            yield 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);
@@ -633,19 +424,17 @@ export class UnlockedOverlayFS extends BaseFileSystem {
             this._writable.mkdirSync(p, this.statSync(p, cred).mode, cred);
         }
     }
-    createParentDirectoriesAsync(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let parent = dirname(p), toCreate = [];
-            while (!(yield this._writable.exists(parent, cred))) {
-                toCreate.push(parent);
-                parent = dirname(parent);
-            }
-            toCreate = toCreate.reverse();
-            for (const p of toCreate) {
-                const stats = yield this.stat(p, cred);
-                yield this._writable.mkdir(p, stats.mode, cred);
-            }
-        });
+    async createParentDirectories(p, cred) {
+        let parent = dirname(p), toCreate = [];
+        while (!(await this._writable.exists(parent, cred))) {
+            toCreate.push(parent);
+            parent = dirname(parent);
+        }
+        toCreate = toCreate.reverse();
+        for (const p of toCreate) {
+            const stats = await this.stat(p, cred);
+            await this._writable.mkdir(p, stats.mode, cred);
+        }
     }
     /**
      * Helper function:
@@ -659,42 +448,48 @@ 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);
         }
     }
-    operateOnWritableAsync(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.exists(p, cred))) {
-                throw ApiError.ENOENT(p);
-            }
-            if (!(yield this._writable.exists(p, cred))) {
-                return this.copyToWritableAsync(p, cred);
-            }
-        });
+    async operateOnWritableAsync(p, cred) {
+        if (!(await this.exists(p, cred))) {
+            throw ApiError.ENOENT(p);
+        }
+        if (!(await this._writable.exists(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);
-        }
-    }
-    copyToWritableAsync(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pStats = yield this.stat(p, cred);
-            if (pStats.isDirectory()) {
-                yield this._writable.mkdir(p, pStats.mode, cred);
-            }
-            else {
-                yield this.writeFile(p, yield this._readable.readFile(p, getFlag('r'), cred), getFlag('w'), pStats.mode, cred);
-            }
-        });
+    copyToWritableSync(p, cred) {
+        const stats = this.statSync(p, cred);
+        if (stats.isDirectory()) {
+            this._writable.mkdirSync(p, stats.mode, cred);
+            return;
+        }
+        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();
     }
 }
 /**
@@ -703,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();
@@ -725,26 +520,23 @@ export class OverlayFS extends LockedFS {
     unwrap() {
         return super.fs;
     }
-    _initialize() {
-        const _super = Object.create(null, {
-            fs: { get: () => super.fs }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _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);
     },
 };