@zenfs/core 1.3.3 → 1.3.5

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

@@ -4,7 +4,7 @@ import { type MountConfiguration } from '../../config.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Async } from '../../mixins/async.js';
-import { Stats, type FileType } from '../../stats.js';
+import { Stats } from '../../stats.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
 type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
@@ -37,7 +37,6 @@ export declare class PortFile extends File {
     chmodSync(): void;
     utimes(atime: Date, mtime: Date): Promise<void>;
     utimesSync(): void;
-    _setType(type: FileType): Promise<void>;
     _setTypeSync(): void;
     close(): Promise<void>;
     closeSync(): void;

package/dist/backends/port/fs.js

@@ -67,9 +67,6 @@ export class PortFile extends File {
     utimesSync() {
         this._throwNoSync('utimes');
     }
-    _setType(type) {
-        return this.rpc('_setType', type);
-    }
     _setTypeSync() {
         this._throwNoSync('_setType');
     }

package/dist/config.d.ts

@@ -1,5 +1,4 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
-import type { AbsolutePath } from './emulation/path.js';
 /**
  * Configuration for a specific mount point
  */
@@ -9,8 +8,11 @@ export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendCon
  * @see MountConfiguration
  */
 export declare function resolveMountConfig<T extends Backend>(configuration: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
+/**
+ * An object mapping mount points to backends
+ */
 export interface ConfigMounts {
-    [K: AbsolutePath]: Backend;
+    [K: string]: Backend;
 }
 /**
  * Configuration
@@ -20,7 +22,7 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * An object mapping mount points to mount configuration
      */
     mounts: {
-        [K in keyof T & AbsolutePath]: MountConfiguration<T[K]>;
+        [K in keyof T]: MountConfiguration<T[K]>;
     };
     /**
      * The uid to use

package/dist/config.js

@@ -1,5 +1,5 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
-import { credentials } from './credentials.js';
+import { useCredentials } from './credentials.js';
 import { DeviceFS } from './devices.js';
 import * as cache from './emulation/cache.js';
 import { config } from './emulation/config.js';
@@ -87,7 +87,7 @@ async function mount(path, mount) {
 export async function configure(configuration) {
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
-    Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+    useCredentials({ uid, gid });
     cache.stats.isEnabled = configuration.cacheStats ?? false;
     cache.paths.isEnabled = configuration.cachePaths ?? false;
     config.checkAccess = !configuration.disableAccessChecks;
@@ -96,10 +96,8 @@ export async function configure(configuration) {
     if (configuration.mounts) {
         const toMount = [];
         let unmountRoot = false;
-        for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
-            if (!point.startsWith('/')) {
-                throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
-            }
+        for (const [_point, mountConfig] of Object.entries(configuration.mounts)) {
+            const point = _point.startsWith('/') ? _point : '/' + _point;
             if (isBackendConfig(mountConfig)) {
                 mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
             }

package/dist/credentials.d.ts

@@ -10,9 +10,21 @@ export interface Credentials {
     sgid: number;
     euid: number;
     egid: number;
+    /**
+     * List of group IDs.
+     */
+    groups: number[];
 }
 export declare const credentials: Credentials;
+export interface CredentialInit {
+    uid: number;
+    gid: number;
+    suid?: number;
+    sgid?: number;
+    euid?: number;
+    egid?: number;
+}
 /**
- * @deprecated
+ * Uses credentials from the provided uid and gid.
  */
-export declare const rootCredentials: Credentials;
+export declare function useCredentials(source: CredentialInit): void;

package/dist/credentials.js

@@ -5,15 +5,17 @@ export const credentials = {
     sgid: 0,
     euid: 0,
     egid: 0,
+    groups: [],
 };
 /**
- * @deprecated
+ * Uses credentials from the provided uid and gid.
  */
-export const rootCredentials = {
-    uid: 0,
-    gid: 0,
-    suid: 0,
-    sgid: 0,
-    euid: 0,
-    egid: 0,
-};
+export function useCredentials(source) {
+    Object.assign(credentials, {
+        suid: source.uid,
+        sgid: source.gid,
+        euid: source.uid,
+        egid: source.gid,
+        ...source,
+    });
+}

package/dist/emulation/cache.d.ts

@@ -7,26 +7,30 @@ export declare class Cache<T> {
     isEnabled: boolean;
     protected sync: Map<string, T>;
     protected async: Map<string, Promise<T>>;
+    /**
+     * Whether the data exists in the cache
+     */
+    has(path: string): boolean;
     /**
      * Gets data from the cache, if is exists and the cache is enabled.
      */
-    getSync(path: string): T | undefined;
+    get(path: string): T | undefined;
     /**
      * Adds data if the cache is enabled
      */
-    setSync(path: string, value: T): void;
+    set(path: string, value: T): void;
     /**
-     * Clears the cache if it is enabled
+     * Whether the data exists in the cache
      */
-    clearSync(): void;
+    hasAsync(path: string): boolean;
     /**
      * Gets data from the cache, if it exists and the cache is enabled.
      */
-    get(path: string): Promise<T> | undefined;
+    getAsync(path: string): Promise<T> | undefined;
     /**
      * Adds data if the cache is enabled
      */
-    set(path: string, value: Promise<T>): void;
+    setAsync(path: string, value: Promise<T>): void;
     /**
      * Clears the cache if it is enabled
      */

package/dist/emulation/cache.js

@@ -9,10 +9,16 @@ export class Cache {
         this.sync = new Map();
         this.async = new Map();
     }
+    /**
+     * Whether the data exists in the cache
+     */
+    has(path) {
+        return this.isEnabled && this.sync.has(path);
+    }
     /**
      * Gets data from the cache, if is exists and the cache is enabled.
      */
-    getSync(path) {
+    get(path) {
         if (!this.isEnabled)
             return;
         return this.sync.get(path);
@@ -20,24 +26,22 @@ export class Cache {
     /**
      * Adds data if the cache is enabled
      */
-    setSync(path, value) {
+    set(path, value) {
         if (!this.isEnabled)
             return;
         this.sync.set(path, value);
         this.async.set(path, Promise.resolve(value));
     }
     /**
-     * Clears the cache if it is enabled
+     * Whether the data exists in the cache
      */
-    clearSync() {
-        if (!this.isEnabled)
-            return;
-        this.sync.clear();
+    hasAsync(path) {
+        return this.isEnabled && this.async.has(path);
     }
     /**
      * Gets data from the cache, if it exists and the cache is enabled.
      */
-    get(path) {
+    getAsync(path) {
         if (!this.isEnabled)
             return;
         return this.async.get(path);
@@ -45,7 +49,7 @@ export class Cache {
     /**
      * Adds data if the cache is enabled
      */
-    set(path, value) {
+    setAsync(path, value) {
         if (!this.isEnabled)
             return;
         this.async.set(path, value);
@@ -57,6 +61,7 @@ export class Cache {
     clear() {
         if (!this.isEnabled)
             return;
+        this.sync.clear();
         this.async.clear();
     }
 }

package/dist/emulation/promises.js

@@ -56,7 +56,7 @@ import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse } from './path.js';
+import { dirname, join, parse, resolve } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
@@ -360,6 +360,7 @@ export async function rename(oldPath, newPath) {
         if (src.mountPoint == dst.mountPoint) {
             await src.fs.rename(src.path, dst.path);
             emitChange('rename', oldPath.toString());
+            emitChange('change', newPath.toString());
             return;
         }
         await writeFile(newPath, await readFile(oldPath));
@@ -435,7 +436,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(await (cache.stats.get(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.stats.getAsync(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -583,7 +584,7 @@ export async function rmdir(path) {
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = await (cache.stats.get(path) || fs.stat(resolved));
+        const stats = await (cache.stats.getAsync(path) || fs.stat(resolved));
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
@@ -642,8 +643,8 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path);
-    const _stats = cache.stats.get(path) || fs.stat(resolved).catch(handleError);
-    cache.stats.set(path, _stats);
+    const _stats = cache.stats.getAsync(path) || fs.stat(resolved).catch(handleError);
+    cache.stats.setAsync(path, _stats);
     const stats = await _stats;
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
@@ -659,8 +660,8 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            const _entryStats = cache.stats.get(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
-            cache.stats.set(join(path, entry), _entryStats);
+            const _entryStats = cache.stats.getAsync(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+            cache.stats.setAsync(join(path, entry), _entryStats);
             entryStats = await _entryStats;
         }
         if (options?.withFileTypes) {
@@ -737,7 +738,7 @@ export async function symlink(target, path, type = 'file') {
         }
         const handle = __addDisposableResource(env_5, await _open(path, 'w+', 0o644, false), true);
         await handle.writeFile(target.toString());
-        await handle.file._setType(constants.S_IFLNK);
+        await handle.file.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -880,17 +881,23 @@ export async function lutimes(path, atime, mtime) {
 lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);
+    if (cache.paths.hasAsync(path))
+        return cache.paths.getAsync(path);
     const { base, dir } = parse(path);
-    const lpath = join(dir == '/' ? '/' : await (cache.paths.get(dir) || realpath(dir)), base);
-    const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
+    const realDir = dir == '/' ? '/' : await (cache.paths.getAsync(dir) || realpath(dir));
+    const lpath = join(realDir, base);
+    const { fs, path: resolvedPath } = resolveMount(lpath);
     try {
-        const _stats = cache.stats.get(lpath) || fs.stat(resolvedPath);
-        cache.stats.set(lpath, _stats);
+        const _stats = cache.stats.getAsync(lpath) || fs.stat(resolvedPath);
+        cache.stats.setAsync(lpath, _stats);
         if (!(await _stats).isSymbolicLink()) {
+            cache.paths.set(path, lpath);
             return lpath;
         }
-        const target = mountPoint + (await readlink(lpath));
-        return await (cache.paths.get(target) || realpath(target));
+        const target = resolve(realDir, await readlink(lpath));
+        const real = cache.paths.getAsync(target) || realpath(target);
+        cache.paths.setAsync(path, real);
+        return await real;
     }
     catch (e) {
         if (e.code == 'ENOENT') {
@@ -945,7 +952,7 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = await (cache.stats.get(path) ||
+    const stats = await (cache.stats.getAsync(path) ||
         stat(path).catch((error) => {
             if (error.code == 'ENOENT' && options?.force)
                 return undefined;
@@ -954,7 +961,7 @@ export async function rm(path, options) {
     if (!stats) {
         return;
     }
-    cache.stats.setSync(path, stats);
+    cache.stats.set(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -966,10 +973,10 @@ export async function rm(path, options) {
             break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
-            await unlink(path);
-            break;
         case constants.S_IFBLK:
         case constants.S_IFCHR:
+            await unlink(path);
+            break;
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:

package/dist/emulation/shared.js

@@ -4,6 +4,7 @@ import { Errno, ErrnoError } from '../error.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
 import { size_max } from './constants.js';
+import { paths as pathCache } from './cache.js';
 // descriptors
 export const fdMap = new Map();
 let nextFd = 100;
@@ -37,6 +38,7 @@ export function mount(mountPoint, fs) {
         throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
     }
     mounts.set(mountPoint, fs);
+    pathCache.clear();
 }
 /**
  * Unmounts the file system at `mountPoint`.
@@ -50,6 +52,7 @@ export function umount(mountPoint) {
         throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
     }
     mounts.delete(mountPoint);
+    pathCache.clear();
 }
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root

package/dist/emulation/sync.js

@@ -54,7 +54,7 @@ import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse } from './path.js';
+import { dirname, join, parse, resolve } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { emitChange } from './watchers.js';
 export function renameSync(oldPath, newPath) {
@@ -69,6 +69,7 @@ export function renameSync(oldPath, newPath) {
         if (oldMount === newMount) {
             oldMount.fs.renameSync(oldMount.path, newMount.path);
             emitChange('rename', oldPath.toString());
+            emitChange('change', newPath.toString());
             return;
         }
         writeFileSync(newPath, readFileSync(oldPath));
@@ -147,7 +148,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -393,7 +394,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+        const stats = cache.stats.get(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -446,8 +447,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
-        cache.stats.setSync(path, stats);
+        const stats = cache.stats.get(path) || fs.statSync(resolved);
+        cache.stats.set(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -462,8 +463,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.stats.setSync(join(path, entry), entryStat);
+        const entryStat = cache.stats.get(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.stats.set(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -489,7 +490,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.stats.clearSync();
+        cache.stats.clear();
     }
     return values;
 }
@@ -535,7 +536,7 @@ export function symlinkSync(target, path, type = 'file') {
     }
     writeFileSync(path, target.toString());
     const file = _openSync(path, 'r+', 0o644, false);
-    file._setTypeSync(constants.S_IFLNK);
+    file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
@@ -592,16 +593,23 @@ export function lutimesSync(path, atime, mtime) {
 lutimesSync;
 export function realpathSync(path, options) {
     path = normalizePath(path);
+    if (cache.paths.has(path))
+        return cache.paths.get(path);
     const { base, dir } = parse(path);
-    const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
-    const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
+    const realDir = dir == '/' ? '/' : cache.paths.get(dir) || realpathSync(dir);
+    const lpath = join(realDir, base);
+    const { fs, path: resolvedPath } = resolveMount(lpath);
     try {
-        const stats = fs.statSync(resolvedPath);
+        const stats = cache.stats.get(lpath) || fs.statSync(resolvedPath);
+        cache.stats.set(lpath, stats);
         if (!stats.isSymbolicLink()) {
+            cache.paths.set(path, lpath);
             return lpath;
         }
-        const target = mountPoint + readlinkSync(lpath, options).toString();
-        return cache.paths.getSync(target) || realpathSync(target);
+        const target = resolve(realDir, readlinkSync(lpath, options).toString());
+        const real = cache.paths.get(target) || realpathSync(target);
+        cache.paths.set(path, real);
+        return real;
     }
     catch (e) {
         if (e.code == 'ENOENT') {
@@ -627,7 +635,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.stats.getSync(path) || statSync(path);
+        stats = cache.stats.get(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -636,7 +644,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.stats.setSync(path, stats);
+    cache.stats.set(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -648,18 +656,18 @@ export function rmSync(path, options) {
             break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
-            unlinkSync(path);
-            break;
         case constants.S_IFBLK:
         case constants.S_IFCHR:
+            unlinkSync(path);
+            break;
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.stats.clearSync();
+            cache.stats.clear();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.stats.clearSync();
+        cache.stats.clear();
     }
 }
 rmSync;

package/dist/emulation/watchers.js

@@ -2,7 +2,7 @@ import { EventEmitter } from 'eventemitter3';
 import { ErrnoError } from '../error.js';
 import { isStatsEqual } from '../stats.js';
 import { normalizePath } from '../utils.js';
-import { dirname, basename } from './path.js';
+import { basename, dirname } from './path.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -130,22 +130,22 @@ export function removeWatcher(path, watcher) {
     }
 }
 export function emitChange(eventType, filename) {
-    let normalizedFilename = normalizePath(filename);
+    filename = normalizePath(filename);
     // Notify watchers on the specific file
-    if (watchers.has(normalizedFilename)) {
-        for (const watcher of watchers.get(normalizedFilename)) {
+    if (watchers.has(filename)) {
+        for (const watcher of watchers.get(filename)) {
             watcher.emit('change', eventType, basename(filename));
         }
     }
     // Notify watchers on parent directories if they are watching recursively
-    let parent = dirname(normalizedFilename);
-    while (parent !== normalizedFilename && parent !== '/') {
+    let parent = filename, normalizedFilename;
+    while (parent !== normalizedFilename) {
+        normalizedFilename = parent;
+        parent = dirname(parent);
         if (watchers.has(parent)) {
             for (const watcher of watchers.get(parent)) {
-                watcher.emit('change', eventType, basename(filename));
+                watcher.emit('change', eventType, filename.slice(parent.length + (parent == '/' ? 0 : 1)));
             }
         }
-        normalizedFilename = parent;
-        parent = dirname(parent);
     }
 }

package/dist/file.d.ts

@@ -1,7 +1,7 @@
 import type { FileReadResult } from 'node:fs/promises';
 import type { FileSystem } from './filesystem.js';
 import './polyfills.js';
-import { Stats, type FileType } from './stats.js';
+import { Stats } from './stats.js';
 /**
     Typescript does not include a type declaration for resizable array buffers.
     It has been standardized into ECMAScript though
@@ -123,16 +123,6 @@ export declare abstract class File<FS extends FileSystem = FileSystem> {
      * Change the file timestamps of the file.
      */
     abstract utimesSync(atime: Date, mtime: Date): void;
-    /**
-     * Set the file type
-     * @internal
-     */
-    abstract _setType(type: FileType): Promise<void>;
-    /**
-     * Set the file type
-     * @internal
-     */
-    abstract _setTypeSync(type: FileType): void;
 }
 /**
  * An implementation of `File` that operates completely in-memory.
@@ -243,8 +233,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
     chownSync(uid: number, gid: number): void;
     utimes(atime: Date, mtime: Date): Promise<void>;
     utimesSync(atime: Date, mtime: Date): void;
-    _setType(type: FileType): Promise<void>;
-    _setTypeSync(type: FileType): void;
 }
 /**
  * For the file systems which do not sync to anything.