@zenfs/core 1.9.3 → 1.9.4

package/dist/backends/fetch.d.ts

@@ -73,5 +73,8 @@ declare const _Fetch: {
 type _Fetch = typeof _Fetch;
 export interface Fetch extends _Fetch {
 }
+/**
+ * @category Backends and Configuration
+ */
 export declare const Fetch: Fetch;
 export {};

package/dist/backends/fetch.js

@@ -123,4 +123,7 @@ const _Fetch = {
         return fs;
     },
 };
+/**
+ * @category Backends and Configuration
+ */
 export const Fetch = _Fetch;

package/dist/backends/memory.d.ts

@@ -31,6 +31,7 @@ export interface InMemory extends _InMemory {
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
+ * @category Backends and Configuration
  */
 export declare const InMemory: InMemory;
 export {};

package/dist/backends/memory.js

@@ -33,5 +33,6 @@ const _InMemory = {
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
+ * @category Backends and Configuration
  */
 export const InMemory = _InMemory;

package/dist/backends/overlay.d.ts

@@ -117,6 +117,7 @@ export interface Overlay extends _Overlay {
 /**
  * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
+ * @category Backends and Configuration
  * @internal
  */
 export declare const Overlay: Overlay;

package/dist/backends/overlay.js

@@ -550,6 +550,7 @@ const _Overlay = {
 /**
  * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
+ * @category Backends and Configuration
  * @internal
  */
 export const Overlay = _Overlay;

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

@@ -2,12 +2,12 @@ import type { ExtractProperties } from 'utilium';
 import type { Inode, InodeLike } from '../..//internal/inode.js';
 import type { MountConfiguration } from '../../config.js';
 import type { File } from '../../internal/file.js';
-import type { CreationOptions, FileSystemMetadata } from '../../internal/filesystem.js';
+import type { CreationOptions, UsageInfo } from '../../internal/filesystem.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import { FileSystem } from '../../internal/filesystem.js';
 import { Stats } from '../../stats.js';
 import * as RPC from './rpc.js';
-type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
+type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | UsageInfo>;
 type FSMethod = keyof FSMethods;
 export type FSRequest<TMethod extends FSMethod = FSMethod> = RPC.Message & {
     [M in TMethod]: {
@@ -73,6 +73,12 @@ declare const _Port: {
 type _Port = typeof _Port;
 export interface Port extends _Port {
 }
+/**
+ * @category Backends and Configuration
+ */
 export declare const Port: Port;
+/**
+ * @category Backends and Configuration
+ */
 export declare function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 export {};

package/dist/backends/port/fs.js

@@ -134,7 +134,13 @@ const _Port = {
         return new PortFS(options);
     },
 };
+/**
+ * @category Backends and Configuration
+ */
 export const Port = _Port;
+/**
+ * @category Backends and Configuration
+ */
 export async function resolveRemoteMount(port, config, _depth = 0) {
     const stopAndReplay = RPC.catchMessages(port);
     const fs = await resolveMountConfig(config, _depth);

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

@@ -6,11 +6,8 @@ import { Inode, type InodeLike } from '../../internal/inode.js';
 import type { Stats } from '../../stats.js';
 import { WrappedTransaction, type Store } from './store.js';
 /**
- * A file system which uses a key-value store.
+ * A file system which uses a `Store`
  *
- * We use a unique ID for each node in the file system. The root node has a fixed ID.
- *
- * @todo Introduce Node ID caching?
  * @todo Check modes?
  * @category Stores and Transactions
  * @internal

package/dist/backends/store/fs.js

@@ -63,11 +63,8 @@ import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID, size_max } from '../../vfs/constant
 import { basename, dirname, join, parse, relative } from '../../vfs/path.js';
 import { WrappedTransaction } from './store.js';
 /**
- * A file system which uses a key-value store.
+ * A file system which uses a `Store`
  *
- * We use a unique ID for each node in the file system. The root node has a fixed ID.
- *
- * @todo Introduce Node ID caching?
  * @todo Check modes?
  * @category Stores and Transactions
  * @internal

package/dist/config.d.ts

@@ -45,21 +45,6 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     addDevices: boolean;
-    /**
-     * If true, enables caching stats for certain operations.
-     * This should reduce the number of stat calls performed.
-     * @experimental
-     * @default false
-     */
-    cacheStats: boolean;
-    /**
-     * If true, enables caching realpath output
-     *
-     * This can increase performance.
-     * @experimental
-     * @default false
-     */
-    cachePaths: boolean;
     /**
      * If true, disables *all* permissions checking.
      *

package/dist/config.js

@@ -4,7 +4,6 @@ import { DeviceFS } from './internal/devices.js';
 import { Errno, ErrnoError } from './internal/error.js';
 import { FileSystem } from './internal/filesystem.js';
 import { configure as configureLog, crit, err, info } from './internal/log.js';
-import * as cache from './vfs/cache.js';
 import { config } from './vfs/config.js';
 import * as fs from './vfs/index.js';
 import { mounts } from './vfs/shared.js';
@@ -99,12 +98,10 @@ export function addDevice(driver, options) {
  * @see Configuration
  */
 export async function configure(configuration) {
-    var _a, _b, _c;
+    var _a;
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
     useCredentials({ uid, gid });
-    cache.stats.isEnabled = (_a = configuration.cacheStats) !== null && _a !== void 0 ? _a : false;
-    cache.paths.isEnabled = (_b = configuration.cachePaths) !== null && _b !== void 0 ? _b : false;
     config.checkAccess = !configuration.disableAccessChecks;
     config.updateOnRead = !configuration.disableUpdateOnRead;
     config.syncImmediately = !configuration.onlySyncOnClose;
@@ -115,7 +112,7 @@ export async function configure(configuration) {
         for (const [_point, mountConfig] of Object.entries(configuration.mounts).sort(([a], [b]) => (a.length > b.length ? 1 : -1))) {
             const point = _point.startsWith('/') ? _point : '/' + _point;
             if (isBackendConfig(mountConfig)) {
-                (_c = mountConfig.disableAsyncCache) !== null && _c !== void 0 ? _c : (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
+                (_a = mountConfig.disableAsyncCache) !== null && _a !== void 0 ? _a : (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
             }
             if (point == '/')
                 fs.umount('/');

package/dist/internal/file_index.d.ts

@@ -10,7 +10,7 @@ export interface IndexData {
 }
 export declare const version = 1;
 /**
- * An index of files
+ * An index of file metadata
  * @category Internals
  * @internal
  */

package/dist/internal/file_index.js

@@ -6,7 +6,7 @@ import { Errno, ErrnoError } from './error.js';
 import { Inode } from './inode.js';
 export const version = 1;
 /**
- * An index of files
+ * An index of file metadata
  * @category Internals
  * @internal
  */

package/dist/internal/index_fs.d.ts

@@ -4,7 +4,7 @@ import { Index } from './file_index.js';
 import { FileSystem, type CreationOptions, type PureCreationOptions } from './filesystem.js';
 import { Inode, type InodeLike } from './inode.js';
 /**
- * Uses an `Index` for metadata.
+ * A file system that uses an `Index` for metadata.
  * @category Internals
  * @internal
  */

package/dist/internal/index_fs.js

@@ -9,7 +9,7 @@ import { Index } from './file_index.js';
 import { FileSystem } from './filesystem.js';
 import { Inode } from './inode.js';
 /**
- * Uses an `Index` for metadata.
+ * A file system that uses an `Index` for metadata.
  * @category Internals
  * @internal
  */

package/dist/vfs/promises.d.ts

@@ -6,7 +6,7 @@ import type { Interface as ReadlineInterface } from 'readline';
 import type { V_Context } from '../context.js';
 import type { File } from '../internal/file.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 '../polyfills.js';
 import { BigIntStats } from '../stats.js';
@@ -304,7 +304,7 @@ export declare function access(this: V_Context, path: fs.PathLike, mode?: number
  * Asynchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rm(this: V_Context, path: fs.PathLike, options?: fs.RmOptions & InternalOptions): Promise<void>;
+export declare function rm(this: V_Context, path: fs.PathLike, options?: fs.RmOptions): Promise<void>;
 /**
  * Asynchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.

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';
@@ -459,7 +458,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 +483,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: realpath, 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', realpath, '_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(realpath), '_open');
         }
         if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+            throw ErrnoError.With('ENOTDIR', dirname(realpath), '_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', realpath, '_open');
     }
     if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', path, '_open');
+        throw ErrnoError.With('EEXIST', realpath, '_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 +530,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 +622,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 +685,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 +700,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 +713,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 +728,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;
@@ -781,7 +771,7 @@ export async function symlink(target, path, type = 'file') {
         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);
+        const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         await handle.writeFile(target.toString());
         await handle.file.chmod(constants.S_IFLNK);
     }
@@ -799,7 +789,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 +826,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 +865,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 +910,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 +929,64 @@ 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());
+        const real = await realpath.call($, target);
+        return { ...resolved, fullPath: real, stats };
     }
     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 +1040,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 +1065,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);
@@ -426,7 +425,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 +483,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 +498,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 +510,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 +523,6 @@ export function readdirSync(path, options) {
             }
         }
     }
-    if (!(options === null || options === void 0 ? void 0 : options._isIndirect)) {
-        cache.stats.clear();
-    }
     return values;
 }
 readdirSync;
@@ -627,52 +621,64 @@ 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());
+        const real = realpathSync.call($, target);
+        return { ...resolved, fullPath: real, stats };
     }
     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;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.9.3",
+	"version": "1.9.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/dist/vfs/cache.d.ts

@@ -1,46 +0,0 @@
-import type { Stats } from '../stats.js';
-/**
- * Used for caching data
- * @internal
- */
-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.
-     */
-    get(path: string): T | undefined;
-    /**
-     * Adds data if the cache is enabled
-     */
-    set(path: string, value: T): void;
-    /**
-     * Whether the data exists in the cache
-     */
-    hasAsync(path: string): boolean;
-    /**
-     * Gets data from the cache, if it exists and the cache is enabled.
-     */
-    getAsync(path: string): Promise<T> | undefined;
-    /**
-     * Adds data if the cache is enabled
-     */
-    setAsync(path: string, value: Promise<T>): void;
-    /**
-     * Clears the cache if it is enabled
-     */
-    clear(): void;
-}
-/**
- * Used to cache
- */
-export declare const stats: Cache<Stats>;
-/**
- * Used to cache realpath lookups
- */
-export declare const paths: Cache<string>;

package/dist/vfs/cache.js

@@ -1,75 +0,0 @@
-/* Experimental caching */
-/**
- * Used for caching data
- * @internal
- */
-export class Cache {
-    constructor() {
-        this.isEnabled = false;
-        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.
-     */
-    get(path) {
-        if (!this.isEnabled)
-            return;
-        return this.sync.get(path);
-    }
-    /**
-     * Adds data if the cache is enabled
-     */
-    set(path, value) {
-        if (!this.isEnabled)
-            return;
-        this.sync.set(path, value);
-        this.async.set(path, Promise.resolve(value));
-    }
-    /**
-     * Whether the data exists in the cache
-     */
-    hasAsync(path) {
-        return this.isEnabled && this.async.has(path);
-    }
-    /**
-     * Gets data from the cache, if it exists and the cache is enabled.
-     */
-    getAsync(path) {
-        if (!this.isEnabled)
-            return;
-        return this.async.get(path);
-    }
-    /**
-     * Adds data if the cache is enabled
-     */
-    setAsync(path, value) {
-        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() {
-        if (!this.isEnabled)
-            return;
-        this.sync.clear();
-        this.async.clear();
-    }
-}
-/**
- * Used to cache
- */
-export const stats = new Cache();
-/**
- * Used to cache realpath lookups
- */
-export const paths = new Cache();