@zenfs/core 1.7.2 → 1.8.1

package/dist/backends/passthrough.js

@@ -1,7 +1,59 @@
-import { FileSystem } from '../filesystem.js';
+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;
+});
 import { ErrnoError } from '../error.js';
-import { Stats } from '../stats.js';
 import { File } from '../file.js';
+import { FileSystem } from '../filesystem.js';
+import { Stats } from '../stats.js';
 import { join, resolve } from '../vfs/path.js';
 class PassthroughFile extends File {
     constructor(fs, path, fd) {
@@ -281,7 +333,23 @@ export class PassthroughFS extends FileSystem {
      */
     async sync(path, data, stats) {
         try {
-            await this.nodeFS.promises.writeFile(this.path(path), data);
+            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.writeFile(data);
+                await handle.chmod(stats.mode);
+                await handle.chown(stats.uid, stats.gid);
+                await handle.utimes(stats.atimeMs, stats.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;
+            }
         }
         catch (err) {
             this.error(err, path);
@@ -292,7 +360,11 @@ export class PassthroughFS extends FileSystem {
      */
     syncSync(path, data, stats) {
         try {
-            this.nodeFS.writeFileSync(this.path(path), data);
+            const p = this.path(path);
+            this.nodeFS.writeFileSync(p, data);
+            this.nodeFS.chmodSync(p, stats.mode);
+            this.nodeFS.chownSync(p, stats.uid, stats.gid);
+            this.nodeFS.utimesSync(p, stats.atimeMs, stats.mtimeMs);
         }
         catch (err) {
             this.error(err, path);
@@ -320,6 +392,78 @@ export class PassthroughFS extends FileSystem {
             this.error(err, target);
         }
     }
+    async read(path, buffer, offset, end) {
+        try {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'r'), true);
+                await handle.read({ buffer, offset, length: end - offset });
+            }
+            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 (err) {
+            this.error(err, path);
+        }
+    }
+    readSync(path, buffer, offset, end) {
+        let fd;
+        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);
+        }
+        // unreachable
+        throw ErrnoError.With('EIO', path, 'read');
+    }
+    async write(path, buffer, offset) {
+        try {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_3, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+                await handle.write(buffer, 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;
+            }
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    writeSync(path, buffer, offset) {
+        let fd;
+        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);
+        }
+    }
 }
 const _Passthrough = {
     name: 'Passthrough',

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

@@ -1,56 +1,20 @@
-import type { FileReadResult } from 'node:fs/promises';
 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 type { Inode, InodeLike } from '../store/inode.js';
+import type { File } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.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]>;
-}
+export type FSRequest<TMethod extends FSMethod = FSMethod> = RPC.Message & {
+    [M in TMethod]: {
+        method: M;
+        args: Parameters<FSMethods[M]>;
+    };
+}[TMethod];
 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.
@@ -61,7 +25,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 +38,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 +47,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, buffer: Uint8Array, offset: number, length: number): Promise<void>;
+    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,88 +1,11 @@
+import { pick } from 'utilium';
 import { resolveMountConfig } from '../../config.js';
 import { Errno, ErrnoError } from '../../error.js';
-import { File } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 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 +19,7 @@ export class PortFS extends Async(FileSystem) {
     constructor(options) {
         super();
         this.options = options;
-        /**
+        /**`
          * @hidden
          */
         this._sync = InMemory.create({ name: 'port-tmpfs' });
@@ -110,11 +33,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 +46,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 +73,43 @@ export class PortFS extends Async(FileSystem) {
     link(srcpath, dstpath) {
         return this.rpc('link', srcpath, dstpath);
     }
+    async read(path, buffer, offset, length) {
+        const _buf = (await this.rpc('read', path, buffer, offset, length));
+        buffer.set(_buf);
+    }
+    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;
     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);
-                }
+        // @ts-expect-error 2556
+        value = await fs[method](...args);
+        switch (method) {
+            case 'openFile':
+            case 'createFile': {
+                value = {
+                    path: args[0],
+                    flag: args[1],
+                    stats: await fs.stat(args[0]),
+                };
                 break;
             }
-            default:
-                return;
+            case 'read':
+                value = args[1];
+                break;
         }
     }
     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 });
 }
 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,17 +39,22 @@ 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;
     value: Awaited<T> extends File ? FileData : Awaited<T>;
 }
-export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T>;
+interface _ResponseRead extends Message {
+    error: false;
+    method: 'read';
+    value: Uint8Array;
+}
+export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T> | _ResponseRead;
 export interface FileData {
-    fd: number;
     path: string;
-    position: number;
+    flag: string;
+    stats: StatsLike<number>;
 }
 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 { LazyFile } 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 } = value;
+        const file = new LazyFile(fs, path, flag, new Stats(stats));
         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;
+    }
+}