@zenfs/core 0.17.0 → 0.18.0

package/dist/backends/backend.d.ts

@@ -84,10 +84,9 @@ export declare function checkOptions<T extends Backend>(backend: T, opts: Record
 /**
  * Specifies a file system backend type and its options.
  *
- * Individual options can recursively contain BackendConfig objects for
- * option values that require file systems.
+ * Individual options can recursively contain BackendConfiguration objects for values that require file systems.
  *
- * The option object for each file system corresponds to that file system's option object passed to its `Create()` method.
+ * The configuration for each file system corresponds to that file system's option object passed to its `create()` method.
  */
 export type BackendConfiguration<T extends Backend> = OptionsOf<T> & Partial<SharedConfig> & {
     backend: T;

package/dist/backends/fetch.js

@@ -80,10 +80,10 @@ export class FetchFS extends IndexFS {
     preload(path, buffer) {
         const stats = this.index.get(path);
         if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'preloadFile');
+            throw ErrnoError.With('ENOENT', path, 'preload');
         }
         if (!stats.isFile()) {
-            throw ErrnoError.With('EISDIR', path, 'preloadFile');
+            throw ErrnoError.With('EISDIR', path, 'preload');
         }
         stats.size = buffer.length;
         stats.fileData = buffer;

package/dist/backends/file_index.d.ts

@@ -1,4 +1,3 @@
-import type { Cred } from '../cred.js';
 import { NoSyncFile } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import type { StatsLike } from '../stats.js';
@@ -45,18 +44,18 @@ export declare class Index extends Map<string, Stats> {
 }
 declare const IndexFS_base: import("../mixins/shared.js").Mixin<typeof FileSystem, {
     metadata(): import("../filesystem.js").FileSystemMetadata;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("../file.js").File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("../file.js").File;
-    unlink(path: string, cred: Cred): Promise<void>;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    createFile(path: string, flag: string, mode: number): Promise<import("../file.js").File>;
+    createFileSync(path: string, flag: string, mode: number): import("../file.js").File;
+    unlink(path: string): Promise<void>;
+    unlinkSync(path: string): void;
+    rmdir(path: string): Promise<void>;
+    rmdirSync(path: string): void;
+    mkdir(path: string, mode: number): Promise<void>;
+    mkdirSync(path: string, mode: number): void;
+    link(srcpath: string, dstpath: string): Promise<void>;
+    linkSync(srcpath: string, dstpath: string): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }>;
@@ -70,8 +69,8 @@ export declare abstract class IndexFS extends IndexFS_base {
     reloadFilesSync(): void;
     stat(path: string): Promise<Stats>;
     statSync(path: string): Stats;
-    openFile(path: string, flag: string, cred: Cred): Promise<NoSyncFile<this>>;
-    openFileSync(path: string, flag: string, cred: Cred): NoSyncFile<this>;
+    openFile(path: string, flag: string): Promise<NoSyncFile<this>>;
+    openFileSync(path: string, flag: string): NoSyncFile<this>;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;

package/dist/backends/file_index.js

@@ -2,7 +2,7 @@
 import { isJSON } from 'utilium';
 import { basename, dirname } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
-import { NoSyncFile, flagToMode, isWriteable } from '../file.js';
+import { NoSyncFile, isWriteable } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Readonly } from '../mixins/readonly.js';
 import { Stats } from '../stats.js';
@@ -118,7 +118,7 @@ export class IndexFS extends Readonly(FileSystem) {
         }
         return this.index.get(path);
     }
-    async openFile(path, flag, cred) {
+    async openFile(path, flag) {
         if (isWriteable(flag)) {
             // You can't write to files on this file system.
             throw new ErrnoError(Errno.EPERM, path);
@@ -128,12 +128,9 @@ export class IndexFS extends Readonly(FileSystem) {
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'openFile');
         }
-        if (!stats.hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
-        }
         return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : await this.getData(path, stats));
     }
-    openFileSync(path, flag, cred) {
+    openFileSync(path, flag) {
         if (isWriteable(flag)) {
             // You can't write to files on this file system.
             throw new ErrnoError(Errno.EPERM, path);
@@ -143,9 +140,6 @@ export class IndexFS extends Readonly(FileSystem) {
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'openFile');
         }
-        if (!stats.hasAccess(flagToMode(flag), cred)) {
-            throw ErrnoError.With('EACCES', path, 'openFile');
-        }
         return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : this.getDataSync(path, stats));
     }
     readdir(path) {

package/dist/backends/overlay.d.ts

@@ -1,8 +1,7 @@
+import type { File } from '../file.js';
 import type { FileSystemMetadata } from '../filesystem.js';
 import { FileSystem } from '../filesystem.js';
-import type { File } from '../file.js';
 import { Stats } from '../stats.js';
-import type { Cred } from '../cred.js';
 /**
  * Configuration options for OverlayFS instances.
  */
@@ -45,25 +44,25 @@ export declare class UnmutexedOverlayFS extends FileSystem {
      */
     _initialize(): Promise<void>;
     getDeletionLog(): string;
-    restoreDeletionLog(log: string, cred: Cred): Promise<void>;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    stat(path: string, cred: Cred): Promise<Stats>;
-    statSync(path: string, cred: Cred): Stats;
-    openFile(path: string, flag: string, cred: Cred): Promise<File>;
-    openFileSync(path: string, flag: string, cred: Cred): File;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    unlink(path: string, cred: Cred): Promise<void>;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    readdir(path: string, cred: Cred): Promise<string[]>;
-    readdirSync(path: string, cred: Cred): string[];
+    restoreDeletionLog(log: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    openFile(path: string, flag: string): Promise<File>;
+    openFileSync(path: string, flag: string): File;
+    createFile(path: string, flag: string, mode: number): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number): File;
+    link(srcpath: string, dstpath: string): Promise<void>;
+    linkSync(srcpath: string, dstpath: string): void;
+    unlink(path: string): Promise<void>;
+    unlinkSync(path: string): void;
+    rmdir(path: string): Promise<void>;
+    rmdirSync(path: string): void;
+    mkdir(path: string, mode: number): Promise<void>;
+    mkdirSync(path: string, mode: number): void;
+    readdir(path: string): Promise<string[]>;
+    readdirSync(path: string): string[];
     private deletePath;
     private updateLog;
     private _reparseDeletionLog;
@@ -90,7 +89,7 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     private copyToWritable;
 }
 declare const OverlayFS_base: import("../mixins/shared.js").Mixin<typeof UnmutexedOverlayFS, {
-    lock(path: string): Promise<import("../mixins/mutexed.js").MutexLock>;
+    lock(path: string, syscall: string): Promise<import("../mixins/mutexed.js").MutexLock>;
     lockSync(path: string): import("../mixins/mutexed.js").MutexLock;
     isLocked(path: string): boolean;
 }>;

package/dist/backends/overlay.js

@@ -1,10 +1,9 @@
-import { FileSystem } from '../filesystem.js';
-import { ErrnoError, Errno } from '../error.js';
+import { dirname } from '../emulation/path.js';
+import { Errno, ErrnoError } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
-import { Stats } from '../stats.js';
+import { FileSystem } from '../filesystem.js';
 import { Mutexed } from '../mixins/mutexed.js';
-import { dirname } from '../emulation/path.js';
-import { rootCred } from '../cred.js';
+import { Stats } from '../stats.js';
 import { decode, encode } from '../utils.js';
 /**
  * @internal
@@ -48,16 +47,14 @@ export class UnmutexedOverlayFS extends FileSystem {
         };
     }
     async sync(path, data, stats) {
-        const cred = stats.cred(0, 0);
-        await this.createParentDirectories(path, cred);
-        if (!(await this.writable.exists(path, cred))) {
-            await this.writable.createFile(path, 'w', 0o644, cred);
+        await this.createParentDirectories(path);
+        if (!(await this.writable.exists(path))) {
+            await this.writable.createFile(path, 'w', 0o644);
         }
         await this.writable.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
-        const cred = stats.cred(0, 0);
-        this.createParentDirectoriesSync(path, cred);
+        this.createParentDirectoriesSync(path);
         this.writable.syncSync(path, data, stats);
     }
     /**
@@ -70,7 +67,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         }
         // Read deletion log, process into metadata.
         try {
-            const file = await this.writable.openFile(deletionLogPath, parseFlag('r'), rootCred);
+            const file = await this.writable.openFile(deletionLogPath, parseFlag('r'));
             const { size } = await file.stat();
             const { buffer } = await file.read(new Uint8Array(size));
             this._deleteLog = decode(buffer);
@@ -86,17 +83,17 @@ export class UnmutexedOverlayFS extends FileSystem {
     getDeletionLog() {
         return this._deleteLog;
     }
-    async restoreDeletionLog(log, cred) {
+    async restoreDeletionLog(log) {
         this._deleteLog = log;
         this._reparseDeletionLog();
-        await this.updateLog('', cred);
+        await this.updateLog('');
     }
-    async rename(oldPath, newPath, cred) {
+    async rename(oldPath, newPath) {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
         try {
-            await this.writable.rename(oldPath, newPath, cred);
+            await this.writable.rename(oldPath, newPath);
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
@@ -104,12 +101,12 @@ export class UnmutexedOverlayFS extends FileSystem {
             }
         }
     }
-    renameSync(oldPath, newPath, cred) {
+    renameSync(oldPath, newPath) {
         this.checkInitialized();
         this.checkPath(oldPath);
         this.checkPath(newPath);
         try {
-            this.writable.renameSync(oldPath, newPath, cred);
+            this.writable.renameSync(oldPath, newPath);
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
@@ -117,173 +114,173 @@ export class UnmutexedOverlayFS extends FileSystem {
             }
         }
     }
-    async stat(path, cred) {
+    async stat(path) {
         this.checkInitialized();
         try {
-            return await this.writable.stat(path, cred);
+            return await this.writable.stat(path);
         }
         catch (e) {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
-            const oldStat = new Stats(await this.readable.stat(path, cred));
+            const oldStat = new Stats(await this.readable.stat(path));
             // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type
             oldStat.mode |= 0o222;
             return oldStat;
         }
     }
-    statSync(path, cred) {
+    statSync(path) {
         this.checkInitialized();
         try {
-            return this.writable.statSync(path, cred);
+            return this.writable.statSync(path);
         }
         catch (e) {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
-            const oldStat = new Stats(this.readable.statSync(path, cred));
+            const oldStat = new Stats(this.readable.statSync(path));
             // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type.
             oldStat.mode |= 0o222;
             return oldStat;
         }
     }
-    async openFile(path, flag, cred) {
-        if (await this.writable.exists(path, cred)) {
-            return this.writable.openFile(path, flag, cred);
+    async openFile(path, flag) {
+        if (await this.writable.exists(path)) {
+            return this.writable.openFile(path, flag);
         }
         // Create an OverlayFile.
-        const file = await this.readable.openFile(path, parseFlag('r'), cred);
+        const file = await this.readable.openFile(path, parseFlag('r'));
         const stats = new Stats(await file.stat());
         const { buffer } = await file.read(new Uint8Array(stats.size));
         return new PreloadFile(this, path, flag, stats, buffer);
     }
-    openFileSync(path, flag, cred) {
-        if (this.writable.existsSync(path, cred)) {
-            return this.writable.openFileSync(path, flag, cred);
+    openFileSync(path, flag) {
+        if (this.writable.existsSync(path)) {
+            return this.writable.openFileSync(path, flag);
         }
         // Create an OverlayFile.
-        const file = this.readable.openFileSync(path, parseFlag('r'), cred);
+        const file = this.readable.openFileSync(path, parseFlag('r'));
         const stats = new Stats(file.statSync());
         const data = new Uint8Array(stats.size);
         file.readSync(data);
         return new PreloadFile(this, path, flag, stats, data);
     }
-    async createFile(path, flag, mode, cred) {
+    async createFile(path, flag, mode) {
         this.checkInitialized();
-        await this.writable.createFile(path, flag, mode, cred);
-        return this.openFile(path, flag, cred);
+        await this.writable.createFile(path, flag, mode);
+        return this.openFile(path, flag);
     }
-    createFileSync(path, flag, mode, cred) {
+    createFileSync(path, flag, mode) {
         this.checkInitialized();
-        this.writable.createFileSync(path, flag, mode, cred);
-        return this.openFileSync(path, flag, cred);
+        this.writable.createFileSync(path, flag, mode);
+        return this.openFileSync(path, flag);
     }
-    async link(srcpath, dstpath, cred) {
+    async link(srcpath, dstpath) {
         this.checkInitialized();
-        await this.writable.link(srcpath, dstpath, cred);
+        await this.writable.link(srcpath, dstpath);
     }
-    linkSync(srcpath, dstpath, cred) {
+    linkSync(srcpath, dstpath) {
         this.checkInitialized();
-        this.writable.linkSync(srcpath, dstpath, cred);
+        this.writable.linkSync(srcpath, dstpath);
     }
-    async unlink(path, cred) {
+    async unlink(path) {
         this.checkInitialized();
         this.checkPath(path);
-        if (!(await this.exists(path, cred))) {
+        if (!(await this.exists(path))) {
             throw ErrnoError.With('ENOENT', path, 'unlink');
         }
-        if (await this.writable.exists(path, cred)) {
-            await this.writable.unlink(path, cred);
+        if (await this.writable.exists(path)) {
+            await this.writable.unlink(path);
         }
         // if it still exists add to the delete log
-        if (await this.exists(path, cred)) {
-            await this.deletePath(path, cred);
+        if (await this.exists(path)) {
+            await this.deletePath(path);
         }
     }
-    unlinkSync(path, cred) {
+    unlinkSync(path) {
         this.checkInitialized();
         this.checkPath(path);
-        if (!this.existsSync(path, cred)) {
+        if (!this.existsSync(path)) {
             throw ErrnoError.With('ENOENT', path, 'unlink');
         }
-        if (this.writable.existsSync(path, cred)) {
-            this.writable.unlinkSync(path, cred);
+        if (this.writable.existsSync(path)) {
+            this.writable.unlinkSync(path);
         }
         // if it still exists add to the delete log
-        if (this.existsSync(path, cred)) {
-            void this.deletePath(path, cred);
+        if (this.existsSync(path)) {
+            void this.deletePath(path);
         }
     }
-    async rmdir(path, cred) {
+    async rmdir(path) {
         this.checkInitialized();
-        if (!(await this.exists(path, cred))) {
+        if (!(await this.exists(path))) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
-        if (await this.writable.exists(path, cred)) {
-            await this.writable.rmdir(path, cred);
+        if (await this.writable.exists(path)) {
+            await this.writable.rmdir(path);
         }
-        if (await this.exists(path, cred)) {
+        if (await this.exists(path)) {
             // Check if directory is empty.
-            if ((await this.readdir(path, cred)).length > 0) {
+            if ((await this.readdir(path)).length > 0) {
                 throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                await this.deletePath(path, cred);
+                await this.deletePath(path);
             }
         }
     }
-    rmdirSync(path, cred) {
+    rmdirSync(path) {
         this.checkInitialized();
-        if (!this.existsSync(path, cred)) {
+        if (!this.existsSync(path)) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
-        if (this.writable.existsSync(path, cred)) {
-            this.writable.rmdirSync(path, cred);
+        if (this.writable.existsSync(path)) {
+            this.writable.rmdirSync(path);
         }
-        if (this.existsSync(path, cred)) {
+        if (this.existsSync(path)) {
             // Check if directory is empty.
-            if (this.readdirSync(path, cred).length > 0) {
+            if (this.readdirSync(path).length > 0) {
                 throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                void this.deletePath(path, cred);
+                void this.deletePath(path);
             }
         }
     }
-    async mkdir(path, mode, cred) {
+    async mkdir(path, mode) {
         this.checkInitialized();
-        if (await this.exists(path, cred)) {
+        if (await this.exists(path)) {
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
-        await this.createParentDirectories(path, cred);
-        await this.writable.mkdir(path, mode, cred);
+        await this.createParentDirectories(path);
+        await this.writable.mkdir(path, mode);
     }
-    mkdirSync(path, mode, cred) {
+    mkdirSync(path, mode) {
         this.checkInitialized();
-        if (this.existsSync(path, cred)) {
+        if (this.existsSync(path)) {
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // The below will throw should any of the parent directories fail to exist on _writable.
-        this.createParentDirectoriesSync(path, cred);
-        this.writable.mkdirSync(path, mode, cred);
+        this.createParentDirectoriesSync(path);
+        this.writable.mkdirSync(path, mode);
     }
-    async readdir(path, cred) {
+    async readdir(path) {
         this.checkInitialized();
-        const dirStats = await this.stat(path, cred);
+        const dirStats = await this.stat(path);
         if (!dirStats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', path, 'readdir');
         }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         const contents = [];
         try {
-            contents.push(...(await this.writable.readdir(path, cred)));
+            contents.push(...(await this.writable.readdir(path)));
         }
         catch (e) {
             // NOP.
         }
         try {
-            contents.push(...(await this.readable.readdir(path, cred)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
+            contents.push(...(await this.readable.readdir(path)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -295,22 +292,22 @@ export class UnmutexedOverlayFS extends FileSystem {
             return result;
         });
     }
-    readdirSync(path, cred) {
+    readdirSync(path) {
         this.checkInitialized();
-        const dirStats = this.statSync(path, cred);
+        const dirStats = this.statSync(path);
         if (!dirStats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', path, 'readdir');
         }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         let contents = [];
         try {
-            contents = contents.concat(this.writable.readdirSync(path, cred));
+            contents = contents.concat(this.writable.readdirSync(path));
         }
         catch (e) {
             // NOP.
         }
         try {
-            contents = contents.concat(this.readable.readdirSync(path, cred).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
+            contents = contents.concat(this.readable.readdirSync(path).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -322,23 +319,23 @@ export class UnmutexedOverlayFS extends FileSystem {
             return result;
         });
     }
-    async deletePath(path, cred) {
+    async deletePath(path) {
         this._deletedFiles.add(path);
-        await this.updateLog(`d${path}\n`, cred);
+        await this.updateLog(`d${path}\n`);
     }
-    async updateLog(addition, cred) {
+    async updateLog(addition) {
         this._deleteLog += addition;
         if (this._deleteLogUpdatePending) {
             this._deleteLogUpdateNeeded = true;
             return;
         }
         this._deleteLogUpdatePending = true;
-        const log = await this.writable.openFile(deletionLogPath, parseFlag('w'), cred);
+        const log = await this.writable.openFile(deletionLogPath, parseFlag('w'));
         try {
             await log.write(encode(this._deleteLog));
             if (this._deleteLogUpdateNeeded) {
                 this._deleteLogUpdateNeeded = false;
-                await this.updateLog('', cred);
+                await this.updateLog('');
             }
         }
         catch (e) {
@@ -378,27 +375,27 @@ export class UnmutexedOverlayFS extends FileSystem {
      * With the given path, create the needed parent directories on the writable storage
      * should they not exist. Use modes from the read-only storage.
      */
-    createParentDirectoriesSync(path, cred) {
+    createParentDirectoriesSync(path) {
         let parent = dirname(path), toCreate = [];
-        while (!this.writable.existsSync(parent, cred)) {
+        while (!this.writable.existsSync(parent)) {
             toCreate.push(parent);
             parent = dirname(parent);
         }
         toCreate = toCreate.reverse();
         for (const p of toCreate) {
-            this.writable.mkdirSync(p, this.statSync(p, cred).mode, cred);
+            this.writable.mkdirSync(p, this.statSync(p).mode);
         }
     }
-    async createParentDirectories(path, cred) {
+    async createParentDirectories(path) {
         let parent = dirname(path), toCreate = [];
-        while (!(await this.writable.exists(parent, cred))) {
+        while (!(await this.writable.exists(parent))) {
             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);
+            const stats = await this.stat(p);
+            await this.writable.mkdir(p, stats.mode);
         }
     }
     /**
@@ -406,53 +403,53 @@ export class UnmutexedOverlayFS extends FileSystem {
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
      */
-    operateOnWritable(path, cred) {
-        if (!this.existsSync(path, cred)) {
+    operateOnWritable(path) {
+        if (!this.existsSync(path)) {
             throw ErrnoError.With('ENOENT', path, 'operateOnWriteable');
         }
-        if (!this.writable.existsSync(path, cred)) {
+        if (!this.writable.existsSync(path)) {
             // File is on readable storage. Copy to writable storage before
             // changing its mode.
-            this.copyToWritableSync(path, cred);
+            this.copyToWritableSync(path);
         }
     }
-    async operateOnWritableAsync(path, cred) {
-        if (!(await this.exists(path, cred))) {
+    async operateOnWritableAsync(path) {
+        if (!(await this.exists(path))) {
             throw ErrnoError.With('ENOENT', path, 'operateOnWritable');
         }
-        if (!(await this.writable.exists(path, cred))) {
-            return this.copyToWritable(path, cred);
+        if (!(await this.writable.exists(path))) {
+            return this.copyToWritable(path);
         }
     }
     /**
      * Copy from readable to writable storage.
      * PRECONDITION: File does not exist on writable storage.
      */
-    copyToWritableSync(path, cred) {
-        const stats = this.statSync(path, cred);
+    copyToWritableSync(path) {
+        const stats = this.statSync(path);
         if (stats.isDirectory()) {
-            this.writable.mkdirSync(path, stats.mode, cred);
+            this.writable.mkdirSync(path, stats.mode);
             return;
         }
         const data = new Uint8Array(stats.size);
-        const readable = this.readable.openFileSync(path, parseFlag('r'), cred);
+        const readable = this.readable.openFileSync(path, parseFlag('r'));
         readable.readSync(data);
         readable.closeSync();
-        const writable = this.writable.openFileSync(path, parseFlag('w'), cred);
+        const writable = this.writable.openFileSync(path, parseFlag('w'));
         writable.writeSync(data);
         writable.closeSync();
     }
-    async copyToWritable(path, cred) {
-        const stats = await this.stat(path, cred);
+    async copyToWritable(path) {
+        const stats = await this.stat(path);
         if (stats.isDirectory()) {
-            await this.writable.mkdir(path, stats.mode, cred);
+            await this.writable.mkdir(path, stats.mode);
             return;
         }
         const data = new Uint8Array(stats.size);
-        const readable = await this.readable.openFile(path, parseFlag('r'), cred);
+        const readable = await this.readable.openFile(path, parseFlag('r'));
         await readable.read(data);
         await readable.close();
-        const writable = await this.writable.openFile(path, parseFlag('w'), cred);
+        const writable = await this.writable.openFile(path, parseFlag('w'));
         await writable.write(data);
         await writable.close();
     }