@zenfs/core 0.15.2 → 0.16.1

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

@@ -6,9 +6,17 @@ import type { Cred } from '../../cred.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
-type FileMethods = ExtractProperties<File, (...args: any[]) => Promise<any>>;
+import { type MountConfiguration } from '../../config.js';
+type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
 type FileMethod = keyof FileMethods;
+interface FileRequest<TMethod extends FileMethod = FileMethod> extends RPC.Request {
+    fd: number;
+    scope: 'file';
+    method: TMethod;
+    args: Parameters<FileMethods[TMethod]>;
+}
 export declare class PortFile extends File {
     readonly fs: PortFS;
     readonly fd: number;
@@ -40,6 +48,11 @@ export declare class PortFile extends File {
 }
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
+interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
+    scope: 'fs';
+    method: TMethod;
+    args: Parameters<FSMethods[TMethod]>;
+}
 declare const PortFS_base: import("../../filesystem.js").Mixin<typeof FileSystem, {
     _sync?: FileSystem | undefined;
     queueDone(): Promise<void>;
@@ -88,6 +101,14 @@ export declare class PortFS extends PortFS_base {
     exists(path: string, cred: Cred): Promise<boolean>;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
 }
+/**
+ * @internal
+ */
+export type FileOrFSRequest = FSRequest | FileRequest;
+/**
+ * @internal
+ */
+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: {
@@ -108,4 +129,5 @@ export declare const Port: {
     isAvailable(): Promise<boolean>;
     create(options: RPC.Options): PortFS;
 };
+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

@@ -4,6 +4,7 @@ import { Async, FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
+import { resolveMountConfig } from '../../config.js';
 export class PortFile extends File {
     constructor(fs, fd, path, position) {
         super();
@@ -159,7 +160,10 @@ export class PortFS extends Async(FileSystem) {
 }
 let nextFd = 0;
 const descriptors = new Map();
-async function handleRequest(port, fs, request) {
+/**
+ * @internal
+ */
+export async function handleRequest(port, fs, request) {
     if (!RPC.isMessage(request)) {
         return;
     }
@@ -195,18 +199,10 @@ async function handleRequest(port, fs, request) {
         }
     }
     catch (e) {
-        value = e;
+        value = e instanceof ErrnoError ? e.toJSON() : e.toString();
         error = true;
     }
-    port.postMessage({
-        _zenfs: true,
-        scope,
-        id,
-        error,
-        method,
-        stack,
-        value: value instanceof ErrnoError ? value.toJSON() : value,
-    });
+    port.postMessage({ _zenfs: true, scope, id, error, method, stack, value });
 }
 export function attachFS(port, fs) {
     RPC.attach(port, request => handleRequest(port, fs, request));
@@ -241,3 +237,10 @@ export const Port = {
         return new PortFS(options);
     },
 };
+export async function resolveRemoteMount(port, config, _depth = 0) {
+    const stopAndReplay = RPC.catchMessages(port);
+    const fs = await resolveMountConfig(config, _depth);
+    attachFS(port, fs);
+    stopAndReplay(fs);
+    return fs;
+}

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

@@ -1,16 +1,16 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { TransferListItem } from 'worker_threads';
+import { type ErrnoErrorJSON } from '../../error.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import { type PortFS } from './fs.js';
 type _MessageEvent<T = any> = T | {
     data: T;
 };
 export interface Port {
-    postMessage(value: unknown, transferList?: ReadonlyArray<TransferListItem>): void;
+    postMessage(value: unknown): void;
     on?(event: 'message', listener: (value: unknown) => void): this;
     off?(event: 'message', listener: (value: unknown) => void): this;
-    addEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
-    removeEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
+    addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
+    removeEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
 }
 export interface Options {
     /**
@@ -25,27 +25,32 @@ export interface Options {
 /**
  * An RPC message
  */
-export interface Message<TScope extends string = string, TMethod extends string = string> {
+export interface Message {
     _zenfs: true;
-    scope: TScope;
+    scope: 'fs' | 'file';
     id: string;
-    method: TMethod;
+    method: string;
     stack: string;
 }
-export interface Request<TScope extends string = string, TMethod extends string = string, TArgs extends unknown[] = unknown[]> extends Message<TScope, TMethod> {
-    args: TArgs;
+export interface Request extends Message {
+    args: unknown[];
+}
+interface _ResponseWithError extends Message {
+    error: true;
+    value: ErrnoErrorJSON | string;
 }
-export interface Response<TScope extends string = string, TMethod extends string = string, TValue = unknown> extends Message<TScope, TMethod> {
-    error: boolean;
-    value: Awaited<TValue> extends File ? FileData : Awaited<TValue>;
+interface _ResponseWithValue<T> extends Message {
+    error: false;
+    value: Awaited<T> extends File ? FileData : Awaited<T>;
 }
+export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T>;
 export interface FileData {
     fd: number;
     path: string;
     position: number;
 }
 export { FileData as File };
-export declare function isMessage(arg: unknown): arg is Message<string, string>;
+export declare function isMessage(arg: unknown): arg is Message;
 type _Executor = Parameters<ConstructorParameters<typeof Promise<any>>[0]>;
 export interface Executor {
     resolve: _Executor[0];
@@ -58,3 +63,4 @@ export declare function request<const TRequest extends Request, TValue>(request:
 export declare function handleResponse<const TResponse extends Response>(response: TResponse): void;
 export declare function attach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
 export declare function detach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
+export declare function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => void;

package/dist/backends/port/rpc.js

@@ -1,5 +1,6 @@
-import { ErrnoError, Errno } from '../../error.js';
-import { PortFile } from './fs.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Errno, ErrnoError } from '../../error.js';
+import { handleRequest, PortFile } from './fs.js';
 function isFileData(value) {
     return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
 }
@@ -38,7 +39,7 @@ export function handleResponse(response) {
     }
     const { resolve, reject, fs } = executors.get(id);
     if (error) {
-        const e = ErrnoError.fromJSON(value);
+        const e = typeof value == 'string' ? new Error(value) : ErrnoError.fromJSON(value);
         e.stack += stack;
         reject(e);
         executors.delete(id);
@@ -71,3 +72,15 @@ export function detach(port, handler) {
         handler('data' in message ? message.data : message);
     });
 }
+export function catchMessages(port) {
+    const events = [];
+    const handler = events.push.bind(events);
+    attach(port, handler);
+    return function (fs) {
+        detach(port, handler);
+        for (const event of events) {
+            const request = 'data' in event ? event.data : event;
+            handleRequest(port, fs, request);
+        }
+    };
+}

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

@@ -2,7 +2,7 @@ import type { Cred } from '../../cred.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { type Ino, Inode } from '../../inode.js';
-import { type Stats, FileType } from '../../stats.js';
+import type { FileType, Stats } from '../../stats.js';
 import type { Store, Transaction } from './store.js';
 /**
  * A file system which uses a key-value store.

package/dist/backends/store/fs.js

@@ -1,11 +1,10 @@
-import { W_OK, R_OK } from '../../emulation/constants.js';
-import { dirname, basename, join, resolve } from '../../emulation/path.js';
-import { ErrnoError, Errno } from '../../error.js';
+import { R_OK, S_IFDIR, S_IFREG, W_OK } from '../../emulation/constants.js';
+import { basename, dirname, join, resolve } from '../../emulation/path.js';
+import { Errno, ErrnoError } from '../../error.js';
 import { PreloadFile, flagToMode } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
-import { Inode, rootIno, randomIno } from '../../inode.js';
-import { FileType } from '../../stats.js';
-import { encodeDirListing, encode, decodeDirListing } from '../../utils.js';
+import { Inode, randomIno, rootIno } from '../../inode.js';
+import { decodeDirListing, encode, encodeDirListing } from '../../utils.js';
 const maxInodeAllocTries = 5;
 /**
  * A file system which uses a key-value store.
@@ -199,11 +198,11 @@ export class StoreFS extends FileSystem {
     }
     async createFile(path, flag, mode, cred) {
         const data = new Uint8Array(0);
-        const file = await this.commitNew(this.store.transaction(), path, FileType.FILE, mode, cred, data);
+        const file = await this.commitNew(this.store.transaction(), path, S_IFREG, mode, cred, data);
         return new PreloadFile(this, path, flag, file.toStats(), data);
     }
     createFileSync(path, flag, mode, cred) {
-        this.commitNewSync(path, FileType.FILE, mode, cred);
+        this.commitNewSync(path, S_IFREG, mode, cred);
         return this.openFileSync(path, flag, cred);
     }
     async openFile(path, flag, cred) {
@@ -251,10 +250,10 @@ export class StoreFS extends FileSystem {
     }
     async mkdir(path, mode, cred) {
         const tx = this.store.transaction(), data = encode('{}');
-        await this.commitNew(tx, path, FileType.DIRECTORY, mode, cred, data);
+        await this.commitNew(tx, path, S_IFDIR, mode, cred, data);
     }
     mkdirSync(path, mode, cred) {
-        this.commitNewSync(path, FileType.DIRECTORY, mode, cred, encode('{}'));
+        this.commitNewSync(path, S_IFDIR, mode, cred, encode('{}'));
     }
     async readdir(path, cred) {
         const tx = this.store.transaction();
@@ -378,7 +377,7 @@ export class StoreFS extends FileSystem {
         }
         // Create new inode. o777, owned by root:root
         const inode = new Inode();
-        inode.mode = 0o777 | FileType.DIRECTORY;
+        inode.mode = 0o777 | S_IFDIR;
         // If the root doesn't exist, the first random ID shouldn't exist either.
         await tx.set(inode.ino, encode('{}'));
         await tx.set(rootIno, inode.data);
@@ -394,7 +393,7 @@ export class StoreFS extends FileSystem {
         }
         // Create new inode, mode o777, owned by root:root
         const inode = new Inode();
-        inode.mode = 0o777 | FileType.DIRECTORY;
+        inode.mode = 0o777 | S_IFDIR;
         // If the root doesn't exist, the first random ID shouldn't exist either.
         tx.setSync(inode.ino, encode('{}'));
         tx.setSync(rootIno, inode.data);