@zenfs/core 0.10.0 → 0.11.1

package/dist/backends/{Overlay.js → 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 { LockedFS } from './locked.js';
 import { dirname } from '../emulation/path.js';
 import { rootCred } from '../cred.js';
 import { decode, encode } from '../utils.js';
@@ -23,7 +23,6 @@ export class UnlockedOverlayFS extends FileSystem {
         await this._readable.ready();
         await this._writable.ready();
         await this._ready;
-        return this;
     }
     constructor({ writable, readable }) {
         super();
@@ -121,31 +120,31 @@ export class UnlockedOverlayFS extends FileSystem {
             }
         }
     }
-    async stat(p, cred) {
+    async stat(path, cred) {
         this.checkInitialized();
         try {
-            return this._writable.stat(p, cred);
+            return this._writable.stat(path, cred);
         }
         catch (e) {
-            if (this._deletedFiles.has(p)) {
-                throw ErrnoError.With('ENOENT', p, 'stat');
+            if (this._deletedFiles.has(path)) {
+                throw ErrnoError.With('ENOENT', path, 'stat');
             }
-            const oldStat = new Stats(await this._readable.stat(p, 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;
         }
     }
-    statSync(p, cred) {
+    statSync(path, cred) {
         this.checkInitialized();
         try {
-            return this._writable.statSync(p, cred);
+            return this._writable.statSync(path, cred);
         }
         catch (e) {
-            if (this._deletedFiles.has(p)) {
-                throw ErrnoError.With('ENOENT', p, 'stat');
+            if (this._deletedFiles.has(path)) {
+                throw ErrnoError.With('ENOENT', path, 'stat');
             }
-            const oldStat = new Stats(this._readable.statSync(p, 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;
@@ -190,145 +189,145 @@ export class UnlockedOverlayFS extends FileSystem {
         this.checkInitialized();
         this._writable.linkSync(srcpath, dstpath, cred);
     }
-    async unlink(p, cred) {
+    async unlink(path, cred) {
         this.checkInitialized();
-        this.checkPath(p);
-        if (!(await this.exists(p, cred))) {
-            throw ErrnoError.With('ENOENT', p, 'unlink');
+        this.checkPath(path);
+        if (!(await this.exists(path, cred))) {
+            throw ErrnoError.With('ENOENT', path, 'unlink');
         }
-        if (await this._writable.exists(p, cred)) {
-            await this._writable.unlink(p, 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(p, cred)) {
-            this.deletePath(p, cred);
+        if (await this.exists(path, cred)) {
+            this.deletePath(path, cred);
         }
     }
-    unlinkSync(p, cred) {
+    unlinkSync(path, cred) {
         this.checkInitialized();
-        this.checkPath(p);
-        if (!this.existsSync(p, cred)) {
-            throw ErrnoError.With('ENOENT', p, 'unlink');
+        this.checkPath(path);
+        if (!this.existsSync(path, cred)) {
+            throw ErrnoError.With('ENOENT', path, 'unlink');
         }
-        if (this._writable.existsSync(p, cred)) {
-            this._writable.unlinkSync(p, cred);
+        if (this._writable.existsSync(path, cred)) {
+            this._writable.unlinkSync(path, cred);
         }
         // if it still exists add to the delete log
-        if (this.existsSync(p, cred)) {
-            this.deletePath(p, cred);
+        if (this.existsSync(path, cred)) {
+            this.deletePath(path, cred);
         }
     }
-    async rmdir(p, cred) {
+    async rmdir(path, cred) {
         this.checkInitialized();
-        if (!(await this.exists(p, cred))) {
-            throw ErrnoError.With('ENOENT', p, 'rmdir');
+        if (!(await this.exists(path, cred))) {
+            throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
-        if (await this._writable.exists(p, cred)) {
-            await this._writable.rmdir(p, cred);
+        if (await this._writable.exists(path, cred)) {
+            await this._writable.rmdir(path, cred);
         }
-        if (await this.exists(p, cred)) {
+        if (await this.exists(path, cred)) {
             // Check if directory is empty.
-            if ((await this.readdir(p, cred)).length > 0) {
-                throw ErrnoError.With('ENOTEMPTY', p, 'rmdir');
+            if ((await this.readdir(path, cred)).length > 0) {
+                throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                this.deletePath(p, cred);
+                this.deletePath(path, cred);
             }
         }
     }
-    rmdirSync(p, cred) {
+    rmdirSync(path, cred) {
         this.checkInitialized();
-        if (!this.existsSync(p, cred)) {
-            throw ErrnoError.With('ENOENT', p, 'rmdir');
+        if (!this.existsSync(path, cred)) {
+            throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
-        if (this._writable.existsSync(p, cred)) {
-            this._writable.rmdirSync(p, cred);
+        if (this._writable.existsSync(path, cred)) {
+            this._writable.rmdirSync(path, cred);
         }
-        if (this.existsSync(p, cred)) {
+        if (this.existsSync(path, cred)) {
             // Check if directory is empty.
-            if (this.readdirSync(p, cred).length > 0) {
-                throw ErrnoError.With('ENOTEMPTY', p, 'rmdir');
+            if (this.readdirSync(path, cred).length > 0) {
+                throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                this.deletePath(p, cred);
+                this.deletePath(path, cred);
             }
         }
     }
-    async mkdir(p, mode, cred) {
+    async mkdir(path, mode, cred) {
         this.checkInitialized();
-        if (await this.exists(p, cred)) {
-            throw ErrnoError.With('EEXIST', p, 'mkdir');
+        if (await this.exists(path, cred)) {
+            throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // 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);
+        await this.createParentDirectories(path, cred);
+        await this._writable.mkdir(path, mode, cred);
     }
-    mkdirSync(p, mode, cred) {
+    mkdirSync(path, mode, cred) {
         this.checkInitialized();
-        if (this.existsSync(p, cred)) {
-            throw ErrnoError.With('EEXIST', p, 'mkdir');
+        if (this.existsSync(path, cred)) {
+            throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
         // 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);
+        this.createParentDirectoriesSync(path, cred);
+        this._writable.mkdirSync(path, mode, cred);
     }
-    async readdir(p, cred) {
+    async readdir(path, cred) {
         this.checkInitialized();
-        const dirStats = await this.stat(p, cred);
+        const dirStats = await this.stat(path, cred);
         if (!dirStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', p, 'readdir');
+            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(p, cred)));
+            contents.push(...(await this._writable.readdir(path, cred)));
         }
         catch (e) {
             // NOP.
         }
         try {
-            contents.push(...(await this._readable.readdir(p, cred)).filter((fPath) => !this._deletedFiles.has(`${p}/${fPath}`)));
+            contents.push(...(await this._readable.readdir(path, cred)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
         }
         const seenMap = {};
-        return contents.filter((fileP) => {
-            const result = !seenMap[fileP];
-            seenMap[fileP] = true;
+        return contents.filter((path) => {
+            const result = !seenMap[path];
+            seenMap[path] = true;
             return result;
         });
     }
-    readdirSync(p, cred) {
+    readdirSync(path, cred) {
         this.checkInitialized();
-        const dirStats = this.statSync(p, cred);
+        const dirStats = this.statSync(path, cred);
         if (!dirStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', p, 'readdir');
+            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(p, cred));
+            contents = contents.concat(this._writable.readdirSync(path, cred));
         }
         catch (e) {
             // NOP.
         }
         try {
-            contents = contents.concat(this._readable.readdirSync(p, cred).filter((fPath) => !this._deletedFiles.has(`${p}/${fPath}`)));
+            contents = contents.concat(this._readable.readdirSync(path, cred).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
         catch (e) {
             // NOP.
         }
         const seenMap = {};
-        return contents.filter((fileP) => {
-            const result = !seenMap[fileP];
-            seenMap[fileP] = true;
+        return contents.filter((path) => {
+            const result = !seenMap[path];
+            seenMap[path] = true;
             return result;
         });
     }
-    deletePath(p, cred) {
-        this._deletedFiles.add(p);
-        this.updateLog(`d${p}\n`, cred);
+    deletePath(path, cred) {
+        this._deletedFiles.add(path);
+        this.updateLog(`d${path}\n`, cred);
     }
     async updateLog(addition, cred) {
         this._deleteLog += addition;
@@ -382,8 +381,8 @@ export class UnlockedOverlayFS 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(p, cred) {
-        let parent = dirname(p), toCreate = [];
+    createParentDirectoriesSync(path, cred) {
+        let parent = dirname(path), toCreate = [];
         while (!this._writable.existsSync(parent, cred)) {
             toCreate.push(parent);
             parent = dirname(parent);
@@ -393,8 +392,8 @@ export class UnlockedOverlayFS extends FileSystem {
             this._writable.mkdirSync(p, this.statSync(p, cred).mode, cred);
         }
     }
-    async createParentDirectories(p, cred) {
-        let parent = dirname(p), toCreate = [];
+    async createParentDirectories(path, cred) {
+        let parent = dirname(path), toCreate = [];
         while (!(await this._writable.exists(parent, cred))) {
             toCreate.push(parent);
             parent = dirname(parent);
@@ -410,53 +409,53 @@ export class UnlockedOverlayFS 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(p, cred) {
-        if (!this.existsSync(p, cred)) {
-            throw ErrnoError.With('ENOENT', p, 'operateOnWriteable');
+    operateOnWritable(path, cred) {
+        if (!this.existsSync(path, cred)) {
+            throw ErrnoError.With('ENOENT', path, 'operateOnWriteable');
         }
-        if (!this._writable.existsSync(p, cred)) {
+        if (!this._writable.existsSync(path, cred)) {
             // File is on readable storage. Copy to writable storage before
             // changing its mode.
-            this.copyToWritableSync(p, cred);
+            this.copyToWritableSync(path, cred);
         }
     }
-    async operateOnWritableAsync(p, cred) {
-        if (!(await this.exists(p, cred))) {
-            throw ErrnoError.With('ENOENT', p, 'operateOnWritable');
+    async operateOnWritableAsync(path, cred) {
+        if (!(await this.exists(path, cred))) {
+            throw ErrnoError.With('ENOENT', path, 'operateOnWritable');
         }
-        if (!(await this._writable.exists(p, cred))) {
-            return this.copyToWritable(p, cred);
+        if (!(await this._writable.exists(path, cred))) {
+            return this.copyToWritable(path, cred);
         }
     }
     /**
      * Copy from readable to writable storage.
      * PRECONDITION: File does not exist on writable storage.
      */
-    copyToWritableSync(p, cred) {
-        const stats = this.statSync(p, cred);
+    copyToWritableSync(path, cred) {
+        const stats = this.statSync(path, cred);
         if (stats.isDirectory()) {
-            this._writable.mkdirSync(p, stats.mode, cred);
+            this._writable.mkdirSync(path, stats.mode, cred);
             return;
         }
         const data = new Uint8Array(stats.size);
-        const readable = this._readable.openFileSync(p, parseFlag('r'), cred);
+        const readable = this._readable.openFileSync(path, parseFlag('r'), cred);
         readable.readSync(data);
         readable.closeSync();
-        const writable = this._writable.openFileSync(p, parseFlag('w'), cred);
+        const writable = this._writable.openFileSync(path, parseFlag('w'), cred);
         writable.writeSync(data);
         writable.closeSync();
     }
-    async copyToWritable(p, cred) {
-        const stats = await this.stat(p, cred);
+    async copyToWritable(path, cred) {
+        const stats = await this.stat(path, cred);
         if (stats.isDirectory()) {
-            await this._writable.mkdir(p, stats.mode, cred);
+            await this._writable.mkdir(path, stats.mode, cred);
             return;
         }
         const data = new Uint8Array(stats.size);
-        const readable = await this._readable.openFile(p, 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(p, parseFlag('w'), cred);
+        const writable = await this._writable.openFile(path, parseFlag('w'), cred);
         await writable.write(data);
         await writable.close();
     }
@@ -468,10 +467,6 @@ export class UnlockedOverlayFS extends FileSystem {
  * @internal
  */
 export class OverlayFS extends LockedFS {
-    async ready() {
-        await super.ready();
-        return this;
-    }
     /**
      * @param options The options to initialize the OverlayFS with
      */

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

@@ -1,13 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+import type { FileReadResult } from 'node:fs/promises';
+import type { ExtractProperties } from 'utilium';
 import type { Cred } from '../../cred.js';
-import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { File } from '../../file.js';
+import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
-import type { SyncStoreFS } from '../SyncStore.js';
 import * as RPC from './rpc.js';
-import type { ExtractProperties } from 'utilium';
-import type { FileReadResult } from 'node:fs/promises';
 type FileMethods = ExtractProperties<File, (...args: any[]) => Promise<any>>;
 type FileMethod = keyof FileMethods;
 export declare class PortFile extends File {
@@ -44,7 +43,7 @@ declare const PortFS_base: (abstract new (...args: any[]) => {
     _sync: FileSystem;
     queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
-    ready(): Promise<any>;
+    ready(): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
@@ -80,7 +79,7 @@ export declare class PortFS extends PortFS_base {
     /**
      * @hidden
      */
-    _sync: SyncStoreFS;
+    _sync: import("../store/fs.js").StoreFS;
     /**
      * Constructs a new PortFS instance that connects with ZenFS running on
      * the specified port.
@@ -88,17 +87,17 @@ export declare class PortFS extends PortFS_base {
     constructor(options: RPC.Options);
     metadata(): FileSystemMetadata;
     protected rpc<const T extends FSMethod>(method: T, ...args: Parameters<FSMethods[T]>): Promise<Awaited<ReturnType<FSMethods[T]>>>;
-    ready(): Promise<this>;
+    ready(): Promise<void>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    stat(p: string, cred: Cred): Promise<Stats>;
+    stat(path: string, cred: Cred): Promise<Stats>;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    openFile(p: string, flag: string, cred: Cred): Promise<File>;
-    createFile(p: string, flag: string, mode: number, cred: Cred): Promise<File>;
-    unlink(p: string, cred: Cred): Promise<void>;
-    rmdir(p: string, cred: Cred): Promise<void>;
-    mkdir(p: string, mode: number, cred: Cred): Promise<void>;
-    readdir(p: string, cred: Cred): Promise<string[]>;
-    exists(p: string, cred: Cred): Promise<boolean>;
+    openFile(path: string, flag: string, cred: Cred): Promise<File>;
+    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
+    unlink(path: string, cred: Cred): Promise<void>;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    exists(path: string, cred: Cred): Promise<boolean>;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
 }
 export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
@@ -118,7 +117,7 @@ export declare const Port: {
             description: string;
         };
     };
-    isAvailable(port?: RPC.Port): Promise<boolean>;
+    isAvailable(): Promise<boolean>;
     create(options: RPC.Options): PortFS;
 };
 export {};

package/dist/backends/port/fs.js

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ErrnoError, Errno } from '../../error.js';
-import { FileSystem, Async } from '../../filesystem.js';
+import { Errno, ErrnoError } from '../../error.js';
 import { File } from '../../file.js';
+import { Async, FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
-import { InMemory } from '../InMemory.js';
+import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
 export class PortFile extends File {
     constructor(fs, fd, path, position) {
@@ -119,37 +118,36 @@ export class PortFS extends Async(FileSystem) {
     async ready() {
         await this.rpc('ready');
         await super.ready();
-        return this;
     }
     rename(oldPath, newPath, cred) {
         return this.rpc('rename', oldPath, newPath, cred);
     }
-    async stat(p, cred) {
-        return new Stats(await this.rpc('stat', p, cred));
+    async stat(path, cred) {
+        return new Stats(await this.rpc('stat', path, cred));
     }
     sync(path, data, stats) {
         return this.rpc('sync', path, data, stats);
     }
-    openFile(p, flag, cred) {
-        return this.rpc('openFile', p, flag, cred);
+    openFile(path, flag, cred) {
+        return this.rpc('openFile', path, flag, cred);
     }
-    createFile(p, flag, mode, cred) {
-        return this.rpc('createFile', p, flag, mode, cred);
+    createFile(path, flag, mode, cred) {
+        return this.rpc('createFile', path, flag, mode, cred);
     }
-    unlink(p, cred) {
-        return this.rpc('unlink', p, cred);
+    unlink(path, cred) {
+        return this.rpc('unlink', path, cred);
     }
-    rmdir(p, cred) {
-        return this.rpc('rmdir', p, cred);
+    rmdir(path, cred) {
+        return this.rpc('rmdir', path, cred);
     }
-    mkdir(p, mode, cred) {
-        return this.rpc('mkdir', p, mode, cred);
+    mkdir(path, mode, cred) {
+        return this.rpc('mkdir', path, mode, cred);
     }
-    readdir(p, cred) {
-        return this.rpc('readdir', p, cred);
+    readdir(path, cred) {
+        return this.rpc('readdir', path, cred);
     }
-    exists(p, cred) {
-        return this.rpc('exists', p, cred);
+    exists(path, cred) {
+        return this.rpc('exists', path, cred);
     }
     link(srcpath, dstpath, cred) {
         return this.rpc('link', srcpath, dstpath, cred);
@@ -232,7 +230,7 @@ export const Port = {
             description: 'How long to wait before the request times out',
         },
     },
-    async isAvailable(port) {
+    async isAvailable() {
         return true;
     },
     create(options) {