@zenfs/core 1.2.10 → 1.3.0

package/src/backends/store/simple.ts

@@ -1,14 +1,13 @@
-import type { Ino } from '../../inode.js';
 import { SyncTransaction, type Store } from './store.js';
 
 /**
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
-	keys(): Iterable<Ino>;
-	get(ino: Ino): Uint8Array | undefined;
-	set(ino: Ino, data: Uint8Array): void;
-	delete(ino: Ino): void;
+	keys(): Iterable<bigint>;
+	get(id: bigint): Uint8Array | undefined;
+	set(id: bigint, data: Uint8Array): void;
+	delete(id: bigint): void;
 }
 
 /**
@@ -18,33 +17,33 @@ export interface SimpleSyncStore extends Store {
 export abstract class SimpleAsyncStore implements SimpleSyncStore {
 	public abstract name: string;
 
-	protected cache: Map<Ino, Uint8Array> = new Map();
+	protected cache: Map<bigint, Uint8Array> = new Map();
 
 	protected queue: Set<Promise<unknown>> = new Set();
 
-	protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
+	protected abstract entries(): Promise<Iterable<[bigint, Uint8Array]>>;
 
-	public keys(): Iterable<Ino> {
+	public keys(): Iterable<bigint> {
 		return this.cache.keys();
 	}
 
-	public get(ino: Ino): Uint8Array | undefined {
-		return this.cache.get(ino);
+	public get(id: bigint): Uint8Array | undefined {
+		return this.cache.get(id);
 	}
 
-	public set(ino: Ino, data: Uint8Array): void {
-		this.cache.set(ino, data);
-		this.queue.add(this._set(ino, data));
+	public set(id: bigint, data: Uint8Array): void {
+		this.cache.set(id, data);
+		this.queue.add(this._set(id, data));
 	}
 
-	protected abstract _set(ino: Ino, data: Uint8Array): Promise<void>;
+	protected abstract _set(ino: bigint, data: Uint8Array): Promise<void>;
 
-	public delete(ino: Ino): void {
-		this.cache.delete(ino);
-		this.queue.add(this._delete(ino));
+	public delete(id: bigint): void {
+		this.cache.delete(id);
+		this.queue.add(this._delete(id));
 	}
 
-	protected abstract _delete(ino: Ino): Promise<void>;
+	protected abstract _delete(ino: bigint): Promise<void>;
 
 	public clearSync(): void {
 		this.cache.clear();
@@ -79,32 +78,32 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 	 * Stores data in the keys we modify prior to modifying them.
 	 * Allows us to roll back commits.
 	 */
-	protected originalData: Map<Ino, Uint8Array | void> = new Map();
+	protected originalData: Map<bigint, Uint8Array | void> = new Map();
 	/**
 	 * List of keys modified in this transaction, if any.
 	 */
-	protected modifiedKeys: Set<Ino> = new Set();
+	protected modifiedKeys: Set<bigint> = new Set();
 
 	protected declare store: SimpleSyncStore;
 
-	public keysSync(): Iterable<Ino> {
+	public keysSync(): Iterable<bigint> {
 		return this.store.keys();
 	}
 
-	public getSync(ino: Ino): Uint8Array {
-		const val = this.store.get(ino);
-		this.stashOldValue(ino, val);
+	public getSync(id: bigint): Uint8Array {
+		const val = this.store.get(id);
+		this.stashOldValue(id, val);
 		return val!;
 	}
 
-	public setSync(ino: Ino, data: Uint8Array): void {
-		this.markModified(ino);
-		return this.store.set(ino, data);
+	public setSync(id: bigint, data: Uint8Array): void {
+		this.markModified(id);
+		return this.store.set(id, data);
 	}
 
-	public removeSync(ino: Ino): void {
-		this.markModified(ino);
-		this.store.delete(ino);
+	public removeSync(id: bigint): void {
+		this.markModified(id);
+		this.store.delete(id);
 	}
 
 	public commitSync(): void {
@@ -135,10 +134,10 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 	 * prevent needless `get` requests if the program modifies the data later
 	 * on during the transaction.
 	 */
-	protected stashOldValue(ino: Ino, value?: Uint8Array): void {
+	protected stashOldValue(id: bigint, value?: Uint8Array): void {
 		// Keep only the earliest value in the transaction.
-		if (!this.originalData.has(ino)) {
-			this.originalData.set(ino, value);
+		if (!this.originalData.has(id)) {
+			this.originalData.set(id, value);
 		}
 	}
 
@@ -146,10 +145,10 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 	 * Marks `ino` as modified, and stashes its value if it has not been
 	 * stashed already.
 	 */
-	protected markModified(ino: Ino): void {
-		this.modifiedKeys.add(ino);
-		if (!this.originalData.has(ino)) {
-			this.originalData.set(ino, this.store.get(ino));
+	protected markModified(id: bigint): void {
+		this.modifiedKeys.add(id);
+		if (!this.originalData.has(id)) {
+			this.originalData.set(id, this.store.get(id));
 		}
 	}
 }

package/src/backends/store/store.ts

@@ -1,5 +1,4 @@
 import { ErrnoError } from '../../error.js';
-import type { Ino } from '../../inode.js';
 import '../../polyfills.js';
 
 /**
@@ -46,52 +45,52 @@ export abstract class Transaction<T extends Store = Store> {
 	/**
 	 * Gets all of the keys
 	 */
-	public abstract keys(): Promise<Iterable<Ino>>;
+	public abstract keys(): Promise<Iterable<bigint>>;
 
 	/**
 	 * Gets all of the keys
 	 */
-	public abstract keysSync(): Iterable<Ino>;
+	public abstract keysSync(): Iterable<bigint>;
 
 	/**
-	 * Retrieves the data at `ino`.
-	 * @param ino The key to look under for data.
+	 * Retrieves data.
+	 * @param id The key to look under for data.
 	 */
-	public abstract get(ino: Ino): Promise<Uint8Array>;
+	public abstract get(id: bigint): Promise<Uint8Array>;
 
 	/**
-	 * Retrieves the data at `ino`.
+	 * Retrieves data.
 	 * Throws an error if an error occurs or if the key does not exist.
-	 * @param ino The key to look under for data.
+	 * @param id The key to look under for data.
 	 * @return The data stored under the key, or undefined if not present.
 	 */
-	public abstract getSync(ino: Ino): Uint8Array;
+	public abstract getSync(id: bigint): Uint8Array;
 
 	/**
-	 * Adds the data to the store under `ino`. Overwrites any existing data.
-	 * @param ino The key to add the data under.
+	 * Adds the data to the store under an id. Overwrites any existing data.
+	 * @param id The key to add the data under.
 	 * @param data The data to add to the store.
 	 */
-	public abstract set(ino: Ino, data: Uint8Array): Promise<void>;
+	public abstract set(id: bigint, data: Uint8Array): Promise<void>;
 
 	/**
-	 * Adds the data to the store under `ino`.
-	 * @param ino The key to add the data under.
+	 * Adds the data to the store under and id.
+	 * @param id The key to add the data under.
 	 * @param data The data to add to the store.
 	 */
-	public abstract setSync(ino: Ino, data: Uint8Array): void;
+	public abstract setSync(id: bigint, data: Uint8Array): void;
 
 	/**
 	 * Deletes the data at `ino`.
-	 * @param ino The key to delete from the store.
+	 * @param id The key to delete from the store.
 	 */
-	public abstract remove(ino: Ino): Promise<void>;
+	public abstract remove(id: bigint): Promise<void>;
 
 	/**
 	 * Deletes the data at `ino`.
-	 * @param ino The key to delete from the store.
+	 * @param id The key to delete from the store.
 	 */
-	public abstract removeSync(ino: Ino): void;
+	public abstract removeSync(id: bigint): void;
 
 	/**
 	 * Commits the transaction.
@@ -135,19 +134,19 @@ export abstract class Transaction<T extends Store = Store> {
  */
 export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
 	/* eslint-disable @typescript-eslint/require-await */
-	public async keys(): Promise<Iterable<Ino>> {
+	public async keys(): Promise<Iterable<bigint>> {
 		return this.keysSync();
 	}
-	public async get(ino: Ino): Promise<Uint8Array> {
-		return this.getSync(ino);
+	public async get(id: bigint): Promise<Uint8Array> {
+		return this.getSync(id);
 	}
 
-	public async set(ino: bigint, data: Uint8Array): Promise<void> {
-		return this.setSync(ino, data);
+	public async set(id: bigint, data: Uint8Array): Promise<void> {
+		return this.setSync(id, data);
 	}
 
-	public async remove(ino: Ino): Promise<void> {
-		return this.removeSync(ino);
+	public async remove(id: bigint): Promise<void> {
+		return this.removeSync(id);
 	}
 
 	public async commit(): Promise<void> {

package/src/config.ts

@@ -108,6 +108,15 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
 	 */
 	cacheStats: boolean;
 
+	/**
+	 * If true, enables caching realpath output
+	 *
+	 * This can increase performance.
+	 * @experimental
+	 * @default false
+	 */
+	cachePaths: boolean;
+
 	/**
 	 * If true, disables *all* permissions checking.
 	 *
@@ -181,7 +190,8 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 
 	Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 
-	cache.setEnabled(configuration.cacheStats ?? false);
+	cache.stats.isEnabled = configuration.cacheStats ?? false;
+	cache.paths.isEnabled = configuration.cachePaths ?? false;
 	config.checkAccess = !configuration.disableAccessChecks;
 	config.updateOnRead = !configuration.disableUpdateOnRead;
 	config.syncImmediately = !configuration.onlySyncOnClose;

package/src/devices.ts

@@ -11,7 +11,6 @@ import { File } from './file.js';
 import type { StatsLike } from './stats.js';
 import { Stats } from './stats.js';
 import { basename, dirname } from './emulation/path.js';
-import type { Ino } from './inode.js';
 
 /**
  * A device
@@ -28,7 +27,7 @@ export interface Device<TData = any> {
 	/**
 	 * Which inode the device is assigned
 	 */
-	ino: Ino;
+	ino: bigint;
 
 	/**
 	 * Data associated with a device.
@@ -70,7 +69,7 @@ export interface DeviceDriver<TData = any> {
 	 * @returns `Device.data`
 	 * @experimental
 	 */
-	init?(ino: Ino): {
+	init?(ino: bigint): {
 		data?: TData;
 		minor?: number;
 		major?: number;

package/src/emulation/cache.ts

@@ -3,71 +3,79 @@
 import type { Stats } from '../stats.js';
 
 /**
- * Whether the cache is enabled
+ * Used for caching data
+ * @internal
  */
-export let isEnabled = false;
-
-/**
- * Sets whether the cache is enabled or not
- */
-export function setEnabled(value: boolean): void {
-	isEnabled = value;
+export class Cache<T> {
+	public isEnabled: boolean = false;
+
+	protected sync = new Map<string, T>();
+
+	protected async = new Map<string, Promise<T>>();
+
+	/**
+	 * Gets data from the cache, if is exists and the cache is enabled.
+	 */
+	getSync(path: string): T | undefined {
+		if (!this.isEnabled) return;
+
+		return this.sync.get(path);
+	}
+
+	/**
+	 * Adds data if the cache is enabled
+	 */
+	setSync(path: string, value: T): void {
+		if (!this.isEnabled) return;
+
+		this.sync.set(path, value);
+		this.async.set(path, Promise.resolve(value));
+	}
+
+	/**
+	 * Clears the cache if it is enabled
+	 */
+	clearSync(): void {
+		if (!this.isEnabled) return;
+
+		this.sync.clear();
+	}
+
+	/**
+	 * Gets data from the cache, if it exists and the cache is enabled.
+	 */
+	get(path: string): Promise<T> | undefined {
+		if (!this.isEnabled) return;
+
+		return this.async.get(path);
+	}
+
+	/**
+	 * Adds data if the cache is enabled
+	 */
+	set(path: string, value: Promise<T>): void {
+		if (!this.isEnabled) return;
+
+		this.async.set(path, value);
+		void value.then(v => this.sync.set(path, v));
+	}
+
+	/**
+	 * Clears the cache if it is enabled
+	 */
+	clear(): void {
+		if (!this.isEnabled) return;
+
+		this.async.clear();
+	}
 }
 
-const statsSync = new Map<string, Stats>();
-
 /**
- * Gets stats from the cache, if they exist and the cache is enabled.
+ * Used to cache
  */
-export function getStatsSync(path: string): Stats | undefined {
-	if (!isEnabled) return;
-
-	return statsSync.get(path);
-}
+export const stats = new Cache<Stats>();
 
 /**
- * Adds stats if the cache is enabled
+ * Used to cache realpath lookups
  */
-export function setStatsSync(path: string, value: Stats): void {
-	if (!isEnabled) return;
-
-	statsSync.set(path, value);
-}
-
-/**
- * Clears the cache if it is enabled
- */
-export function clearStatsSync(): void {
-	if (!isEnabled) return;
-
-	statsSync.clear();
-}
-
-const stats = new Map<string, Promise<Stats | undefined>>();
-
-/**
- * Gets stats from the cache, if they exist and the cache is enabled.
- */
-export function getStats(path: string): Promise<Stats | undefined> | undefined {
-	if (!isEnabled) return;
-
-	return stats.get(path);
-}
-
-/**
- * Adds stats if the cache is enabled
- */
-export function setStats(path: string, value: Promise<Stats | undefined>): void {
-	if (!isEnabled) return;
-
-	stats.set(path, value);
-}
-
-/**
- * Clears the cache if it is enabled
- */
-export function clearStats(): void {
-	if (!isEnabled) return;
-
-	stats.clear();
-}
+export const paths = new Cache<string>();

package/src/emulation/index.ts

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountObject, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount, _synced } from './shared.js';
 export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/src/emulation/promises.ts

@@ -471,7 +471,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.getStats(path) || fs.stat(resolved)))!.hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(await (cache.stats.get(path) || fs.stat(resolved)))!.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		await fs.unlink(resolved);
@@ -623,7 +623,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.getStats(path) || fs.stat(resolved));
+		const stats = await (cache.stats.get(path) || fs.stat(resolved));
 		if (!stats) {
 			throw ErrnoError.With('ENOENT', path, 'rmdir');
 		}
@@ -718,8 +718,8 @@ export async function readdir(
 
 	const { fs, path: resolved } = resolveMount(path);
 
-	const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
-	cache.setStats(path, _stats);
+	const _stats = cache.stats.get(path) || fs.stat(resolved).catch(handleError);
+	cache.stats.set(path, _stats);
 	const stats = await _stats;
 
 	if (!stats) {
@@ -740,8 +740,8 @@ export async function readdir(
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;
 		if (options?.recursive || options?.withFileTypes) {
-			const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
-			cache.setStats(join(path, entry), _entryStats);
+			const _entryStats = cache.stats.get(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+			cache.stats.set(join(path, entry), _entryStats);
 			entryStats = await _entryStats;
 		}
 		if (options?.withFileTypes) {
@@ -768,7 +768,7 @@ export async function readdir(
 	};
 	await Promise.all(entries.map(addEntry));
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.stats.clear();
 	}
 
 	return values as string[] | Dirent[];
@@ -892,16 +892,19 @@ export async function realpath(path: fs.PathLike, options?: fs.EncodingOption |
 export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Promise<string | Buffer> {
 	path = normalizePath(path);
 	const { base, dir } = parse(path);
-	const lpath = join(dir == '/' ? '/' : await realpath(dir), base);
+	const lpath = join(dir == '/' ? '/' : await (cache.paths.get(dir) || realpath(dir)), base);
 	const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
 
 	try {
-		const stats = await fs.stat(resolvedPath);
-		if (!stats.isSymbolicLink()) {
+		const _stats = cache.stats.get(lpath) || fs.stat(resolvedPath);
+		cache.stats.set(lpath, _stats);
+		if (!(await _stats).isSymbolicLink()) {
 			return lpath;
 		}
 
-		return await realpath(mountPoint + (await readlink(lpath)));
+		const target = mountPoint + (await readlink(lpath));
+
+		return await (cache.paths.get(target) || realpath(target));
 	} catch (e) {
 		if ((e as ErrnoError).code == 'ENOENT') {
 			return path;
@@ -965,20 +968,18 @@ access satisfies typeof promises.access;
 export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions) {
 	path = normalizePath(path);
 
-	const _stats =
-		cache.getStats(path) ||
+	const stats = await (cache.stats.get(path) ||
 		stat(path).catch((error: ErrnoError) => {
 			if (error.code == 'ENOENT' && options?.force) return undefined;
 			throw error;
-		});
-
-	cache.setStats(path, _stats);
-	const stats = await _stats;
+		}));
 
 	if (!stats) {
 		return;
 	}
 
+	cache.stats.setSync(path, stats);
+
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
 			if (options?.recursive) {
@@ -998,12 +999,12 @@ export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOpt
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStats();
+			cache.stats.clear();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.stats.clear();
 	}
 }
 rm satisfies typeof promises.rm;

package/src/emulation/shared.ts

@@ -83,6 +83,16 @@ export function resolveMount(path: string): { fs: FileSystem; path: string; moun
 	throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
 }
 
+/**
+ * Wait for all file systems to be ready and synced.
+ * May be removed at some point.
+ * @experimental @internal
+ */
+export async function _synced(): Promise<void> {
+	await Promise.all([...mounts.values()].map(m => m.ready()));
+	return;
+}
+
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  * @hidden
@@ -102,7 +112,9 @@ export function fixError<E extends ErrnoError>(e: E, paths: Record<string, strin
 	if (typeof e.stack == 'string') {
 		e.stack = fixPaths(e.stack, paths);
 	}
-	e.message = fixPaths(e.message, paths);
+	try {
+		e.message = fixPaths(e.message, paths);
+	} catch {}
 	return e;
 }
 

package/src/emulation/sync.ts

@@ -106,7 +106,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -386,7 +386,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -459,8 +459,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
-		cache.setStatsSync(path, stats);
+		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+		cache.stats.setSync(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -475,8 +475,8 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.setStatsSync(join(path, entry), entryStat);
+		const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.stats.setSync(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -500,7 +500,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStatsSync();
+		cache.stats.clearSync();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -622,7 +622,7 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption): st
 export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): string | Buffer {
 	path = normalizePath(path);
 	const { base, dir } = parse(path);
-	const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
+	const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
 	const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
 
 	try {
@@ -631,7 +631,8 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 			return lpath;
 		}
 
-		return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
+		const target = mountPoint + readlinkSync(lpath, options).toString();
+		return cache.paths.getSync(target) || realpathSync(target);
 	} catch (e) {
 		if ((e as ErrnoError).code == 'ENOENT') {
 			return path;
@@ -658,7 +659,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.getStatsSync(path) || statSync(path);
+		stats = cache.stats.getSync(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -667,7 +668,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.setStatsSync(path, stats);
+	cache.stats.setSync(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -688,12 +689,12 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStatsSync();
+			cache.stats.clearSync();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStatsSync();
+		cache.stats.clearSync();
 	}
 }
 rmSync satisfies typeof fs.rmSync;