@zenfs/core 1.3.3 → 1.3.5

package/dist/file.js

@@ -2,7 +2,7 @@ import { config } from './emulation/config.js';
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT, size_max } from './emulation/constants.js';
 import { Errno, ErrnoError } from './error.js';
 import './polyfills.js';
-import { Stats } from './stats.js';
+import { _chown, Stats } from './stats.js';
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
@@ -411,8 +411,8 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'File.chmod');
         }
         this.dirty = true;
-        this.stats.chmod(mode);
-        if (config.syncImmediately)
+        this.stats.mode = (this.stats.mode & (mode > S_IFMT ? ~S_IFMT : S_IFMT)) | mode;
+        if (config.syncImmediately || mode > S_IFMT)
             await this.sync();
     }
     chmodSync(mode) {
@@ -420,8 +420,8 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'File.chmod');
         }
         this.dirty = true;
-        this.stats.chmod(mode);
-        if (config.syncImmediately)
+        this.stats.mode = (this.stats.mode & (mode > S_IFMT ? ~S_IFMT : S_IFMT)) | mode;
+        if (config.syncImmediately || mode > S_IFMT)
             this.syncSync();
     }
     async chown(uid, gid) {
@@ -429,7 +429,7 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'File.chown');
         }
         this.dirty = true;
-        this.stats.chown(uid, gid);
+        _chown(this.stats, uid, gid);
         if (config.syncImmediately)
             await this.sync();
     }
@@ -438,7 +438,7 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'File.chown');
         }
         this.dirty = true;
-        this.stats.chown(uid, gid);
+        _chown(this.stats, uid, gid);
         if (config.syncImmediately)
             this.syncSync();
     }
@@ -462,22 +462,6 @@ export class PreloadFile extends File {
         if (config.syncImmediately)
             this.syncSync();
     }
-    async _setType(type) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File._setType');
-        }
-        this.dirty = true;
-        this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-        await this.sync();
-    }
-    _setTypeSync(type) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File._setType');
-        }
-        this.dirty = true;
-        this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-        this.syncSync();
-    }
 }
 /**
  * For the file systems which do not sync to anything.

package/dist/stats.d.ts

@@ -1,5 +1,4 @@
 import type * as Node from 'node:fs';
-import { type Credentials } from './credentials.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of a file. Applied to 'mode'.
@@ -43,6 +42,10 @@ export interface StatsLike<T extends number | bigint = number | bigint> {
      * Inode number
      */
     ino: T;
+    /**
+     * Number of hard links
+     */
+    nlink: T;
 }
 /**
  * Provides information about a particular entry in the file system.
@@ -136,28 +139,29 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * @internal
      */
     hasAccess(mode: number): boolean;
-    /**
-     * Convert the current stats object into a credentials object
-     * @internal
-     */
-    cred(uid?: number, gid?: number): Credentials;
     /**
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
      * @internal
+     * @deprecated This will be removed in the next minor release since it is internal
      */
     chmod(mode: number): void;
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
      * @internal
+     * @deprecated This will be removed in the next minor release since it is internal
      */
-    chown(uid: number | bigint, gid: number | bigint): void;
+    chown(uid: number, gid: number): void;
     get atimeNs(): bigint;
     get mtimeNs(): bigint;
     get ctimeNs(): bigint;
     get birthtimeNs(): bigint;
 }
+/**
+ * @hidden @internal
+ */
+export declare function _chown(stats: Partial<StatsLike<number>>, uid: number, gid: number): void;
 /**
  * Implementation of Node's `Stats`.
  *

package/dist/stats.js

@@ -124,7 +124,7 @@ export class StatsCommon {
                 perm |= X_OK;
         }
         // Group permissions
-        if (credentials.gid === this.gid) {
+        if (credentials.gid === this.gid || credentials.groups.includes(Number(this.gid))) {
             if (this.mode & S_IRGRP)
                 perm |= R_OK;
             if (this.mode & S_IWGRP)
@@ -142,24 +142,11 @@ export class StatsCommon {
         // Perform the access check
         return (perm & mode) === mode;
     }
-    /**
-     * Convert the current stats object into a credentials object
-     * @internal
-     */
-    cred(uid = Number(this.uid), gid = Number(this.gid)) {
-        return {
-            uid,
-            gid,
-            suid: Number(this.uid),
-            sgid: Number(this.gid),
-            euid: uid,
-            egid: gid,
-        };
-    }
     /**
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
      * @internal
+     * @deprecated This will be removed in the next minor release since it is internal
      */
     chmod(mode) {
         this.mode = this._convert((this.mode & S_IFMT) | mode);
@@ -168,6 +155,7 @@ export class StatsCommon {
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
      * @internal
+     * @deprecated This will be removed in the next minor release since it is internal
      */
     chown(uid, gid) {
         uid = Number(uid);
@@ -192,6 +180,17 @@ export class StatsCommon {
         return BigInt(this.birthtimeMs) * 1000n;
     }
 }
+/**
+ * @hidden @internal
+ */
+export function _chown(stats, uid, gid) {
+    if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {
+        stats.uid = uid;
+    }
+    if (!isNaN(gid) && 0 <= gid && gid < 2 ** 32) {
+        stats.gid = gid;
+    }
+}
 /**
  * Implementation of Node's `Stats`.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.3.3",
+	"version": "1.3.5",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -74,10 +74,12 @@
 		"@types/readable-stream": "^4.0.10",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
-		"minimatch": "^9.0.3",
 		"readable-stream": "^4.5.2",
 		"utilium": "^1.0.0"
 	},
+	"optionalDependencies": {
+		"minimatch": "^9.0.3"
+	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",
 		"@types/eslint__js": "^8.42.3",

package/readme.md

@@ -64,6 +64,8 @@ await configure({
 };
 ```
 
+Note that while you aren't required to use absolute paths for the keys of `mounts`, it is a good practice to do so.
+
 > [!TIP]
 > When configuring a mount point, you can pass in
 >

package/scripts/make-index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { readdirSync, statSync, writeFileSync } from 'node:fs';
-import { minimatch } from 'minimatch';
-import { join, relative, resolve } from 'node:path/posix';
+import _path from 'node:path/posix';
 import { parseArgs } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
@@ -37,6 +36,24 @@ if (options.quiet && options.verbose) {
 	process.exit();
 }
 
+let matchesGlob = _path.matchesGlob;
+
+if (matchesGlob && options.verbose) {
+	console.debug('[debug] path.matchesGlob is available.');
+}
+
+if (!matchesGlob) {
+	console.warn('Warning: path.matchesGlob is not available, falling back to minimatch. (Node 20.17.0+ or 22.5.0+ needed)');
+
+	try {
+		const { minimatch } = await import('minimatch');
+		matchesGlob = minimatch;
+	} catch {
+		console.error('Fatal error: Failed to fall back to minimatch (is it installed?)');
+		process.exit(1);
+	}
+}
+
 function fixSlash(path) {
 	return path.replaceAll('\\', '/');
 }
@@ -71,7 +88,7 @@ const entries = new Map();
 
 function computeEntries(path) {
 	try {
-		if (options.ignore.some(pattern => minimatch(path, pattern))) {
+		if (options.ignore.some(pattern => matchesGlob(path, pattern))) {
 			if (!options.quiet) console.log(`${color('yellow', 'skip')} ${path}`);
 			return;
 		}
@@ -79,7 +96,7 @@ function computeEntries(path) {
 		const stats = statSync(path);
 
 		if (stats.isFile()) {
-			entries.set('/' + relative(resolvedRoot, path), stats);
+			entries.set('/' + _path.relative(resolvedRoot, path), stats);
 			if (options.verbose) {
 				console.log(`${color('green', 'file')} ${path}`);
 			}
@@ -87,9 +104,9 @@ function computeEntries(path) {
 		}
 
 		for (const file of readdirSync(path)) {
-			computeEntries(join(path, file));
+			computeEntries(_path.join(path, file));
 		}
-		entries.set('/' + relative(resolvedRoot, path), stats);
+		entries.set('/' + _path.relative(resolvedRoot, path), stats);
 		if (options.verbose) {
 			console.log(`${color('bright_green', ' dir')} ${path}`);
 		}
@@ -102,7 +119,7 @@ function computeEntries(path) {
 
 computeEntries(resolvedRoot);
 if (!options.quiet) {
-	console.log('Generated listing for ' + fixSlash(resolve(root)));
+	console.log('Generated listing for ' + fixSlash(_path.resolve(root)));
 }
 
 const index = {

package/src/backends/port/fs.ts

@@ -6,7 +6,7 @@ import { Errno, ErrnoError } from '../../error.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 { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
@@ -104,10 +104,6 @@ export class PortFile extends File {
 		this._throwNoSync('utimes');
 	}
 
-	public _setType(type: FileType): Promise<void> {
-		return this.rpc('_setType', type);
-	}
-
 	public _setTypeSync(): void {
 		this._throwNoSync('_setType');
 	}

package/src/config.ts

@@ -1,11 +1,10 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 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';
 import * as fs from './emulation/index.js';
-import type { AbsolutePath } from './emulation/path.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 
@@ -68,8 +67,11 @@ export async function resolveMountConfig<T extends Backend>(configuration: Mount
 	return mount;
 }
 
+/**
+ * An object mapping mount points to backends
+ */
 export interface ConfigMounts {
-	[K: AbsolutePath]: Backend;
+	[K: string]: Backend;
 }
 
 /**
@@ -79,7 +81,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]> };
+	mounts: { [K in keyof T]: MountConfiguration<T[K]> };
 
 	/**
 	 * The uid to use
@@ -188,7 +190,7 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 	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;
@@ -200,10 +202,8 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 		const toMount: [string, FileSystem][] = [];
 		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 ??= configuration.disableAsyncCache || false;

package/src/credentials.ts

@@ -10,6 +10,10 @@ export interface Credentials {
 	sgid: number;
 	euid: number;
 	egid: number;
+	/**
+	 * List of group IDs.
+	 */
+	groups: number[];
 }
 
 export const credentials: Credentials = {
@@ -19,16 +23,27 @@ export const credentials: Credentials = {
 	sgid: 0,
 	euid: 0,
 	egid: 0,
+	groups: [],
 };
 
+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 const rootCredentials: Credentials = {
-	uid: 0,
-	gid: 0,
-	suid: 0,
-	sgid: 0,
-	euid: 0,
-	egid: 0,
-};
+export function useCredentials(source: CredentialInit): void {
+	Object.assign(credentials, {
+		suid: source.uid,
+		sgid: source.gid,
+		euid: source.uid,
+		egid: source.gid,
+		...source,
+	});
+}

package/src/emulation/cache.ts

@@ -13,10 +13,17 @@ export class Cache<T> {
 
 	protected async = new Map<string, Promise<T>>();
 
+	/**
+	 * Whether the data exists in the cache
+	 */
+	has(path: string): boolean {
+		return this.isEnabled && this.sync.has(path);
+	}
+
 	/**
 	 * Gets data from the cache, if is exists and the cache is enabled.
 	 */
-	getSync(path: string): T | undefined {
+	get(path: string): T | undefined {
 		if (!this.isEnabled) return;
 
 		return this.sync.get(path);
@@ -25,7 +32,7 @@ export class Cache<T> {
 	/**
 	 * Adds data if the cache is enabled
 	 */
-	setSync(path: string, value: T): void {
+	set(path: string, value: T): void {
 		if (!this.isEnabled) return;
 
 		this.sync.set(path, value);
@@ -33,18 +40,16 @@ export class Cache<T> {
 	}
 
 	/**
-	 * Clears the cache if it is enabled
+	 * Whether the data exists in the cache
 	 */
-	clearSync(): void {
-		if (!this.isEnabled) return;
-
-		this.sync.clear();
+	hasAsync(path: string): boolean {
+		return this.isEnabled && this.async.has(path);
 	}
 
 	/**
 	 * 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 {
 		if (!this.isEnabled) return;
 
 		return this.async.get(path);
@@ -53,7 +58,7 @@ export class Cache<T> {
 	/**
 	 * Adds data if the cache is enabled
 	 */
-	set(path: string, value: Promise<T>): void {
+	setAsync(path: string, value: Promise<T>): void {
 		if (!this.isEnabled) return;
 
 		this.async.set(path, value);
@@ -65,7 +70,7 @@ export class Cache<T> {
 	 */
 	clear(): void {
 		if (!this.isEnabled) return;
-
+		this.sync.clear();
 		this.async.clear();
 	}
 }

package/src/emulation/promises.ts

@@ -16,7 +16,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, type InternalOptions, type ReaddirOptions } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
@@ -395,6 +395,7 @@ export async function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promis
 		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));
@@ -471,7 +472,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 	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);
@@ -623,7 +624,7 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	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');
 		}
@@ -718,8 +719,8 @@ export async function readdir(
 
 	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) {
@@ -740,8 +741,8 @@ export async function readdir(
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;
 		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) {
@@ -822,7 +823,7 @@ export async function symlink(target: fs.PathLike, path: fs.PathLike, type: fs.s
 
 	await using handle = await _open(path, 'w+', 0o644, false);
 	await handle.writeFile(target.toString());
-	await handle.file._setType(constants.S_IFLNK);
+	await handle.file.chmod(constants.S_IFLNK);
 }
 symlink satisfies typeof promises.symlink;
 
@@ -891,20 +892,25 @@ export async function realpath(path: fs.PathLike, options: fs.BufferEncodingOpti
 export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
 export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Promise<string | Buffer> {
 	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));
+		const target = resolve(realDir, await readlink(lpath));
 
-		return await (cache.paths.get(target) || realpath(target));
+		const real = cache.paths.getAsync(target) || realpath(target);
+		cache.paths.setAsync(path, real);
+		return await real;
 	} catch (e) {
 		if ((e as ErrnoError).code == 'ENOENT') {
 			return path;
@@ -968,7 +974,7 @@ access satisfies typeof promises.access;
 export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions) {
 	path = normalizePath(path);
 
-	const stats = await (cache.stats.get(path) ||
+	const stats = await (cache.stats.getAsync(path) ||
 		stat(path).catch((error: ErrnoError) => {
 			if (error.code == 'ENOENT' && options?.force) return undefined;
 			throw error;
@@ -978,7 +984,7 @@ export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOpt
 		return;
 	}
 
-	cache.stats.setSync(path, stats);
+	cache.stats.set(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -992,10 +998,10 @@ export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOpt
 			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/src/emulation/shared.ts

@@ -8,6 +8,7 @@ import type { FileSystem } from '../filesystem.js';
 import { normalizePath } from '../utils.js';
 import { resolve, type AbsolutePath } from './path.js';
 import { size_max } from './constants.js';
+import { paths as pathCache } from './cache.js';
 
 // descriptors
 export const fdMap: Map<number, File> = new Map();
@@ -47,6 +48,7 @@ export function mount(mountPoint: string, fs: FileSystem): void {
 		throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
 	}
 	mounts.set(mountPoint, fs);
+	pathCache.clear();
 }
 
 /**
@@ -61,6 +63,7 @@ export function umount(mountPoint: string): void {
 		throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
 	}
 	mounts.delete(mountPoint);
+	pathCache.clear();
 }
 
 /**