@zenfs/core 1.7.2 → 1.8.0

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

@@ -1,53 +1,16 @@
-import type { FileReadResult } from 'node:fs/promises';
-import type { ExtractProperties } from 'utilium';
+import { type ExtractProperties } from 'utilium';
 import type { MountConfiguration } from '../../config.js';
 import type { CreationOptions, FileSystemMetadata } from '../../filesystem.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import { File } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
+import type { Inode, InodeLike } from '../store/inode.js';
 import * as RPC from './rpc.js';
-type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
-type FileMethod = keyof FileMethods;
-/** @internal */
-export 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 {
-    fs: PortFS;
-    readonly fd: number;
-    position: number;
-    constructor(fs: PortFS, fd: number, path: string, position: number);
-    rpc<const T extends FileMethod>(method: T, ...args: Parameters<FileMethods[T]>): Promise<Awaited<ReturnType<FileMethods[T]>>>;
-    protected _throwNoSync(syscall: string): never;
-    stat(): Promise<Stats>;
-    statSync(): Stats;
-    truncate(len: number): Promise<void>;
-    truncateSync(): void;
-    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
-    writeSync(): number;
-    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>>;
-    readSync(): number;
-    chown(uid: number, gid: number): Promise<void>;
-    chownSync(): void;
-    chmod(mode: number): Promise<void>;
-    chmodSync(): void;
-    utimes(atime: Date, mtime: Date): Promise<void>;
-    utimesSync(): void;
-    _setTypeSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-    sync(): Promise<void>;
-    syncSync(): void;
-}
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
 /** @internal */
 export interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
-    scope: 'fs';
     method: TMethod;
     args: Parameters<FSMethods[TMethod]>;
 }
@@ -61,7 +24,7 @@ declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, imp
 export declare class PortFS extends PortFS_base {
     readonly options: RPC.Options;
     readonly port: RPC.Port;
-    /**
+    /**`
      * @hidden
      */
     _sync: import("../index.js").StoreFS<import("../memory.js").InMemoryStore>;
@@ -74,7 +37,7 @@ export declare class PortFS extends PortFS_base {
     ready(): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     stat(path: string): Promise<Stats>;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    sync(path: string, data: Uint8Array | undefined, stats: Readonly<InodeLike | Inode>): Promise<void>;
     openFile(path: string, flag: string): Promise<File>;
     createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
     unlink(path: string): Promise<void>;
@@ -83,11 +46,13 @@ export declare class PortFS extends PortFS_base {
     readdir(path: string): Promise<string[]>;
     exists(path: string): Promise<boolean>;
     link(srcpath: string, dstpath: string): Promise<void>;
+    read(path: string, offset: number, length: number): Promise<Uint8Array>;
+    write(path: string, buffer: Uint8Array, offset: number): 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 handleRequest(port: RPC.Port, fs: FileSystem & {
+    _descriptors?: Map<number, File>;
+}, request: FSRequest): Promise<void>;
 export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
 export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
 declare const _Port: {

package/dist/backends/port/fs.js

@@ -1,3 +1,57 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { pick } from 'utilium';
 import { resolveMountConfig } from '../../config.js';
 import { Errno, ErrnoError } from '../../error.js';
 import { File } from '../../file.js';
@@ -6,83 +60,6 @@ import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
-export class PortFile extends File {
-    constructor(fs, fd, path, position) {
-        super(fs, path);
-        this.fs = fs;
-        this.fd = fd;
-        this.position = position;
-    }
-    rpc(method, ...args) {
-        return RPC.request({
-            scope: 'file',
-            fd: this.fd,
-            method,
-            args,
-        }, this.fs.options);
-    }
-    _throwNoSync(syscall) {
-        throw new ErrnoError(Errno.ENOTSUP, 'Synchronous operations not supported on PortFile', this.path, syscall);
-    }
-    async stat() {
-        return new Stats(await this.rpc('stat'));
-    }
-    statSync() {
-        this._throwNoSync('stat');
-    }
-    truncate(len) {
-        return this.rpc('truncate', len);
-    }
-    truncateSync() {
-        this._throwNoSync('truncate');
-    }
-    write(buffer, offset, length, position) {
-        return this.rpc('write', buffer, offset, length, position);
-    }
-    writeSync() {
-        this._throwNoSync('write');
-    }
-    async read(buffer, offset, length, position) {
-        const result = await this.rpc('read', buffer, offset, length, position);
-        return result;
-    }
-    readSync() {
-        this._throwNoSync('read');
-    }
-    chown(uid, gid) {
-        return this.rpc('chown', uid, gid);
-    }
-    chownSync() {
-        this._throwNoSync('chown');
-    }
-    chmod(mode) {
-        return this.rpc('chmod', mode);
-    }
-    chmodSync() {
-        this._throwNoSync('chmod');
-    }
-    utimes(atime, mtime) {
-        return this.rpc('utimes', atime, mtime);
-    }
-    utimesSync() {
-        this._throwNoSync('utimes');
-    }
-    _setTypeSync() {
-        this._throwNoSync('_setType');
-    }
-    close() {
-        return this.rpc('close');
-    }
-    closeSync() {
-        this._throwNoSync('close');
-    }
-    sync() {
-        return this.rpc('sync');
-    }
-    syncSync() {
-        this._throwNoSync('sync');
-    }
-}
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
  *
@@ -96,7 +73,7 @@ export class PortFS extends Async(FileSystem) {
     constructor(options) {
         super();
         this.options = options;
-        /**
+        /**`
          * @hidden
          */
         this._sync = InMemory.create({ name: 'port-tmpfs' });
@@ -110,11 +87,7 @@ export class PortFS extends Async(FileSystem) {
         };
     }
     rpc(method, ...args) {
-        return RPC.request({
-            scope: 'fs',
-            method,
-            args,
-        }, { ...this.options, fs: this });
+        return RPC.request({ method, args }, { ...this.options, fs: this });
     }
     async ready() {
         await this.rpc('ready');
@@ -127,6 +100,7 @@ export class PortFS extends Async(FileSystem) {
         return new Stats(await this.rpc('stat', path));
     }
     sync(path, data, stats) {
+        stats = 'toJSON' in stats ? stats.toJSON() : stats;
         return this.rpc('sync', path, data, stats);
     }
     openFile(path, flag) {
@@ -153,51 +127,54 @@ export class PortFS extends Async(FileSystem) {
     link(srcpath, dstpath) {
         return this.rpc('link', srcpath, dstpath);
     }
+    read(path, offset, length) {
+        return this.rpc('read', path, offset, length);
+    }
+    write(path, buffer, offset) {
+        return this.rpc('write', path, buffer, offset);
+    }
 }
-let nextFd = 0;
-const descriptors = new Map();
 /** @internal */
 export async function handleRequest(port, fs, request) {
-    if (!RPC.isMessage(request)) {
+    if (!RPC.isMessage(request))
         return;
-    }
-    const { method, args, id, scope, stack } = request;
+    const { method, args, id, stack } = request;
     let value, error = false;
+    const transfer = [];
     try {
-        switch (scope) {
-            case 'fs':
-                // @ts-expect-error 2556
-                value = await fs[method](...args);
-                if (value instanceof File) {
-                    descriptors.set(++nextFd, value);
-                    value = {
-                        fd: nextFd,
-                        path: value.path,
-                        position: value.position,
-                    };
-                }
-                break;
-            case 'file': {
-                const { fd } = request;
-                if (!descriptors.has(fd)) {
-                    throw new ErrnoError(Errno.EBADF);
-                }
-                // @ts-expect-error 2556
-                value = await descriptors.get(fd)[method](...args);
-                if (method == 'close') {
-                    descriptors.delete(fd);
-                }
-                break;
+        // @ts-expect-error 2556
+        value = await fs[method](...args);
+        if (value instanceof File) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const file = __addDisposableResource(env_1, await fs.openFile(args[0], 'r+'), true);
+                const stats = await file.stat();
+                const data = new Uint8Array(stats.size);
+                await file.read(data);
+                value = {
+                    path: value.path,
+                    flag: args[1],
+                    stats,
+                    buffer: data.buffer,
+                };
+                transfer.push(data.buffer);
+            }
+            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;
             }
-            default:
-                return;
         }
     }
     catch (e) {
-        value = e instanceof ErrnoError ? e.toJSON() : e.toString();
+        value = e instanceof ErrnoError ? e.toJSON() : pick(e, 'message', 'stack');
         error = true;
     }
-    port.postMessage({ _zenfs: true, scope, id, error, method, stack, value });
+    port.postMessage({ _zenfs: true, id, error, method, stack, value }, transfer);
 }
 export function attachFS(port, fs) {
     RPC.attach(port, request => handleRequest(port, fs, request));

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

@@ -1,12 +1,15 @@
+import type { TransferListItem } from 'node:worker_threads';
+import type { WithOptional } from 'utilium';
 import type { ErrnoErrorJSON } from '../../error.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import type { PortFS } from './fs.js';
+import { type StatsLike } from '../../stats.js';
 type _MessageEvent<T = any> = T | {
     data: T;
 };
 /** @internal */
 export interface Port {
-    postMessage(value: unknown): void;
+    postMessage(value: unknown, transfer?: TransferListItem[]): void;
     on?(event: 'message', listener: (value: unknown) => void): this;
     off?(event: 'message', listener: (value: unknown) => void): this;
     addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
@@ -27,7 +30,6 @@ export interface Options {
  */
 export interface Message {
     _zenfs: true;
-    scope: 'fs' | 'file';
     id: string;
     method: string;
     stack: string;
@@ -37,7 +39,7 @@ export interface Request extends Message {
 }
 interface _ResponseWithError extends Message {
     error: true;
-    value: ErrnoErrorJSON | string;
+    value: WithOptional<ErrnoErrorJSON, 'code' | 'errno'>;
 }
 interface _ResponseWithValue<T> extends Message {
     error: false;
@@ -45,9 +47,10 @@ interface _ResponseWithValue<T> extends Message {
 }
 export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T>;
 export interface FileData {
-    fd: number;
     path: string;
-    position: number;
+    flag: string;
+    stats: StatsLike<number>;
+    buffer: ArrayBuffer;
 }
 export { FileData as File };
 export declare function isMessage(arg: unknown): arg is Message;

package/dist/backends/port/rpc.js

@@ -1,7 +1,9 @@
 import { Errno, ErrnoError } from '../../error.js';
-import { handleRequest, PortFile } from './fs.js';
+import { PreloadFile } from '../../file.js';
+import { Stats } from '../../stats.js';
+import { handleRequest } from './fs.js';
 function isFileData(value) {
-    return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
+    return typeof value == 'object' && value != null && 'path' in value && 'flag' in value;
 }
 // general types
 export function isMessage(arg) {
@@ -18,7 +20,7 @@ export function request(request, { port, timeout = 1000, fs } = {}) {
         executors.set(id, { resolve, reject, fs });
         port.postMessage({ ...request, _zenfs: true, id, stack });
         const _ = setTimeout(() => {
-            const error = new ErrnoError(Errno.EIO, 'RPC Failed');
+            const error = new ErrnoError(Errno.EIO, 'RPC Failed', typeof request.args[0] == 'string' ? request.args[0] : '', request.method);
             error.stack += stack;
             reject(error);
             if (typeof _ == 'object')
@@ -38,15 +40,15 @@ export function handleResponse(response) {
     }
     const { resolve, reject, fs } = executors.get(id);
     if (error) {
-        const e = typeof value == 'string' ? new Error(value) : ErrnoError.fromJSON(value);
+        const e = ErrnoError.fromJSON({ code: 'EIO', errno: Errno.EIO, ...value });
         e.stack += stack;
         reject(e);
         executors.delete(id);
         return;
     }
     if (isFileData(value)) {
-        const { fd, path, position } = value;
-        const file = new PortFile(fs, fd, path, position);
+        const { path, flag, stats, buffer } = value;
+        const file = new PreloadFile(fs, path, flag, new Stats(stats), new Uint8Array(buffer));
         resolve(file);
         executors.delete(id);
         return;
@@ -78,7 +80,7 @@ export function catchMessages(port) {
     return function (fs) {
         detach(port, handler);
         for (const event of events) {
-            const request = ('data' in event ? event.data : event);
+            const request = 'data' in event ? event.data : event;
             void handleRequest(port, fs, request);
         }
     };

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

@@ -0,0 +1,38 @@
+import type { InodeLike } from './inode.js';
+import { Inode } from './inode.js';
+/**
+ * An Index in JSON form
+ * @internal
+ */
+export interface IndexData {
+    version: number;
+    entries: Record<string, InodeLike>;
+}
+export declare const version = 1;
+/**
+ * An index of files
+ * @internal
+ */
+export declare class Index extends Map<string, Readonly<Inode>> {
+    protected _directories?: Map<string, Record<string, number>>;
+    /**
+     * Converts the index to JSON
+     */
+    toJSON(): IndexData;
+    /**
+     * Converts the index to a string
+     */
+    toString(): string;
+    /**
+     * Gets a list of entries for each directory in the index. Memoized.
+     */
+    directories(): Map<string, Record<string, number>>;
+    /**
+     * Loads the index from JSON data
+     */
+    fromJSON(json: IndexData): void;
+    /**
+     * Parses an index from a string
+     */
+    static parse(data: string): Index;
+}

package/dist/backends/store/file_index.js

@@ -0,0 +1,76 @@
+/* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
+import { isJSON, randomInt } from 'utilium';
+import { Errno, ErrnoError } from '../../error.js';
+import { S_IFDIR, S_IFMT, size_max } from '../../vfs/constants.js';
+import { basename, dirname } from '../../vfs/path.js';
+import { Inode } from './inode.js';
+export const version = 1;
+/**
+ * An index of files
+ * @internal
+ */
+export class Index extends Map {
+    /**
+     * Converts the index to JSON
+     */
+    toJSON() {
+        return {
+            version,
+            entries: Object.fromEntries([...this].map(([k, v]) => [k, v.toJSON()])),
+        };
+    }
+    /**
+     * Converts the index to a string
+     */
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    /**
+     * Gets a list of entries for each directory in the index. Memoized.
+     */
+    directories() {
+        if (this._directories)
+            return this._directories;
+        const dirs = new Map();
+        for (const [path, node] of this) {
+            if ((node.mode & S_IFMT) != S_IFDIR)
+                continue;
+            const entries = {};
+            for (const entry of this.keys()) {
+                if (dirname(entry) == path && entry != path)
+                    entries[basename(entry)] = this.get(entry).ino;
+            }
+            dirs.set(path, entries);
+        }
+        this._directories = dirs;
+        return dirs;
+    }
+    /**
+     * Loads the index from JSON data
+     */
+    fromJSON(json) {
+        var _a;
+        if (json.version != version) {
+            throw new ErrnoError(Errno.EINVAL, 'Index version mismatch');
+        }
+        this.clear();
+        for (const [path, node] of Object.entries(json.entries)) {
+            (_a = node.data) !== null && _a !== void 0 ? _a : (node.data = randomInt(1, size_max));
+            if (path == '/')
+                node.ino = 0;
+            this.set(path, new Inode(node));
+        }
+    }
+    /**
+     * Parses an index from a string
+     */
+    static parse(data) {
+        if (!isJSON(data)) {
+            throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
+        }
+        const json = JSON.parse(data);
+        const index = new Index();
+        index.fromJSON(json);
+        return index;
+    }
+}