@zenfs/core 2.7.5 → 2.7.6

package/dist/backends/backend.js

@@ -55,9 +55,7 @@ export function checkOptions(backend, options) {
             : 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
         const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
-        // The expected type (as a string)
         const name = (type) => (typeof type == 'function' ? (type.name != 'type' ? type.name : type.toString()) : type);
         const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
         throw err(withErrno('EINVAL', `Incorrect type for "${optName}": ${type} (expected ${expected})`));

package/dist/backends/cow.d.ts

@@ -162,14 +162,14 @@ declare const _CopyOnWrite: {
 };
 type _CopyOnWrite = typeof _CopyOnWrite;
 /**
- * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
  */
 export interface CopyOnWrite extends _CopyOnWrite {
 }
 /**
- * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
  * @internal

package/dist/backends/cow.js

@@ -141,7 +141,7 @@ export class CopyOnWriteFS extends FileSystem {
         }
         /* Note the layer's inode is not mutated, since it may be a persistent object.
         `Inode` fields are accessors, so a copy must be explicit rather than a spread. */
-        return { ...pick(inode, _inode_fields), attributes: inode.attributes, ino };
+        return Object.assign(pick(inode, _inode_fields), { attributes: inode.attributes, ino });
     }
     /**
      * @todo Consider trying to track information on the writable as well
@@ -252,25 +252,19 @@ export class CopyOnWriteFS extends FileSystem {
     async unlink(path) {
         if (!(await this.exists(path)))
             throw withErrno('ENOENT');
-        if (await this.writable.exists(path)) {
+        if (await this.writable.exists(path))
             await this.writable.unlink(path);
-        }
-        // if it still exists add to the delete log
-        if (await this.exists(path)) {
+        if (await this.exists(path))
             this.journal.add('delete', path);
-        }
         this.inos.delete(path);
     }
     unlinkSync(path) {
         if (!this.existsSync(path))
             throw withErrno('ENOENT');
-        if (this.writable.existsSync(path)) {
+        if (this.writable.existsSync(path))
             this.writable.unlinkSync(path);
-        }
-        // if it still exists add to the delete log
-        if (this.existsSync(path)) {
+        if (this.existsSync(path))
             this.journal.add('delete', path);
-        }
         this.inos.delete(path);
     }
     async rmdir(path) {
@@ -283,7 +277,6 @@ export class CopyOnWriteFS extends FileSystem {
             this.inos.delete(path);
             return;
         }
-        // Check if directory is empty.
         if ((await this.readdir(path)).length)
             throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
@@ -299,7 +292,6 @@ export class CopyOnWriteFS extends FileSystem {
             this.inos.delete(path);
             return;
         }
-        // Check if directory is empty.
         if (this.readdirSync(path).length)
             throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
@@ -488,7 +480,7 @@ const _CopyOnWrite = {
     },
 };
 /**
- * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
  * @internal

package/dist/backends/passthrough.d.ts

@@ -16,21 +16,9 @@ export declare class PassthroughFS extends FileSystem {
     constructor(nodeFS: NodeFS, prefix: string);
     usage(): UsageInfo;
     path(path: string): string;
-    /**
-     * Rename a file or directory.
-     */
     rename(oldPath: string, newPath: string): Promise<void>;
-    /**
-     * Rename a file or directory synchronously.
-     */
     renameSync(oldPath: string, newPath: string): void;
-    /**
-     * Get file statistics.
-     */
     stat(path: string): Promise<InodeLike>;
-    /**
-     * Get file statistics synchronously.
-     */
     statSync(path: string): InodeLike;
     /**
      * @privateRemarks
@@ -42,61 +30,19 @@ export declare class PassthroughFS extends FileSystem {
      * Timestamps should be updated by the underlying file system.
      */
     touchSync(path: string, metadata: InodeLike): void;
-    /**
-     * Unlink (delete) a file.
-     */
     unlink(path: string): Promise<void>;
-    /**
-     * Unlink (delete) a file synchronously.
-     */
     unlinkSync(path: string): void;
-    /**
-     * Create a directory.
-     */
     mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    /**
-     * Create a directory synchronously.
-     */
     mkdirSync(path: string, options: CreationOptions): InodeLike;
-    /**
-     * Read the contents of a directory.
-     */
     readdir(path: string): Promise<string[]>;
-    /**
-     * Read the contents of a directory synchronously.
-     */
     readdirSync(path: string): string[];
-    /**
-     * Create a file.
-     */
     createFile(path: string, options: CreationOptions): Promise<InodeLike>;
-    /**
-     * Create a file synchronously.
-     */
     createFileSync(path: string, options: CreationOptions): InodeLike;
-    /**
-     * Remove a directory.
-     */
     rmdir(path: string): Promise<void>;
-    /**
-     * Remove a directory synchronously.
-     */
     rmdirSync(path: string): void;
-    /**
-     * Synchronize data to the file system.
-     */
     sync(): Promise<void>;
-    /**
-     * Synchronize data to the file system synchronously.
-     */
     syncSync(): void;
-    /**
-     * Create a hard link.
-     */
     link(target: string, link: string): Promise<void>;
-    /**
-     * Create a hard link synchronously.
-     */
     linkSync(target: string, link: string): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;

package/dist/backends/passthrough.js

@@ -72,27 +72,15 @@ export class PassthroughFS extends FileSystem {
     path(path) {
         return this.prefix + path;
     }
-    /**
-     * Rename a file or directory.
-     */
     async rename(oldPath, newPath) {
         await this.nodeFS.promises.rename(this.path(oldPath), this.path(newPath));
     }
-    /**
-     * Rename a file or directory synchronously.
-     */
     renameSync(oldPath, newPath) {
         this.nodeFS.renameSync(this.path(oldPath), this.path(newPath));
     }
-    /**
-     * Get file statistics.
-     */
     async stat(path) {
         return await this.nodeFS.promises.stat(this.path(path));
     }
-    /**
-     * Get file statistics synchronously.
-     */
     statSync(path) {
         return this.nodeFS.statSync(this.path(path));
     }
@@ -135,47 +123,26 @@ export class PassthroughFS extends FileSystem {
             err('Failed to chown passthrough file: ' + error.message);
         }
     }
-    /**
-     * Unlink (delete) a file.
-     */
     async unlink(path) {
         await this.nodeFS.promises.unlink(this.path(path));
     }
-    /**
-     * Unlink (delete) a file synchronously.
-     */
     unlinkSync(path) {
         this.nodeFS.unlinkSync(this.path(path));
     }
-    /**
-     * Create a directory.
-     */
     async mkdir(path, options) {
         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) {
         this.nodeFS.mkdirSync(this.path(path), options);
         return this.nodeFS.statSync(this.path(path));
     }
-    /**
-     * Read the contents of a directory.
-     */
     async readdir(path) {
         return await this.nodeFS.promises.readdir(this.path(path));
     }
-    /**
-     * Read the contents of a directory synchronously.
-     */
     readdirSync(path) {
         return this.nodeFS.readdirSync(this.path(path));
     }
-    /**
-     * Create a file.
-     */
     async createFile(path, options) {
         if (isDirectory(options)) {
             await this.nodeFS.promises.mkdir(this.path(path), { mode: options.mode });
@@ -198,9 +165,6 @@ export class PassthroughFS extends FileSystem {
         }
         return await this.nodeFS.promises.stat(this.path(path));
     }
-    /**
-     * Create a file synchronously.
-     */
     createFileSync(path, options) {
         if (isDirectory(options)) {
             this.nodeFS.mkdirSync(this.path(path), { mode: options.mode });
@@ -211,39 +175,21 @@ export class PassthroughFS extends FileSystem {
         }
         return this.nodeFS.statSync(this.path(path));
     }
-    /**
-     * Remove a directory.
-     */
     async rmdir(path) {
         await this.nodeFS.promises.rmdir(this.path(path));
     }
-    /**
-     * Remove a directory synchronously.
-     */
     rmdirSync(path) {
         this.nodeFS.rmdirSync(this.path(path));
     }
-    /**
-     * Synchronize data to the file system.
-     */
     async sync() {
         warn('Sync on passthrough is unnecessary');
     }
-    /**
-     * Synchronize data to the file system synchronously.
-     */
     syncSync() {
         warn('Sync on passthrough is unnecessary');
     }
-    /**
-     * Create a hard link.
-     */
     async link(target, link) {
         await this.nodeFS.promises.link(this.path(target), this.path(link));
     }
-    /**
-     * Create a hard link synchronously.
-     */
     linkSync(target, link) {
         this.nodeFS.linkSync(this.path(target), this.path(link));
     }

package/dist/backends/port.d.ts

@@ -33,13 +33,9 @@ export declare class PortFS<T extends RPC.Channel = RPC.Channel> extends PortFS_
     readonly channel: T;
     readonly timeout: number;
     readonly port: RPC.Port<T>;
-    /**
-     * @hidden
-     */
+    /** @hidden */
     _sync: import("./index.js").StoreFS<import("./memory.js").InMemoryStore>;
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
+    /** Constructs a new PortFS instance that connects with the FS running on `options.port`. */
     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>;

package/dist/backends/port.js

@@ -19,13 +19,9 @@ export class PortFS extends Async(FileSystem) {
     channel;
     timeout;
     port;
-    /**
-     * @hidden
-     */
+    /** @hidden */
     _sync = InMemory.create({ label: 'tmpfs:port' });
-    /**
-     * Constructs a new PortFS instance that connects with the FS running on `options.port`.
-     */
+    /** Constructs a new PortFS instance that connects with the FS running on `options.port`. */
     constructor(channel, timeout = 250) {
         super(0x706f7274, 'portfs');
         this.channel = channel;
@@ -34,11 +30,7 @@ export class PortFS extends Async(FileSystem) {
         RPC.attach(this.port, RPC.handleResponse);
     }
     rpc(method, ...args) {
-        return RPC.request({ method, args }, {
-            port: this.port,
-            timeout: this.timeout,
-            fs: this,
-        });
+        return RPC.request({ method, args }, { port: this.port, timeout: this.timeout, fs: this });
     }
     async ready() {
         await this.rpc('ready');

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

@@ -42,9 +42,6 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     ready(): Promise<void>;
     readySync(): void;
     constructor(store: T);
-    /**
-     * @experimental
-     */
     usage(): UsageInfo;
     /**
      * Load an index into the StoreFS.
@@ -77,13 +74,7 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     mkdirSync(path: string, options: CreationOptions): Inode;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
-    /**
-     * Updated the inode and data node at `path`
-     */
     sync(): Promise<void>;
-    /**
-     * Updated the inode and data node at `path`
-     */
     syncSync(): void;
     link(target: string, link: string): Promise<void>;
     linkSync(target: string, link: string): void;

package/dist/backends/store/fs.js

@@ -162,9 +162,6 @@ export class StoreFS extends FileSystem {
         this.label = store.label;
         debug(this.name + ': supports features: ' + this.store.flags?.join(', '));
     }
-    /**
-     * @experimental
-     */
     usage() {
         return (this.store.usage?.() || {
             totalSpace: 0,
@@ -525,13 +522,7 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_12);
         }
     }
-    /**
-     * Updated the inode and data node at `path`
-     */
     async sync() { }
-    /**
-     * Updated the inode and data node at `path`
-     */
     syncSync() { }
     async link(target, link) {
         const env_13 = { stack: [], error: void 0, hasError: false };
@@ -758,16 +749,13 @@ export class StoreFS extends FileSystem {
                 crit('Store contains an invalid root inode. Refusing to populate tables');
                 return;
             }
-            // Keep track of directories we have already traversed to avoid loops
             const visitedDirectories = new Set();
             let i = 0;
-            // Start BFS from root
             const queue = [['/', rootIno]];
             while (queue.length > 0) {
                 i++;
                 const [path, ino] = queue.shift();
                 this._add(ino, path);
-                // Get the inode data from the store
                 const inodeData = await tx.get(ino);
                 if (!inodeData) {
                     warn('Store is missing data for inode: ' + ino);
@@ -777,14 +765,10 @@ export class StoreFS extends FileSystem {
                     warn(`Invalid inode size for ino ${ino}: ${inodeData.length}`);
                     continue;
                 }
-                // Parse the raw data into our Inode object
                 const inode = new Inode(inodeData);
-                // If it is a directory and not yet visited, read its directory listing
-                if (!isDirectory(inode) || visitedDirectories.has(ino)) {
+                if (!isDirectory(inode) || visitedDirectories.has(ino))
                     continue;
-                }
                 visitedDirectories.add(ino);
-                // Grab the directory listing from the store
                 const dirData = await tx.get(inode.data);
                 if (!dirData) {
                     warn('Store is missing directory data: ' + inode.data);
@@ -963,11 +947,9 @@ export class StoreFS extends FileSystem {
             const { dir: parentPath, base: fname } = parse(path);
             const parent = await this.findInode(tx, parentPath);
             const listing = decodeDirListing((await tx.get(parent.data)) ?? _throw(withErrno('ENOENT')));
-            // Check if file already exists.
             if (listing[fname])
                 throw withErrno('EEXIST');
             const id = this.allocNew(path);
-            // Commit data.
             const inode = new Inode({
                 ...options,
                 ino: id,
@@ -977,7 +959,6 @@ export class StoreFS extends FileSystem {
             });
             await tx.set(inode.ino, inode);
             await tx.set(inode.data, data);
-            // Update and commit parent directory listing.
             listing[fname] = inode.ino;
             await tx.set(parent.data, encodeDirListing(listing));
             await tx.commit();
@@ -1025,7 +1006,6 @@ export class StoreFS extends FileSystem {
                 size: data.byteLength,
                 nlink: 1,
             });
-            // Update and commit parent directory listing.
             tx.setSync(inode.ino, inode);
             tx.setSync(inode.data, data);
             listing[fname] = inode.ino;

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

@@ -162,7 +162,7 @@ export declare class WrappedTransaction<T extends Store = Store> {
         data?: Uint8Array;
         offset: number;
     }[]>;
-    /**TransactionEntry
+    /**
      * List of keys modified in this transaction, if any.
      */
     protected modifiedKeys: Set<number>;

package/dist/backends/store/store.js

@@ -109,7 +109,7 @@ export class WrappedTransaction {
      * Allows us to roll back commits.
      */
     originalData = new Map();
-    /**TransactionEntry
+    /**
      * List of keys modified in this transaction, if any.
      */
     modifiedKeys = new Set();
@@ -154,11 +154,9 @@ export class WrappedTransaction {
     async abort() {
         if (this.done)
             return;
-        // Rollback old values.
         for (const [id, entries] of this.originalData) {
             if (!this.modifiedKeys.has(id))
                 continue;
-            // Key didn't exist.
             if (entries.some(ent => !ent.data)) {
                 await this.raw.remove(id);
                 this.fs._remove(id);
@@ -173,11 +171,9 @@ export class WrappedTransaction {
     abortSync() {
         if (this.done)
             return;
-        // Rollback old values.
         for (const [id, entries] of this.originalData) {
             if (!this.modifiedKeys.has(id))
                 continue;
-            // Key didn't exist.
             if (entries.some(ent => !ent.data)) {
                 this.raw.removeSync(id);
                 this.fs._remove(id);

package/dist/internal/contexts.d.ts

@@ -20,8 +20,7 @@ export interface FSContext {
     /** The unique ID of the context */
     readonly id: number;
     /**
-     * The absolute root path of the context
-     *
+     * The absolute root path of the context.
      * Note the parent's root is not considered
      */
     root: string;

package/dist/internal/credentials.d.ts

@@ -11,9 +11,6 @@ export interface Credentials {
     sgid: number;
     euid: number;
     egid: number;
-    /**
-     * List of group IDs.
-     */
     groups: number[];
 }
 /**

package/dist/internal/file_index.js

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-/* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
 import { withErrno } from 'kerium';
 import { sizeof } from 'memium';
 import { isJSON, randomInt } from 'utilium';

package/dist/internal/index_fs.d.ts

@@ -40,8 +40,8 @@ export declare abstract class IndexFS extends FileSystem {
     protected _mkdirSync?(path: string, options: CreationOptions): void;
     mkdir(path: string, options: CreationOptions): Promise<Inode>;
     mkdirSync(path: string, options: CreationOptions): Inode;
-    link(target: string, link: string): Promise<void>;
-    linkSync(target: string, link: string): void;
+    link(): Promise<void>;
+    linkSync(): void;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     sync(): Promise<void>;

package/dist/internal/index_fs.js

@@ -200,10 +200,10 @@ export class IndexFS extends FileSystem {
         this._mkdirSync?.(path, options);
         return inode;
     }
-    link(target, link) {
+    link() {
         throw withErrno('ENOSYS');
     }
-    linkSync(target, link) {
+    linkSync() {
         throw withErrno('ENOSYS');
     }
     async readdir(path) {

package/dist/internal/inode.d.ts

@@ -32,61 +32,39 @@ export interface InodeFields {
     data?: number;
     flags?: number;
     version?: number;
+    /** Extended attributes */
+    attributes?: Attributes;
 }
-/**
- * @category Internals
- * @internal
- */
-export interface InodeLike<T extends number | bigint = number> extends InodeFields {
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
+export interface StatsLike<T extends number | bigint = number | bigint> {
+    /** Size of the item in bytes. For directories/symlinks, this may be the size of the struct that represents the item. */
     size: T;
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the item type
-     */
+    /** Unix-style file mode (e.g. 0o644) that includes the item type */
     mode: T;
-    /**
-     * Time of last access, since epoch
-     */
+    /** Time of last access, since epoch */
     atimeMs: T;
-    /**
-     * Time of last modification, since epoch
-     */
+    /** Time of last modification, since epoch */
     mtimeMs: T;
-    /**
-     * Time of last time file status was changed, since epoch
-     */
+    /** Time of last time file status was changed, since epoch */
     ctimeMs: T;
-    /**
-     * Time of file creation, since epoch
-     */
+    /** Time of file creation, since epoch */
     birthtimeMs: T;
-    /**
-     * The id of the user that owns the file
-     */
+    /** The id of the user that owns the file */
     uid: T;
-    /**
-     * The id of the group that owns the file
-     */
+    /** The id of the group that owns the file */
     gid: T;
-    /**
-     * Inode number
-     */
+    /** Inode number */
     ino: T;
-    /**
-     * Number of hard links
-     */
+    /** Number of hard links */
     nlink: T;
-    /**
-     * Device ID for special files
-     */
+    /** Device ID for special files */
     rdev: T;
-    /**
-     * Extended attributes
-     */
-    attributes?: Attributes;
+}
+/**
+ * @category Internals
+ * @internal
+ * @todo [breaking] switch fully to using bigints
+ */
+export interface InodeLike<T extends number | bigint = number> extends InodeFields, StatsLike<T> {
 }
 /**
  * @internal @hidden

package/dist/internal/rpc.d.ts

@@ -100,15 +100,24 @@ export interface Message {
     method: Method;
     stack: string;
 }
-export interface Request<TMethod extends Method = Method> extends Message {
+export interface RequestInit<TMethod extends Method = Method> {
     method: TMethod;
     args: Parameters<Methods[TMethod]>;
 }
-export interface Response<TMethod extends Method = Method> extends Message {
-    error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
-    method: TMethod;
-    value: ReturnType<Methods[TMethod]>;
-}
+export type Request<TMethod extends Method = Method> = {
+    [K in Method]: Message & RequestInit<K>;
+}[TMethod];
+export type Response<TMethod extends Method = Method> = {
+    [K in Method]: Message & {
+        error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
+        method: K;
+        /**
+         * This is undefined if an error occurs, and we check it at runtime.
+         * We don't do the type stuff because Typescript gets confused
+         */
+        value: ReturnType<Methods[K]>;
+    };
+}[TMethod];
 /**
  * Encode a RPC message as a string using JSON.
  * This is only done when structured cloning is not available.
@@ -130,7 +139,7 @@ export interface Executor extends PromiseWithResolvers<any> {
     fs: PortFS;
     timeout: ReturnType<typeof setTimeout>;
 }
-export declare function request<const TRequest extends Request, TValue>(request: Omit<TRequest, 'id' | 'stack' | '_zenfs'>, { port, timeout: ms, fs }: Partial<Options> & {
+export declare function request<const Init extends RequestInit, TValue>(request: Init, { port, timeout: ms, fs }: Partial<Options> & {
     fs: PortFS;
 }): Promise<TValue>;
 export declare function handleResponse<const TMethod extends Method>(response: Response<TMethod>): void;