@zenfs/core 2.2.3 → 2.3.0

package/dist/backends/backend.js

@@ -32,7 +32,7 @@ export function checkOptions(backend, options) {
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
-        const value = options === null || options === void 0 ? void 0 : options[optName];
+        const value = options?.[optName];
         if (value === undefined || value === null) {
             if (!opt.required) {
                 debug('Using default for option: ' + optName);
@@ -40,14 +40,11 @@ export function checkOptions(backend, options) {
             }
             throw err(withErrno('EINVAL', 'Missing required option: ' + optName));
         }
-        const isType = (type, _ = value) => {
-            var _a;
-            return typeof type == 'function'
-                ? Symbol.hasInstance in type && type.prototype
-                    ? value instanceof type
-                    : type(value)
-                : typeof value === type || ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === type;
-        };
+        const isType = (type, _ = value) => typeof type == 'function'
+            ? Symbol.hasInstance in type && type.prototype
+                ? value instanceof type
+                : type(value)
+            : typeof value === type || value?.constructor?.name === type;
         if (Array.isArray(opt.type) ? opt.type.some(v => isType(v)) : isType(opt.type))
             continue;
         // The type of the value as a string

package/dist/backends/cow.js

@@ -19,10 +19,7 @@ const journalMagicString = '#journal@v0\n';
  * @internal
  */
 export class Journal extends EventEmitter {
-    constructor() {
-        super(...arguments);
-        this.entries = [];
-    }
+    entries = [];
     toString() {
         return journalMagicString + this.entries.map(entry => `${entry.op.padEnd(maxOpLength)} ${entry.path}`).join('\n');
     }
@@ -75,6 +72,9 @@ export class Journal extends EventEmitter {
  * @category Internals
  */
 export class CopyOnWriteFS extends FileSystem {
+    readable;
+    writable;
+    journal;
     async ready() {
         await this.readable.ready();
         await this.writable.ready();

package/dist/backends/fetch.js

@@ -27,6 +27,13 @@ function parseError(error) {
  * @internal
  */
 export class FetchFS extends IndexFS {
+    baseUrl;
+    requestInit;
+    remoteWrite;
+    /**
+     * @internal @hidden
+     */
+    _asyncDone = Promise.resolve();
     _async(p) {
         this._asyncDone = this._asyncDone.then(() => p);
     }
@@ -35,10 +42,6 @@ export class FetchFS extends IndexFS {
         this.baseUrl = baseUrl;
         this.requestInit = requestInit;
         this.remoteWrite = remoteWrite;
-        /**
-         * @internal @hidden
-         */
-        this._asyncDone = Promise.resolve();
     }
     async remove(path) {
         await requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit);
@@ -102,13 +105,12 @@ const _Fetch = {
         return typeof globalThis.fetch == 'function';
     },
     async create(options) {
-        var _a;
         const url = new URL(options.baseUrl);
         url.pathname = normalizePath(url.pathname);
         let baseUrl = url.toString();
         if (baseUrl.at(-1) == '/')
             baseUrl = baseUrl.slice(0, -1);
-        (_a = options.index) !== null && _a !== void 0 ? _a : (options.index = 'index.json');
+        options.index ??= 'index.json';
         const index = new Index();
         if (typeof options.index != 'string') {
             index.fromJSON(options.index);

package/dist/backends/memory.js

@@ -6,12 +6,14 @@ import { SyncMapTransaction } from './store/map.js';
  * @category Stores and Transactions
  */
 export class InMemoryStore extends Map {
+    maxSize;
+    label;
+    flags = [];
+    name = 'tmpfs';
     constructor(maxSize = size_max, label) {
         super();
         this.maxSize = maxSize;
         this.label = label;
-        this.flags = [];
-        this.name = 'tmpfs';
     }
     async sync() { }
     transaction() {

package/dist/backends/passthrough.js

@@ -55,6 +55,8 @@ import { FileSystem } from '../internal/filesystem.js';
 import { isDirectory } from '../internal/inode.js';
 import { resolve } from '../path.js';
 export class PassthroughFS extends FileSystem {
+    nodeFS;
+    prefix;
     constructor(nodeFS, prefix) {
         super(0x6e6f6465, 'nodefs');
         this.nodeFS = nodeFS;

package/dist/backends/port.d.ts

@@ -1,94 +1,25 @@
-import type { TransferListItem } from 'node:worker_threads';
 import type { MountConfiguration } from '../config.js';
-import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
+import type { CreationOptions } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { Backend, FilesystemOf } from './backend.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { Inode } from '../internal/inode.js';
+import * as RPC from '../internal/rpc.js';
 import '../polyfills.js';
-type _MessageEvent<T = any> = T | {
-    data: T;
-};
-/** @internal */
-export interface RPCPort {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
-    on?(event: 'message' | 'online', listener: (value: unknown) => void): this;
-    off?(event: 'message', listener: (value: unknown) => void): this;
-    addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
-    removeEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
-}
+export { RPC };
 /**
- * The options for the Port backend
  * @category Backends and Configuration
  */
 export interface PortOptions {
     /**
      * The target port that you want to connect to, or the current port if in a port context.
      */
-    port: RPCPort;
+    port: RPC.Channel;
     /**
      * How long to wait for a request to complete
      */
     timeout?: number;
 }
-/**
- * The API for remote procedure calls
- * @category Internals
- * @internal
- */
-export interface RPCMethods {
-    usage(): UsageInfo;
-    ready(): void;
-    rename(oldPath: string, newPath: string): void;
-    createFile(path: string, options: CreationOptions): Uint8Array;
-    unlink(path: string): void;
-    rmdir(path: string): void;
-    mkdir(path: string, options: CreationOptions): Uint8Array;
-    readdir(path: string): string[];
-    touch(path: string, metadata: Uint8Array): void;
-    exists(path: string): boolean;
-    link(target: string, link: 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;
-}
-/**
- * The methods that can be called on the RPC port
- * @category Internals
- * @internal
- */
-export type RPCMethod = keyof RPCMethods;
-/**
- * An RPC message
- * @category Internals
- * @internal
- */
-export interface RPCMessage {
-    _zenfs: true;
-    id: string;
-    method: RPCMethod;
-    stack: string;
-}
-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>;
-/**
- * @internal
- */
-export declare function waitOnline(port: RPCPort): Promise<void>;
 declare const PortFS_base: import("../index.js").Mixin<typeof FileSystem, import("../mixins/async.js").AsyncMixin>;
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
@@ -98,14 +29,15 @@ declare const PortFS_base: import("../index.js").Mixin<typeof FileSystem, import
  * @category Internals
  * @internal
  */
-export declare class PortFS extends PortFS_base {
-    readonly options: PortOptions;
-    readonly port: RPCPort;
+export declare class PortFS<T extends RPC.Channel = RPC.Channel> extends PortFS_base {
+    readonly channel: T;
+    readonly timeout: number;
+    readonly port: RPC.Port<T>;
     /**
      * A map of outstanding RPC requests
      * @internal @hidden
      */
-    readonly _executors: Map<string, RPCExecutor>;
+    readonly _executors: Map<string, RPC.Executor>;
     /**
      * @hidden
      */
@@ -113,8 +45,8 @@ export declare class PortFS extends PortFS_base {
     /**
      * Constructs a new PortFS instance that connects with the FS running on `options.port`.
      */
-    constructor(options: PortOptions);
-    protected rpc<const T extends RPCMethod>(method: T, ...args: Parameters<RPCMethods[T]>): Promise<Awaited<ReturnType<RPCMethods[T]>>>;
+    constructor(channel: T, timeout?: number);
+    protected rpc<const T extends RPC.Method>(method: T, ...args: Parameters<RPC.Methods[T]>): Promise<Awaited<ReturnType<RPC.Methods[T]>>>;
     ready(): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     stat(path: string): Promise<Inode>;
@@ -130,17 +62,13 @@ export declare class PortFS extends PortFS_base {
     read(path: string, buffer: Uint8Array, start: number, end: number): Promise<void>;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
 }
-/** @internal */
-export declare function handleRequest(port: RPCPort, fs: FileSystem & {
-    _descriptors?: Map<number, File>;
-}, request: RPCRequest): Promise<void>;
-export declare function attachFS(port: RPCPort, fs: FileSystem): void;
-export declare function detachFS(port: RPCPort, fs: FileSystem): void;
+export declare function attachFS(channel: RPC.Channel | RPC.Port, fs: FileSystem): void;
+export declare function detachFS(channel: RPC.Channel | RPC.Port, fs: FileSystem): void;
 declare const _Port: {
     name: string;
     options: {
         port: {
-            type: (arg: RPCPort) => boolean;
+            type: string[];
             required: true;
         };
         timeout: {
@@ -148,7 +76,7 @@ declare const _Port: {
             required: false;
         };
     };
-    create(options: PortOptions): PortFS;
+    create(opt: PortOptions): PortFS<RPC.Channel>;
 };
 type _Port = typeof _Port;
 /**
@@ -216,5 +144,4 @@ export declare const Port: Port;
 /**
  * @category Backends and Configuration
  */
-export declare function resolveRemoteMount<T extends Backend>(port: RPCPort, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
-export {};
+export declare function resolveRemoteMount<T extends Backend>(channel: RPC.Channel | RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;

package/dist/backends/port.js

@@ -1,114 +1,12 @@
-import { Errno, Exception, withErrno } from 'kerium';
-import { err, info } from 'kerium/log';
-import { pick } from 'utilium';
+import { info } from 'kerium/log';
 import { resolveMountConfig } from '../config.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { Inode } from '../internal/inode.js';
+import * as RPC from '../internal/rpc.js';
 import { Async } from '../mixins/async.js';
 import '../polyfills.js';
-import { _fnOpt } from './backend.js';
 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: ms = 1000, fs }) {
-    const stack = '\n' + new Error().stack.slice('Error:'.length);
-    if (!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);
-    const timeout = setTimeout(() => {
-        const error = err(withErrno('EIO', 'RPC Failed'));
-        error.stack += stack;
-        disposeExecutors(id);
-        reject(error);
-    }, 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?
-function __requestMethod(req) { }
-function __responseMethod(res, ...t) {
-    return t.includes(res.method);
-}
-function handleResponse(response) {
-    if (!isRPCMessage(response))
-        return;
-    if (!executors.has(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 = Exception.fromJSON({ code: 'EIO', errno: Errno.EIO, ...response.error });
-        e.stack += response.stack;
-        disposeExecutors(response.id);
-        reject(e);
-        return;
-    }
-    disposeExecutors(response.id);
-    resolve(__responseMethod(response, 'stat', 'createFile', 'mkdir') ? new Inode(response.value) : response.value);
-    return;
-}
-export function attach(port, handler) {
-    if (!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);
-    });
-}
-export function detach(port, handler) {
-    if (!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);
-    });
-}
-export function catchMessages(port) {
-    const events = [];
-    const handler = events.push.bind(events);
-    attach(port, handler);
-    return async function (fs) {
-        detach(port, handler);
-        for (const event of events) {
-            const request = 'data' in event ? event.data : event;
-            await handleRequest(port, fs, request);
-        }
-    };
-}
-/**
- * @internal
- */
-export async function waitOnline(port) {
-    if (!('on' in port))
-        return; // Only need to wait in Node.js
-    const online = Promise.withResolvers();
-    setTimeout(online.reject, 500);
-    port.on('online', online.resolve);
-    await online.promise;
-}
+export { RPC };
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
  *
@@ -118,27 +16,32 @@ export async function waitOnline(port) {
  * @internal
  */
 export class PortFS extends Async(FileSystem) {
+    channel;
+    timeout;
+    port;
+    /**
+     * A map of outstanding RPC requests
+     * @internal @hidden
+     */
+    _executors = new Map();
+    /**
+     * @hidden
+     */
+    _sync = InMemory.create({ label: 'tmpfs:port' });
     /**
      * Constructs a new PortFS instance that connects with the FS running on `options.port`.
      */
-    constructor(options) {
+    constructor(channel, timeout = 250) {
         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' });
-        this.port = options.port;
-        attach(this.port, handleResponse);
+        this.channel = channel;
+        this.timeout = timeout;
+        this.port = RPC.from(channel);
+        RPC.attach(this.port, RPC.handleResponse);
     }
     rpc(method, ...args) {
-        return request({ method, args }, {
-            ...this.options,
+        return RPC.request({ method, args }, {
+            port: this.port,
+            timeout: this.timeout,
             fs: this,
         });
     }
@@ -197,65 +100,25 @@ export class PortFS extends Async(FileSystem) {
         return this.rpc('write', path, buffer, offset);
     }
 }
-/** @internal */
-export async function handleRequest(port, fs, request) {
-    if (!isRPCMessage(request))
-        return;
-    let value, error;
-    const transferList = [];
-    try {
-        switch (request.method) {
-            case 'read': {
-                __requestMethod(request);
-                const [path, buffer, start, end] = request.args;
-                await fs.read(path, buffer, start, end);
-                value = buffer;
-                break;
-            }
-            case 'stat':
-            case 'createFile':
-            case 'mkdir': {
-                __requestMethod(request);
-                // @ts-expect-error 2556
-                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': {
-                __requestMethod(request);
-                const [path, metadata] = request.args;
-                await fs.touch(path, new Inode(metadata));
-                value = undefined;
-                break;
-            }
-            default:
-                // @ts-expect-error 2556
-                value = (await fs[request.method](...request.args));
-        }
-    }
-    catch (e) {
-        error = e instanceof Exception ? e.toJSON() : pick(e, 'message', 'stack');
-    }
-    port.postMessage({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value }, transferList);
-}
-export function attachFS(port, fs) {
-    attach(port, request => handleRequest(port, fs, request));
+export function attachFS(channel, fs) {
+    const port = RPC.from(channel);
+    RPC.attach(port, request => RPC.handleRequest(port, fs, request));
 }
-export function detachFS(port, fs) {
-    detach(port, request => handleRequest(port, fs, request));
+export function detachFS(channel, fs) {
+    const port = RPC.from(channel);
+    RPC.detach(port, request => RPC.handleRequest(port, fs, request));
 }
 const _Port = {
     name: 'Port',
     options: {
         port: {
-            type: _fnOpt('RPCPort', (port) => typeof (port === null || port === void 0 ? void 0 : port.postMessage) == 'function'),
+            type: ['Worker', 'MessagePort', 'WebSocket'],
             required: true,
         },
         timeout: { type: 'number', required: false },
     },
-    create(options) {
-        return new PortFS(options);
+    create(opt) {
+        return new PortFS(opt.port, opt.timeout);
     },
 };
 /**
@@ -318,8 +181,9 @@ export const Port = _Port;
 /**
  * @category Backends and Configuration
  */
-export async function resolveRemoteMount(port, config, _depth = 0) {
-    const stopAndReplay = catchMessages(port);
+export async function resolveRemoteMount(channel, config, _depth = 0) {
+    const port = RPC.from(channel);
+    const stopAndReplay = RPC.catchMessages(port);
     const fs = await resolveMountConfig(config, _depth);
     attachFS(port, fs);
     await stopAndReplay(fs);

package/dist/backends/single_buffer.d.ts

@@ -23,6 +23,7 @@ declare class MetadataEntry extends BufferView {
  * This is done since IDs are not guaranteed to be sequential.
  */
 export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
+    static readonly name = "MetadataBlock";
     readonly ['constructor']: typeof MetadataBlock;
     /**
      * The crc32c checksum for the metadata block.
@@ -53,9 +54,10 @@ export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
 /**
  * The super block structure for a single-buffer file system
  */
-export declare class SuperBlock extends BufferView {
+export declare class SuperBlock extends BigUint64Array<ArrayBufferLike> {
+    static readonly name = "SuperBlock";
     readonly ['constructor']: typeof SuperBlock;
-    constructor(...args: ConstructorParameters<typeof BufferView>);
+    constructor(...args: ConstructorParameters<typeof BigUint64Array<ArrayBufferLike>>);
     /**
      * The crc32c checksum for the super block.
      * @privateRemarks Keep this first!