@zenfs/core 2.0.0 → 2.1.1

package/dist/backends/passthrough.js

@@ -50,11 +50,10 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { ErrnoError } from '../internal/error.js';
+import { warn } from 'kerium/log';
 import { FileSystem } from '../internal/filesystem.js';
 import { isDirectory } from '../internal/inode.js';
 import { resolve } from '../path.js';
-import { warn } from '../internal/log.js';
 export class PassthroughFS extends FileSystem {
     constructor(nodeFS, prefix) {
         super(0x6e6f6465, 'nodefs');
@@ -71,327 +70,213 @@ export class PassthroughFS extends FileSystem {
     path(path) {
         return this.prefix + path;
     }
-    error(err, path) {
-        const error = err;
-        throw ErrnoError.With(error.code, path, error.syscall);
-    }
     /**
      * Rename a file or directory.
      */
     async rename(oldPath, newPath) {
-        try {
-            await this.nodeFS.promises.rename(this.path(oldPath), this.path(newPath));
-        }
-        catch (err) {
-            this.error(err, oldPath);
-        }
+        await this.nodeFS.promises.rename(this.path(oldPath), this.path(newPath));
     }
     /**
      * Rename a file or directory synchronously.
      */
     renameSync(oldPath, newPath) {
-        try {
-            this.nodeFS.renameSync(this.path(oldPath), this.path(newPath));
-        }
-        catch (err) {
-            this.error(err, oldPath);
-        }
+        this.nodeFS.renameSync(this.path(oldPath), this.path(newPath));
     }
     /**
      * Get file statistics.
      */
     async stat(path) {
-        try {
-            return await this.nodeFS.promises.stat(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        return await this.nodeFS.promises.stat(this.path(path));
     }
     /**
      * Get file statistics synchronously.
      */
     statSync(path) {
-        try {
-            return this.nodeFS.statSync(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        return this.nodeFS.statSync(this.path(path));
     }
     async touch(path, metadata) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const handle = __addDisposableResource(env_1, await this.nodeFS.promises.open(this.path(path), 'w'), true);
-                await handle.chmod(metadata.mode);
-                await handle.chown(metadata.uid, metadata.gid);
-                await handle.utimes(metadata.atimeMs, metadata.mtimeMs);
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
-            }
+            const handle = __addDisposableResource(env_1, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+            await handle.chmod(metadata.mode);
+            await handle.chown(metadata.uid, metadata.gid);
+            await handle.utimes(metadata.atimeMs, metadata.mtimeMs);
         }
-        catch (err) {
-            this.error(err, path);
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
         }
     }
     touchSync(path, metadata) {
-        try {
-            this.nodeFS.chmodSync(this.path(path), metadata.mode);
-            this.nodeFS.chownSync(this.path(path), metadata.uid, metadata.gid);
-            this.nodeFS.utimesSync(this.path(path), metadata.atimeMs, metadata.mtimeMs);
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        this.nodeFS.chmodSync(this.path(path), metadata.mode);
+        this.nodeFS.chownSync(this.path(path), metadata.uid, metadata.gid);
+        this.nodeFS.utimesSync(this.path(path), metadata.atimeMs, metadata.mtimeMs);
     }
     /**
      * Unlink (delete) a file.
      */
     async unlink(path) {
-        try {
-            await this.nodeFS.promises.unlink(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        await this.nodeFS.promises.unlink(this.path(path));
     }
     /**
      * Unlink (delete) a file synchronously.
      */
     unlinkSync(path) {
-        try {
-            this.nodeFS.unlinkSync(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        this.nodeFS.unlinkSync(this.path(path));
     }
     /**
      * Create a directory.
      */
     async mkdir(path, options) {
-        try {
-            await this.nodeFS.promises.mkdir(this.path(path), options);
-            return await this.nodeFS.promises.stat(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        await this.nodeFS.promises.mkdir(this.path(path), options);
+        return await this.nodeFS.promises.stat(this.path(path));
     }
     /**
      * Create a directory synchronously.
      */
     mkdirSync(path, options) {
-        try {
-            this.nodeFS.mkdirSync(this.path(path), options);
-            return this.nodeFS.statSync(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        this.nodeFS.mkdirSync(this.path(path), options);
+        return this.nodeFS.statSync(this.path(path));
     }
     /**
      * Read the contents of a directory.
      */
     async readdir(path) {
-        try {
-            return await this.nodeFS.promises.readdir(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        return await this.nodeFS.promises.readdir(this.path(path));
     }
     /**
      * Read the contents of a directory synchronously.
      */
     readdirSync(path) {
-        try {
-            return this.nodeFS.readdirSync(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        return this.nodeFS.readdirSync(this.path(path));
     }
     /**
      * Create a file.
      */
     async createFile(path, options) {
-        try {
-            if (isDirectory(options)) {
-                await this.nodeFS.promises.mkdir(this.path(path), { mode: options.mode });
+        if (isDirectory(options)) {
+            await this.nodeFS.promises.mkdir(this.path(path), { mode: options.mode });
+        }
+        else {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'wx'), true);
+                await handle.close();
             }
-            else {
-                const env_2 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'wx'), true);
-                    await handle.close();
-                }
-                catch (e_2) {
-                    env_2.error = e_2;
-                    env_2.hasError = true;
-                }
-                finally {
-                    const result_2 = __disposeResources(env_2);
-                    if (result_2)
-                        await result_2;
-                }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                const result_2 = __disposeResources(env_2);
+                if (result_2)
+                    await result_2;
             }
-            return await this.nodeFS.promises.stat(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
         }
+        return await this.nodeFS.promises.stat(this.path(path));
     }
     /**
      * Create a file synchronously.
      */
     createFileSync(path, options) {
-        try {
-            if (isDirectory(options)) {
-                this.nodeFS.mkdirSync(this.path(path), { mode: options.mode });
-            }
-            else {
-                const fd = this.nodeFS.openSync(this.path(path), 'wx');
-                this.nodeFS.closeSync(fd);
-            }
-            return this.nodeFS.statSync(this.path(path));
+        if (isDirectory(options)) {
+            this.nodeFS.mkdirSync(this.path(path), { mode: options.mode });
         }
-        catch (err) {
-            this.error(err, path);
+        else {
+            const fd = this.nodeFS.openSync(this.path(path), 'wx');
+            this.nodeFS.closeSync(fd);
         }
+        return this.nodeFS.statSync(this.path(path));
     }
     /**
      * Remove a directory.
      */
     async rmdir(path) {
-        try {
-            await this.nodeFS.promises.rmdir(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        await this.nodeFS.promises.rmdir(this.path(path));
     }
     /**
      * Remove a directory synchronously.
      */
     rmdirSync(path) {
-        try {
-            this.nodeFS.rmdirSync(this.path(path));
-        }
-        catch (err) {
-            this.error(err, path);
-        }
+        this.nodeFS.rmdirSync(this.path(path));
     }
     /**
      * Synchronize data to the file system.
      */
-    async sync(path) {
+    async sync() {
         warn('Sync on passthrough is unnecessary');
     }
     /**
      * Synchronize data to the file system synchronously.
      */
-    syncSync(path) {
+    syncSync() {
         warn('Sync on passthrough is unnecessary');
     }
     /**
      * Create a hard link.
      */
     async link(target, link) {
-        try {
-            await this.nodeFS.promises.link(this.path(target), this.path(link));
-        }
-        catch (err) {
-            this.error(err, target);
-        }
+        await this.nodeFS.promises.link(this.path(target), this.path(link));
     }
     /**
      * Create a hard link synchronously.
      */
     linkSync(target, link) {
-        try {
-            this.nodeFS.linkSync(this.path(target), this.path(link));
-        }
-        catch (err) {
-            this.error(err, target);
-        }
+        this.nodeFS.linkSync(this.path(target), this.path(link));
     }
     async read(path, buffer, offset, end) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const env_3 = { stack: [], error: void 0, hasError: false };
-            try {
-                const handle = __addDisposableResource(env_3, await this.nodeFS.promises.open(this.path(path), 'r'), true);
-                await handle.read({ buffer, offset, length: end - offset });
-            }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
-            }
-            finally {
-                const result_3 = __disposeResources(env_3);
-                if (result_3)
-                    await result_3;
-            }
+            const handle = __addDisposableResource(env_3, await this.nodeFS.promises.open(this.path(path), 'r'), true);
+            await handle.read({ buffer, offset, length: end - offset });
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
-        catch (err) {
-            this.error(err, path);
+        finally {
+            const result_3 = __disposeResources(env_3);
+            if (result_3)
+                await result_3;
         }
     }
     readSync(path, buffer, offset, end) {
-        let fd;
+        const fd = this.nodeFS.openSync(this.path(path), 'r');
         try {
-            fd = this.nodeFS.openSync(this.path(path), 'r');
             this.nodeFS.readSync(fd, buffer, { offset, length: end - offset });
         }
-        catch (err) {
-            this.error(err, path);
-        }
         finally {
-            if (fd)
-                this.nodeFS.closeSync(fd);
+            this.nodeFS.closeSync(fd);
         }
     }
     async write(path, buffer, offset) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            const env_4 = { stack: [], error: void 0, hasError: false };
-            try {
-                const handle = __addDisposableResource(env_4, await this.nodeFS.promises.open(this.path(path), 'w'), true);
-                await handle.write(buffer, offset);
-            }
-            catch (e_4) {
-                env_4.error = e_4;
-                env_4.hasError = true;
-            }
-            finally {
-                const result_4 = __disposeResources(env_4);
-                if (result_4)
-                    await result_4;
-            }
+            const handle = __addDisposableResource(env_4, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+            await handle.write(buffer, offset);
         }
-        catch (err) {
-            this.error(err, path);
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            const result_4 = __disposeResources(env_4);
+            if (result_4)
+                await result_4;
         }
     }
     writeSync(path, buffer, offset) {
-        let fd;
+        const fd = this.nodeFS.openSync(this.path(path), 'w');
         try {
-            fd = this.nodeFS.openSync(this.path(path), 'w');
             this.nodeFS.writeSync(fd, buffer, offset);
         }
-        catch (err) {
-            this.error(err, path);
-        }
         finally {
-            if (fd)
-                this.nodeFS.closeSync(fd);
+            this.nodeFS.closeSync(fd);
         }
     }
 }

package/dist/backends/port.d.ts

@@ -48,7 +48,7 @@ export interface RPCMethods {
     touch(path: string, metadata: Uint8Array): void;
     exists(path: string): boolean;
     link(target: string, link: string): void;
-    sync(path: string): void;
+    sync(): void;
     read(path: string, buffer: Uint8Array, start: number, end: number): Uint8Array;
     write(path: string, buffer: Uint8Array, offset: number): void;
     stat(path: string): Uint8Array;
@@ -74,6 +74,14 @@ interface RPCRequest<TMethod extends RPCMethod = RPCMethod> extends RPCMessage {
     method: TMethod;
     args: Parameters<RPCMethods[TMethod]>;
 }
+/**
+ * An RPC executor
+ * @internal @hidden
+ */
+interface RPCExecutor extends PromiseWithResolvers<any> {
+    fs: PortFS;
+    timeout: ReturnType<typeof setTimeout>;
+}
 export declare function attach<T extends RPCMessage>(port: RPCPort, handler: (message: T) => unknown): void;
 export declare function detach<T extends RPCMessage>(port: RPCPort, handler: (message: T) => unknown): void;
 export declare function catchMessages<T extends Backend>(port: RPCPort): (fs: FilesystemOf<T>) => Promise<void>;
@@ -93,7 +101,12 @@ declare const PortFS_base: import("../index.js").Mixin<typeof FileSystem, import
 export declare class PortFS extends PortFS_base {
     readonly options: PortOptions;
     readonly port: RPCPort;
-    /**`
+    /**
+     * A map of outstanding RPC requests
+     * @internal @hidden
+     */
+    readonly _executors: Map<string, RPCExecutor>;
+    /**
      * @hidden
      */
     _sync: import("./index.js").StoreFS<import("./memory.js").InMemoryStore>;
@@ -106,7 +119,7 @@ export declare class PortFS extends PortFS_base {
     rename(oldPath: string, newPath: string): Promise<void>;
     stat(path: string): Promise<Inode>;
     touch(path: string, metadata: InodeLike | Inode): Promise<void>;
-    sync(path: string): Promise<void>;
+    sync(): Promise<void>;
     createFile(path: string, options: CreationOptions): Promise<Inode>;
     unlink(path: string): Promise<void>;
     rmdir(path: string): Promise<void>;

package/dist/backends/port.js

@@ -1,9 +1,9 @@
-import { pick, serialize } from 'utilium';
+import { Errno, Exception, withErrno } from 'kerium';
+import { err, info } from 'kerium/log';
+import { pick } from 'utilium';
 import { resolveMountConfig } from '../config.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { Inode } from '../internal/inode.js';
-import { err, info } from '../internal/log.js';
 import { Async } from '../mixins/async.js';
 import '../polyfills.js';
 import { _fnOpt } from './backend.js';
@@ -11,24 +11,38 @@ import { InMemory } from './memory.js';
 function isRPCMessage(arg) {
     return typeof arg == 'object' && arg != null && '_zenfs' in arg && !!arg._zenfs;
 }
+function disposeExecutors(id) {
+    const executor = executors.get(id);
+    if (!executor)
+        return;
+    if (executor.timeout) {
+        clearTimeout(executor.timeout);
+        if (typeof executor.timeout == 'object')
+            executor.timeout.unref();
+    }
+    executor.fs._executors.delete(id);
+    executors.delete(id);
+}
+/**
+ * A map of *all* outstanding RPC requests
+ */
 const executors = new Map();
-function request(request, { port, timeout = 1000, fs } = {}) {
+function request(request, { port, timeout: ms = 1000, fs }) {
     const stack = '\n' + new Error().stack.slice('Error:'.length);
     if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Can not make an RPC request without a port'));
+        throw err(withErrno('EINVAL', 'Can not make an RPC request without a port'));
     const { resolve, reject, promise } = Promise.withResolvers();
     const id = Math.random().toString(16).slice(10);
-    executors.set(id, { resolve, reject, promise, fs });
-    port.postMessage({ ...request, _zenfs: true, id, stack });
-    const _ = setTimeout(() => {
-        const error = err(new ErrnoError(Errno.EIO, 'RPC Failed', typeof request.args[0] == 'string' ? request.args[0] : '', request.method), {
-            fs,
-        });
+    const timeout = setTimeout(() => {
+        const error = err(withErrno('EIO', 'RPC Failed'));
         error.stack += stack;
+        disposeExecutors(id);
         reject(error);
-        if (typeof _ == 'object')
-            _.unref();
-    }, timeout);
+    }, ms);
+    const executor = { resolve, reject, promise, fs, timeout };
+    fs._executors.set(id, executor);
+    executors.set(id, executor);
+    port.postMessage({ ...request, _zenfs: true, id, stack });
     return promise;
 }
 // Why Typescript, WHY does the type need to be asserted even when the method is explicitly checked?
@@ -40,25 +54,25 @@ function handleResponse(response) {
     if (!isRPCMessage(response))
         return;
     if (!executors.has(response.id)) {
-        const error = err(new ErrnoError(Errno.EIO, 'Invalid RPC id:' + response.id));
+        const error = err(withErrno('EIO', 'Invalid RPC id: ' + response.id));
         error.stack += response.stack;
         throw error;
     }
     const { resolve, reject } = executors.get(response.id);
     if (response.error) {
-        const e = ErrnoError.fromJSON({ code: 'EIO', errno: Errno.EIO, ...response.error });
+        const e = Exception.fromJSON({ code: 'EIO', errno: Errno.EIO, ...response.error });
         e.stack += response.stack;
+        disposeExecutors(response.id);
         reject(e);
-        executors.delete(response.id);
         return;
     }
+    disposeExecutors(response.id);
     resolve(__responseMethod(response, 'stat', 'createFile', 'mkdir') ? new Inode(response.value) : response.value);
-    executors.delete(response.id);
     return;
 }
 export function attach(port, handler) {
     if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Cannot attach to non-existent port'));
+        throw err(withErrno('EINVAL', 'Cannot attach to non-existent port'));
     info('Attached handler to port: ' + handler.name);
     port['on' in port ? 'on' : 'addEventListener']('message', (message) => {
         handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
@@ -66,7 +80,7 @@ export function attach(port, handler) {
 }
 export function detach(port, handler) {
     if (!port)
-        throw err(new ErrnoError(Errno.EINVAL, 'Cannot detach from non-existent port'));
+        throw err(withErrno('EINVAL', 'Cannot detach from non-existent port'));
     info('Detached handler from port: ' + handler.name);
     port['off' in port ? 'off' : 'removeEventListener']('message', (message) => {
         handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
@@ -110,7 +124,12 @@ export class PortFS extends Async(FileSystem) {
     constructor(options) {
         super(0x706f7274, 'portfs');
         this.options = options;
-        /**`
+        /**
+         * A map of outstanding RPC requests
+         * @internal @hidden
+         */
+        this._executors = new Map();
+        /**
          * @hidden
          */
         this._sync = InMemory.create({ label: 'tmpfs:port' });
@@ -131,16 +150,24 @@ export class PortFS extends Async(FileSystem) {
         return this.rpc('rename', oldPath, newPath);
     }
     async stat(path) {
-        return new Inode(await this.rpc('stat', path));
+        const result = await this.rpc('stat', path);
+        return result instanceof Inode ? result : new Inode(result);
     }
     async touch(path, metadata) {
-        await this.rpc('touch', path, serialize(metadata instanceof Inode ? metadata : new Inode(metadata)));
+        const inode = metadata instanceof Inode ? metadata : new Inode(metadata);
+        await this.rpc('touch', path, new Uint8Array(inode.buffer, inode.byteOffset, inode.byteLength));
     }
-    sync(path) {
-        return this.rpc('sync', path);
+    async sync() {
+        await this.rpc('sync');
+        for (const executor of this._executors.values()) {
+            await executor.promise.catch(() => { });
+        }
     }
     async createFile(path, options) {
-        return new Inode(await this.rpc('createFile', path, options));
+        if (options instanceof Inode)
+            options = options.toJSON();
+        const result = await this.rpc('createFile', path, options);
+        return result instanceof Inode ? result : new Inode(result);
     }
     unlink(path) {
         return this.rpc('unlink', path);
@@ -149,7 +176,10 @@ export class PortFS extends Async(FileSystem) {
         return this.rpc('rmdir', path);
     }
     async mkdir(path, options) {
-        return new Inode(await this.rpc('mkdir', path, options));
+        if (options instanceof Inode)
+            options = options.toJSON();
+        const result = await this.rpc('mkdir', path, options);
+        return result instanceof Inode ? result : new Inode(result);
     }
     readdir(path) {
         return this.rpc('readdir', path);
@@ -187,8 +217,9 @@ export async function handleRequest(port, fs, request) {
             case 'mkdir': {
                 __requestMethod(request);
                 // @ts-expect-error 2556
-                const inode = await fs[request.method](...request.args);
-                value = serialize(inode instanceof Inode ? inode : new Inode(inode));
+                const md = await fs[request.method](...request.args);
+                const inode = md instanceof Inode ? md : new Inode(md);
+                value = new Uint8Array(inode.buffer, inode.byteOffset, inode.byteLength);
                 break;
             }
             case 'touch': {
@@ -204,7 +235,7 @@ export async function handleRequest(port, fs, request) {
         }
     }
     catch (e) {
-        error = e instanceof ErrnoError ? e.toJSON() : pick(e, 'message', 'stack');
+        error = e instanceof Exception ? e.toJSON() : pick(e, 'message', 'stack');
     }
     port.postMessage({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value }, transferList);
 }