@zenfs/core 2.7.5 → 2.7.7

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

@@ -93,9 +93,7 @@ export class StoreFS extends FileSystem {
      * Add a inode/path pair
      */
     _add(ino, path) {
-        if (!this._paths.has(ino))
-            this._paths.set(ino, new Set());
-        this._paths.get(ino).add(path);
+        this._paths.getOrInsertComputed(ino, () => new Set()).add(path);
         this._ids.set(path, ino);
     }
     /**
@@ -162,9 +160,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 +520,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 +747,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 +763,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 +945,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 +957,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 +1004,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);
@@ -206,9 +202,7 @@ export class WrappedTransaction {
      * on during the transaction.
      */
     stash(id, data, offset = 0) {
-        if (!this.originalData.has(id))
-            this.originalData.set(id, []);
-        this.originalData.get(id).push({ data, offset });
+        this.originalData.getOrInsertComputed(id, () => []).push({ data, offset });
     }
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.

package/dist/config.d.ts

@@ -72,6 +72,12 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     disableAccessChecks: boolean;
+    /**
+     * If true, path resolution always walks each directory in a path, checking search permission on each.
+     * This is more correct but can be much slower.
+     * @default false
+     */
+    resolveFullWalk: boolean;
     /**
      * If true, files will only sync to the file system when closed.
      * This overrides `disableUpdateOnRead`
@@ -79,6 +85,7 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * This can increase performance.
      * @experimental
      * @default false
+     * @deprecated Replaced by the `Sync` inode flag in v2.0.0
      */
     onlySyncOnClose: boolean;
     /**

package/dist/config.js

@@ -6,7 +6,7 @@ import { DeviceFS } from './internal/devices.js';
 import { FileSystem } from './internal/filesystem.js';
 import { exists, mkdir, stat } from './node/promises.js';
 import { existsSync, mkdirSync, statSync } from './node/sync.js';
-import { _setAccessChecks } from './vfs/config.js';
+import { _setVFSConfig } from './vfs/config.js';
 import { mount, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
@@ -209,7 +209,10 @@ export async function configure(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {
@@ -257,7 +260,10 @@ export function configureSync(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {

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/error.d.ts

@@ -25,3 +25,8 @@ export declare function wrap<const FS, const Prop extends keyof FS & string>(fs:
  * Wraps an `fs` so that thrown errors aren't empty
  */
 export declare function withExceptionContext<const FS extends FileSystem>(fs: FS, context: ExceptionExtra): FS;
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export declare function withoutExceptionContext<const FS extends FileSystem>(fs: FS): FS;

package/dist/internal/error.js

@@ -26,6 +26,7 @@ export function wrap(fs, prop, path, dest) {
         }
     };
 }
+const kTarget = Symbol('withExceptionContext:target');
 /**
  * @internal
  * Wraps an `fs` so that thrown errors aren't empty
@@ -33,6 +34,8 @@ export function wrap(fs, prop, path, dest) {
 export function withExceptionContext(fs, context) {
     return new Proxy(fs, {
         get(target, prop) {
+            if (prop === kTarget)
+                return target;
             const value = Reflect.get(target, prop);
             if (typeof value != 'function')
                 return value;
@@ -58,3 +61,10 @@ export function withExceptionContext(fs, context) {
         },
     });
 }
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export function withoutExceptionContext(fs) {
+    return fs[kTarget] ?? fs;
+}

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) {