@zenfs/core 0.16.3 → 0.17.0

package/dist/backends/overlay.js

@@ -2,7 +2,7 @@ import { FileSystem } from '../filesystem.js';
 import { ErrnoError, Errno } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
 import { Stats } from '../stats.js';
-import { LockedFS } from './locked.js';
+import { Mutexed } from '../mixins/mutexed.js';
 import { dirname } from '../emulation/path.js';
 import { rootCred } from '../cred.js';
 import { decode, encode } from '../utils.js';
@@ -14,14 +14,14 @@ const deletionLogPath = '/.deleted';
  * 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.
+ * This class contains no locking whatsoever. It is mutexed to prevent races.
  *
  * @internal
  */
-export class UnlockedOverlayFS extends FileSystem {
+export class UnmutexedOverlayFS extends FileSystem {
     async ready() {
-        await this._readable.ready();
-        await this._writable.ready();
+        await this.readable.ready();
+        await this.writable.ready();
         await this._ready;
     }
     constructor({ writable, readable }) {
@@ -34,9 +34,9 @@ export class UnlockedOverlayFS extends FileSystem {
         // If 'true', a delete log update is needed after the scheduled delete log
         // update finishes.
         this._deleteLogUpdateNeeded = false;
-        this._writable = writable;
-        this._readable = readable;
-        if (this._writable.metadata().readonly) {
+        this.writable = writable;
+        this.readable = readable;
+        if (this.writable.metadata().readonly) {
             throw new ErrnoError(Errno.EINVAL, 'Writable file system must be writable.');
         }
         this._ready = this._initialize();
@@ -47,24 +47,18 @@ export class UnlockedOverlayFS extends FileSystem {
             name: OverlayFS.name,
         };
     }
-    getOverlayedFileSystems() {
-        return {
-            readable: this._readable,
-            writable: this._writable,
-        };
-    }
     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);
+        if (!(await this.writable.exists(path, cred))) {
+            await this.writable.createFile(path, 'w', 0o644, cred);
         }
-        await this._writable.sync(path, data, stats);
+        await this.writable.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
         const cred = stats.cred(0, 0);
         this.createParentDirectoriesSync(path, cred);
-        this._writable.syncSync(path, data, stats);
+        this.writable.syncSync(path, data, stats);
     }
     /**
      * Called once to load up metadata stored on the writable file system.
@@ -76,7 +70,7 @@ export class UnlockedOverlayFS 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'), rootCred);
             const { size } = await file.stat();
             const { buffer } = await file.read(new Uint8Array(size));
             this._deleteLog = decode(buffer);
@@ -102,7 +96,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkPath(oldPath);
         this.checkPath(newPath);
         try {
-            await this._writable.rename(oldPath, newPath, cred);
+            await this.writable.rename(oldPath, newPath, cred);
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
@@ -115,7 +109,7 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkPath(oldPath);
         this.checkPath(newPath);
         try {
-            this._writable.renameSync(oldPath, newPath, cred);
+            this.writable.renameSync(oldPath, newPath, cred);
         }
         catch (e) {
             if (this._deletedFiles.has(oldPath)) {
@@ -126,13 +120,13 @@ export class UnlockedOverlayFS extends FileSystem {
     async stat(path, cred) {
         this.checkInitialized();
         try {
-            return await this._writable.stat(path, cred);
+            return await this.writable.stat(path, cred);
         }
         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, cred));
             // Make the oldStat's mode writable. Preserve the topmost part of the mode, which specifies the type
             oldStat.mode |= 0o222;
             return oldStat;
@@ -141,34 +135,34 @@ export class UnlockedOverlayFS extends FileSystem {
     statSync(path, cred) {
         this.checkInitialized();
         try {
-            return this._writable.statSync(path, cred);
+            return this.writable.statSync(path, cred);
         }
         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, cred));
             // 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);
+        if (await this.writable.exists(path, cred)) {
+            return this.writable.openFile(path, flag, cred);
         }
         // Create an OverlayFile.
-        const file = await this._readable.openFile(path, parseFlag('r'), cred);
+        const file = await this.readable.openFile(path, parseFlag('r'), cred);
         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);
+        if (this.writable.existsSync(path, cred)) {
+            return this.writable.openFileSync(path, flag, cred);
         }
         // Create an OverlayFile.
-        const file = this._readable.openFileSync(path, parseFlag('r'), cred);
+        const file = this.readable.openFileSync(path, parseFlag('r'), cred);
         const stats = new Stats(file.statSync());
         const data = new Uint8Array(stats.size);
         file.readSync(data);
@@ -176,21 +170,21 @@ export class UnlockedOverlayFS extends FileSystem {
     }
     async createFile(path, flag, mode, cred) {
         this.checkInitialized();
-        await this._writable.createFile(path, flag, mode, cred);
+        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);
+        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);
+        await this.writable.link(srcpath, dstpath, cred);
     }
     linkSync(srcpath, dstpath, cred) {
         this.checkInitialized();
-        this._writable.linkSync(srcpath, dstpath, cred);
+        this.writable.linkSync(srcpath, dstpath, cred);
     }
     async unlink(path, cred) {
         this.checkInitialized();
@@ -198,8 +192,8 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!(await this.exists(path, cred))) {
             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, cred)) {
+            await this.writable.unlink(path, cred);
         }
         // if it still exists add to the delete log
         if (await this.exists(path, cred)) {
@@ -212,8 +206,8 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!this.existsSync(path, cred)) {
             throw ErrnoError.With('ENOENT', path, 'unlink');
         }
-        if (this._writable.existsSync(path, cred)) {
-            this._writable.unlinkSync(path, cred);
+        if (this.writable.existsSync(path, cred)) {
+            this.writable.unlinkSync(path, cred);
         }
         // if it still exists add to the delete log
         if (this.existsSync(path, cred)) {
@@ -225,8 +219,8 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!(await this.exists(path, cred))) {
             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, cred)) {
+            await this.writable.rmdir(path, cred);
         }
         if (await this.exists(path, cred)) {
             // Check if directory is empty.
@@ -243,8 +237,8 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!this.existsSync(path, cred)) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
-        if (this._writable.existsSync(path, cred)) {
-            this._writable.rmdirSync(path, cred);
+        if (this.writable.existsSync(path, cred)) {
+            this.writable.rmdirSync(path, cred);
         }
         if (this.existsSync(path, cred)) {
             // Check if directory is empty.
@@ -263,7 +257,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         // 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.writable.mkdir(path, mode, cred);
     }
     mkdirSync(path, mode, cred) {
         this.checkInitialized();
@@ -272,7 +266,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         // 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.writable.mkdirSync(path, mode, cred);
     }
     async readdir(path, cred) {
         this.checkInitialized();
@@ -283,13 +277,13 @@ export class UnlockedOverlayFS extends FileSystem {
         // 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, cred)));
         }
         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, cred)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -310,13 +304,13 @@ export class UnlockedOverlayFS extends FileSystem {
         // 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, cred));
         }
         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, cred).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
@@ -339,7 +333,7 @@ export class UnlockedOverlayFS extends FileSystem {
             return;
         }
         this._deleteLogUpdatePending = true;
-        const log = await this._writable.openFile(deletionLogPath, parseFlag('w'), cred);
+        const log = await this.writable.openFile(deletionLogPath, parseFlag('w'), cred);
         try {
             await log.write(encode(this._deleteLog));
             if (this._deleteLogUpdateNeeded) {
@@ -386,25 +380,25 @@ export class UnlockedOverlayFS extends FileSystem {
      */
     createParentDirectoriesSync(path, cred) {
         let parent = dirname(path), toCreate = [];
-        while (!this._writable.existsSync(parent, cred)) {
+        while (!this.writable.existsSync(parent, cred)) {
             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, cred).mode, cred);
         }
     }
     async createParentDirectories(path, cred) {
         let parent = dirname(path), toCreate = [];
-        while (!(await this._writable.exists(parent, cred))) {
+        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);
+            await this.writable.mkdir(p, stats.mode, cred);
         }
     }
     /**
@@ -416,7 +410,7 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!this.existsSync(path, cred)) {
             throw ErrnoError.With('ENOENT', path, 'operateOnWriteable');
         }
-        if (!this._writable.existsSync(path, cred)) {
+        if (!this.writable.existsSync(path, cred)) {
             // File is on readable storage. Copy to writable storage before
             // changing its mode.
             this.copyToWritableSync(path, cred);
@@ -426,7 +420,7 @@ export class UnlockedOverlayFS extends FileSystem {
         if (!(await this.exists(path, cred))) {
             throw ErrnoError.With('ENOENT', path, 'operateOnWritable');
         }
-        if (!(await this._writable.exists(path, cred))) {
+        if (!(await this.writable.exists(path, cred))) {
             return this.copyToWritable(path, cred);
         }
     }
@@ -437,28 +431,28 @@ export class UnlockedOverlayFS extends FileSystem {
     copyToWritableSync(path, cred) {
         const stats = this.statSync(path, cred);
         if (stats.isDirectory()) {
-            this._writable.mkdirSync(path, stats.mode, cred);
+            this.writable.mkdirSync(path, stats.mode, cred);
             return;
         }
         const data = new Uint8Array(stats.size);
-        const readable = this._readable.openFileSync(path, parseFlag('r'), cred);
+        const readable = this.readable.openFileSync(path, parseFlag('r'), cred);
         readable.readSync(data);
         readable.closeSync();
-        const writable = this._writable.openFileSync(path, parseFlag('w'), cred);
+        const writable = this.writable.openFileSync(path, parseFlag('w'), cred);
         writable.writeSync(data);
         writable.closeSync();
     }
     async copyToWritable(path, cred) {
         const stats = await this.stat(path, cred);
         if (stats.isDirectory()) {
-            await this._writable.mkdir(path, stats.mode, cred);
+            await this.writable.mkdir(path, stats.mode, cred);
             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'), cred);
         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'), cred);
         await writable.write(data);
         await writable.close();
     }
@@ -469,27 +463,9 @@ export class UnlockedOverlayFS extends FileSystem {
  * file system.
  * @internal
  */
-export class OverlayFS extends LockedFS {
-    /**
-     * @param options The options to initialize the OverlayFS with
-     */
-    constructor(options) {
-        super(new UnlockedOverlayFS(options));
-    }
-    getOverlayedFileSystems() {
-        return super.fs.getOverlayedFileSystems();
-    }
-    getDeletionLog() {
-        return super.fs.getDeletionLog();
-    }
-    resDeletionLog() {
-        return super.fs.getDeletionLog();
-    }
-    unwrap() {
-        return super.fs;
-    }
+export class OverlayFS extends Mutexed(UnmutexedOverlayFS) {
 }
-export const Overlay = {
+const _Overlay = {
     name: 'Overlay',
     options: {
         writable: {
@@ -510,3 +486,4 @@ export const Overlay = {
         return new OverlayFS(options);
     },
 };
+export const Overlay = _Overlay;

package/dist/backends/port/fs.d.ts

@@ -53,7 +53,7 @@ interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
     method: TMethod;
     args: Parameters<FSMethods[TMethod]>;
 }
-declare const PortFS_base: import("../../filesystem.js").Mixin<typeof FileSystem, {
+declare const PortFS_base: import("../../mixins/shared.js").Mixin<typeof FileSystem, {
     _sync?: FileSystem | undefined;
     queueDone(): Promise<void>;
     ready(): Promise<void>;
@@ -111,7 +111,7 @@ export type FileOrFSRequest = FSRequest | FileRequest;
 export declare function handleRequest(port: RPC.Port, fs: FileSystem, request: FileOrFSRequest): Promise<void>;
 export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
 export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
-export declare const Port: {
+export declare const _Port: {
     name: string;
     options: {
         port: {
@@ -129,5 +129,9 @@ export declare const Port: {
     isAvailable(): Promise<boolean>;
     create(options: RPC.Options): PortFS;
 };
+type _port = typeof _Port;
+interface Port extends _port {
+}
+export declare const Port: Port;
 export declare function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 export {};

package/dist/backends/port/fs.js

@@ -1,6 +1,7 @@
 import { Errno, ErrnoError } from '../../error.js';
 import { File } from '../../file.js';
-import { Async, FileSystem } from '../../filesystem.js';
+import { FileSystem } from '../../filesystem.js';
+import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
@@ -210,7 +211,7 @@ export function attachFS(port, fs) {
 export function detachFS(port, fs) {
     RPC.detach(port, request => handleRequest(port, fs, request));
 }
-export const Port = {
+export const _Port = {
     name: 'Port',
     options: {
         port: {
@@ -237,6 +238,7 @@ export const Port = {
         return new PortFS(options);
     },
 };
+export const Port = _Port;
 export async function resolveRemoteMount(port, config, _depth = 0) {
     const stopAndReplay = RPC.catchMessages(port);
     const fs = await resolveMountConfig(config, _depth);