@zenfs/core 1.9.3 → 1.9.5

package/dist/vfs/promises.js

@@ -57,7 +57,6 @@ import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWrit
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -90,9 +89,8 @@ export class FileHandle {
      */
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
-        if (numMode < 0) {
+        if (numMode < 0)
             throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
-        }
         await this.file.chmod(numMode);
         this._emitChange();
     }
@@ -459,7 +457,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(await (cache.stats.getAsync(path) || fs.stat(resolved))).hasAccess(constants.W_OK, this)) {
+        if (config.checkAccess && !(await fs.stat(resolved)).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -484,37 +482,35 @@ async function applySetId(file, uid, gid) {
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(path, opt) {
+async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
-    path = opt.preserveSymlinks ? path : await realpath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const stats = await fs.stat(resolved).catch(() => null);
+    const { fullPath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
     if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
-            throw ErrnoError.With('ENOENT', path, '_open');
+            throw ErrnoError.With('ENOENT', fullPath, '_open');
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(path), '_open');
+        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, $)) {
+            throw ErrnoError.With('EACCES', dirname(fullPath), '_open');
         }
         if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+            throw ErrnoError.With('ENOTDIR', dirname(fullPath), '_open');
         }
-        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
+        const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : credentials;
         const file = await fs.createFile(resolved, flag, mode, { uid, gid });
         await applySetId(file, uid, gid);
-        return new FileHandle(file, this);
+        return new FileHandle(file, $);
     }
-    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), this)) {
-        throw ErrnoError.With('EACCES', path, '_open');
+    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), $)) {
+        throw ErrnoError.With('EACCES', fullPath, '_open');
     }
     if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', path, '_open');
+        throw ErrnoError.With('EEXIST', fullPath, '_open');
     }
-    const handle = new FileHandle(await fs.openFile(resolved, flag), this);
+    const handle = new FileHandle(await fs.openFile(resolved, flag), $);
     /*
         In a previous implementation, we deleted the file and
         re-created it. However, this created a race condition if another
@@ -533,7 +529,7 @@ async function _open(path, opt) {
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
-    return await _open.call(this, path, { flag, mode });
+    return await _open(this, path, { flag, mode });
 }
 open;
 export async function readFile(path, _options) {
@@ -625,7 +621,7 @@ export async function rmdir(path) {
     path = await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        const stats = await (cache.stats.getAsync(path) || fs.stat(resolved));
+        const stats = await fs.stat(resolved);
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
@@ -688,9 +684,7 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path, this);
-    const _stats = cache.stats.getAsync(path) || fs.stat(resolved).catch(handleError);
-    cache.stats.setAsync(path, _stats);
-    const stats = await _stats;
+    const stats = await fs.stat(resolved).catch(handleError);
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
     }
@@ -705,9 +699,7 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if ((options === null || options === void 0 ? void 0 : options.recursive) || (options === null || options === void 0 ? void 0 : options.withFileTypes)) {
-            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;
+            entryStats = await fs.stat(join(resolved, entry)).catch(handleError);
         }
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStats));
@@ -720,7 +712,7 @@ export async function readdir(path, options) {
         }
         if (!(options === null || options === void 0 ? void 0 : options.recursive) || !(entryStats === null || entryStats === void 0 ? void 0 : entryStats.isDirectory()))
             return;
-        for (const subEntry of await readdir.call(this, join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of await readdir.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -735,9 +727,6 @@ export async function readdir(path, options) {
         }
     };
     await Promise.all(entries.map(addEntry));
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
     return values;
 }
 readdir;
@@ -778,11 +767,11 @@ export async function symlink(target, path, type = 'file') {
         if (!['file', 'dir', 'junction'].includes(type)) {
             throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
         }
-        if (await exists.call(this, path)) {
-            throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
-        }
-        const handle = __addDisposableResource(env_5, await _open.call(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
-        await handle.writeFile(target.toString());
+        path = normalizePath(path);
+        if (await exists.call(this, path))
+            throw ErrnoError.With('EEXIST', path, 'symlink');
+        const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
+        await handle.writeFile(normalizePath(target, true));
         await handle.file.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
@@ -799,7 +788,7 @@ symlink;
 export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
+        const handle = __addDisposableResource(env_6, await _open(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
         // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
@@ -836,7 +825,7 @@ chown;
 export async function lchown(path, uid, gid) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_8, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -875,7 +864,7 @@ chmod;
 export async function lchmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_10, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -920,7 +909,7 @@ utimes;
 export async function lutimes(path, atime, mtime) {
     const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_12, await _open.call(this, path, {
+        const handle = __addDisposableResource(env_12, await _open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -939,52 +928,63 @@ export async function lutimes(path, atime, mtime) {
     }
 }
 lutimes;
-export async function realpath(path, options) {
-    path = normalizePath(path);
-    const ctx_path = ((this === null || this === void 0 ? void 0 : this.root) || '') + path;
-    if (cache.paths.hasAsync(ctx_path))
-        return cache.paths.getAsync(ctx_path);
+/**
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @internal @hidden
+ */
+async function _resolve($, path, preserveSymlinks) {
+    if (preserveSymlinks) {
+        const resolved = resolveMount(path, $);
+        const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
+        return { ...resolved, fullPath: path, stats };
+    }
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
     try {
-        const { fs, path: resolvedPath } = resolveMount(path, this);
+        const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
-        const stats = await fs.stat(resolvedPath);
-        let real = path.toString();
-        if (stats.isSymbolicLink()) {
-            const target = resolve(dirname(resolvedPath), (await readlink.call(this, resolvedPath, options)).toString());
-            real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || (await realpath.call(this, target));
-            cache.paths.set(ctx_path, real);
+        const stats = await resolved.fs.stat(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: path, stats };
         }
-        cache.paths.set(path.toString(), real);
-        return real;
+        const target = resolve(dirname(path), (await readlink.call($, path)).toString());
+        return await _resolve($, target);
     }
     catch {
         // Go the long way
     }
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : await (cache.paths.getAsync(((this === null || this === void 0 ? void 0 : this.root) || '') + dir) || realpath.call(this, dir));
-    const lpath = join(realDir, base);
-    const { fs, path: resolvedPath } = resolveMount(lpath, this);
+    const realDir = dir == '/' ? '/' : await realpath.call($, dir);
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
     try {
-        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 stats = await resolved.fs.stat(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, (await readlink.call(this, lpath)).toString());
-        const real = cache.paths.getAsync(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpath.call(this, target);
-        cache.paths.setAsync(ctx_path, real);
-        return await real;
+        const target = resolve(realDir, (await readlink.call($, maybePath)).toString());
+        return await _resolve($, target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {
-            return path;
+            return { ...resolved, fullPath: path };
         }
-        throw fixError(e, { [resolvedPath]: lpath });
+        throw fixError(e, { [resolved.path]: maybePath });
     }
 }
+export async function realpath(path, options) {
+    var _a;
+    const encoding = typeof options == 'string' ? options : ((_a = options === null || options === void 0 ? void 0 : options.encoding) !== null && _a !== void 0 ? _a : 'utf8');
+    path = normalizePath(path);
+    const { fullPath } = await _resolve(this, path);
+    if (encoding == 'utf8' || encoding == 'utf-8')
+        return fullPath;
+    const buf = Buffer.from(fullPath, 'utf-8');
+    if (encoding == 'buffer')
+        return buf;
+    return buf.toString(encoding);
+}
 realpath;
 export function watch(filename, options = {}) {
     const watcher = new FSWatcher(this, filename.toString(), typeof options !== 'string' ? options : { encoding: options });
@@ -1038,23 +1038,18 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = await (cache.stats.getAsync(path) ||
-        lstat.call(this, path).catch((error) => {
-            if (error.code == 'ENOENT' && (options === null || options === void 0 ? void 0 : options.force))
-                return undefined;
-            throw error;
-        }));
-    if (!stats) {
+    const stats = await lstat.call(this, path).catch((error) => {
+        if (error.code == 'ENOENT' && (options === null || options === void 0 ? void 0 : options.force))
+            return undefined;
+        throw error;
+    });
+    if (!stats)
         return;
-    }
-    cache.stats.set(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options === null || options === void 0 ? void 0 : options.recursive) {
-                for (const entry of await readdir.call(this, path, {
-                    _isIndirect: true,
-                })) {
-                    await rm.call(this, join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of (await readdir.call(this, path))) {
+                    await rm.call(this, join(path, entry), options);
                 }
             }
             await rmdir.call(this, path);
@@ -1068,12 +1063,8 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.stats.clear();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
 }
 rm;
 export async function mkdtemp(prefix, options) {

package/dist/vfs/shared.d.ts

@@ -1,6 +1,7 @@
 import type * as fs from 'node:fs';
 import type { File } from '../internal/file.js';
 import type { FileSystem } from '../internal/filesystem.js';
+import type { Stats } from '../stats.js';
 import { type BoundContext, type V_Context } from '../context.js';
 import { ErrnoError } from '../internal/error.js';
 import { type AbsolutePath } from './path.js';
@@ -46,6 +47,15 @@ export interface ResolvedMount {
     mountPoint: string;
     root: string;
 }
+/**
+ * @internal @hidden
+ */
+export interface ResolvedPath extends ResolvedMount {
+    /** The real, absolute path */
+    fullPath: string;
+    /** Stats */
+    stats?: Stats;
+}
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
  * @internal @hidden

package/dist/vfs/shared.js

@@ -4,7 +4,6 @@ import { bindContext } from '../context.js';
 import { Errno, ErrnoError } from '../internal/error.js';
 import { alert, debug, err, info, log_deprecated, notice, warn } from '../internal/log.js';
 import { normalizePath } from '../utils.js';
-import { paths as pathCache } from './cache.js';
 import { size_max } from './constants.js';
 import { join, resolve } from './path.js';
 // descriptors
@@ -54,7 +53,6 @@ export function mount(mountPoint, fs) {
     mounts.set(mountPoint, fs);
     info(`Mounted ${fs.name} on ${mountPoint}`);
     debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : v)).join(', ')}`);
-    pathCache.clear();
 }
 /**
  * Unmounts the file system at `mountPoint`.
@@ -69,7 +67,6 @@ export function umount(mountPoint) {
         return;
     }
     mounts.delete(mountPoint);
-    pathCache.clear();
     notice('Unmounted ' + mountPoint);
 }
 /**
@@ -84,9 +81,8 @@ export function resolveMount(path, ctx) {
         // We know path is normalized, so it would be a substring of the mount point.
         if (_isParentOf(mountPoint, path)) {
             path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
-            if (path === '') {
+            if (path === '')
                 path = root;
-            }
             return { fs, path, mountPoint, root };
         }
     }

package/dist/vfs/sync.d.ts

@@ -1,7 +1,7 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { Stats } from '../stats.js';
-import type { FileContents, InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
+import type { FileContents, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 import { Buffer } from 'buffer';
 import { BigIntStats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
@@ -155,7 +155,7 @@ export declare function accessSync(this: V_Context, path: fs.PathLike, mode?: nu
  * Synchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rmSync(this: V_Context, path: fs.PathLike, options?: fs.RmOptions & InternalOptions): void;
+export declare function rmSync(this: V_Context, path: fs.PathLike, options?: fs.RmOptions): void;
 /**
  * Synchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.

package/dist/vfs/sync.js

@@ -56,7 +56,6 @@ import { Errno, ErrnoError } from '../internal/error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -154,7 +153,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK, this)) {
+        if (config.checkAccess && !fs.statSync(resolved).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -236,11 +235,12 @@ openSync;
 export function lopenSync(path, flag, mode) {
     return file2fd(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
-function _readFileSync(fname, flag, preserveSymlinks) {
+function _readFileSync(path, flag, preserveSymlinks) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        path = normalizePath(path);
         // Get file.
-        const file = __addDisposableResource(env_2, _openSync.call(this, fname, { flag, mode: 0o644, preserveSymlinks }), false);
+        const file = __addDisposableResource(env_2, _openSync.call(this, path, { flag, mode: 0o644, preserveSymlinks }), false);
         const stat = file.statSync();
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
@@ -261,7 +261,7 @@ export function readFileSync(path, _options = {}) {
     if (!isReadable(flag)) {
         throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, false));
+    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path, options.flag, false));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -426,7 +426,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
-        const stats = cache.stats.get(path) || fs.statSync(resolved);
+        const stats = fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -484,8 +484,7 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     let entries;
     try {
-        const stats = cache.stats.get(path) || fs.statSync(resolved);
-        cache.stats.set(path, stats);
+        const stats = fs.statSync(resolved);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -500,8 +499,7 @@ 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.get(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.stats.set(join(path, entry), entryStat);
+        const entryStat = fs.statSync(join(resolved, entry));
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -513,7 +511,7 @@ export function readdirSync(path, options) {
         }
         if (!entryStat.isDirectory() || !(options === null || options === void 0 ? void 0 : options.recursive))
             continue;
-        for (const subEntry of readdirSync.call(this, join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -526,9 +524,6 @@ export function readdirSync(path, options) {
             }
         }
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
     return values;
 }
 readdirSync;
@@ -570,13 +565,13 @@ export function symlinkSync(target, path, type = 'file') {
     if (existsSync.call(this, path)) {
         throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
-    writeFileSync.call(this, path, target.toString());
+    writeFileSync.call(this, path, normalizePath(target, true));
     const file = _openSync.call(this, path, { flag: 'r+', mode: 0o644, preserveSymlinks: true });
     file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync.call(this, path.toString(), 'r', true));
+    const value = Buffer.from(_readFileSync.call(this, path, 'r', true));
     const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
     if (encoding == 'buffer') {
         return value;
@@ -627,52 +622,63 @@ export function lutimesSync(path, atime, mtime) {
     closeSync(fd);
 }
 lutimesSync;
-export function realpathSync(path, options) {
-    path = normalizePath(path);
-    const ctx_path = ((this === null || this === void 0 ? void 0 : this.root) || '') + path;
-    if (cache.paths.has(ctx_path))
-        return cache.paths.get(ctx_path);
+/**
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @internal @hidden
+ */
+function _resolveSync($, path, preserveSymlinks) {
+    if (preserveSymlinks) {
+        const resolved = resolveMount(path, $);
+        const stats = resolved.fs.statSync(resolved.path);
+        return { ...resolved, fullPath: path, stats };
+    }
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
     try {
-        const { fs, path: resolvedPath } = resolveMount(path, this);
+        const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
-        const stats = fs.statSync(resolvedPath);
-        let real = path;
-        if (stats.isSymbolicLink()) {
-            const target = resolve(dirname(resolvedPath), readlinkSync.call(this, resolvedPath, options).toString());
-            real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpathSync.call(this, target);
-            cache.paths.set(ctx_path, real);
+        const stats = resolved.fs.statSync(resolved.path);
+        if (!stats.isSymbolicLink()) {
+            return { ...resolved, fullPath: path, stats };
         }
-        cache.paths.set(path, real);
-        return real;
+        const target = resolve(dirname(path), readlinkSync.call($, path).toString());
+        return _resolveSync($, target);
     }
     catch {
         // Go the long way
     }
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + dir) || realpathSync.call(this, dir);
-    const lpath = join(realDir, base);
-    const { fs, path: resolvedPath } = resolveMount(lpath, this);
+    const realDir = dir == '/' ? '/' : realpathSync.call($, dir);
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
     try {
-        const stats = cache.stats.get(lpath) || fs.statSync(resolvedPath);
-        cache.stats.set(lpath, stats);
+        const stats = resolved.fs.statSync(resolved.path);
         if (!stats.isSymbolicLink()) {
-            cache.paths.set(path, lpath);
-            return lpath;
+            return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, readlinkSync.call(this, lpath, options).toString());
-        const real = cache.paths.get(((this === null || this === void 0 ? void 0 : this.root) || '') + target) || realpathSync.call(this, target);
-        cache.paths.set(ctx_path, real);
-        return real;
+        const target = resolve(realDir, readlinkSync.call($, maybePath).toString());
+        return _resolveSync($, target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {
-            return path;
+            return { ...resolved, fullPath: path };
         }
-        throw fixError(e, { [resolvedPath]: lpath });
+        throw fixError(e, { [resolved.path]: maybePath });
     }
 }
+export function realpathSync(path, options) {
+    var _a;
+    const encoding = typeof options == 'string' ? options : ((_a = options === null || options === void 0 ? void 0 : options.encoding) !== null && _a !== void 0 ? _a : 'utf8');
+    path = normalizePath(path);
+    const { fullPath } = _resolveSync(this, path);
+    if (encoding == 'utf8' || encoding == 'utf-8')
+        return fullPath;
+    const buf = Buffer.from(fullPath, 'utf-8');
+    if (encoding == 'buffer')
+        return buf;
+    return buf.toString(encoding);
+}
 realpathSync;
 export function accessSync(path, mode = 0o600) {
     if (!config.checkAccess)
@@ -690,21 +696,19 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.stats.get(path) || lstatSync.bind(this)(path);
+        stats = lstatSync.bind(this)(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !(options === null || options === void 0 ? void 0 : options.force))
             throw error;
     }
-    if (!stats) {
+    if (!stats)
         return;
-    }
-    cache.stats.set(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options === null || options === void 0 ? void 0 : options.recursive) {
-                for (const entry of readdirSync.call(this, path, { _isIndirect: true })) {
-                    rmSync.call(this, join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of readdirSync.call(this, path)) {
+                    rmSync.call(this, join(path, entry), options);
                 }
             }
             rmdirSync.call(this, path);
@@ -718,12 +722,8 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.stats.clear();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
 }
 rmSync;
 export function mkdtempSync(prefix, options) {

package/dist/vfs/types.d.ts

@@ -1,17 +1,5 @@
 import type * as fs from 'node:fs';
 export type FileContents = ArrayBufferView | string;
-/**
- * Options used for caching, among other things.
- * @internal @hidden *UNSTABLE*
- */
-export interface InternalOptions {
-    /**
-     * If true, then this readdir was called from another function.
-     * In this case, don't clear the cache when done.
-     * @internal *UNSTABLE*
-     */
-    _isIndirect?: boolean;
-}
 /**
  * @internal @hidden Used for the internal `_open` functions
  */
@@ -27,7 +15,7 @@ export interface OpenOptions {
      */
     allowDirectory?: boolean;
 }
-export interface ReaddirOptions extends InternalOptions {
+export interface ReaddirOptions {
     withFileTypes?: boolean;
     recursive?: boolean;
 }