@zenfs/core 2.7.5 → 2.7.7

package/dist/vfs/sync.js

@@ -55,11 +55,11 @@ import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
-import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { assertRemovable, assertSearchable, hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
 import { normalizeMode, normalizePath } from '../utils.js';
-import { cacheOf, lockPathSync } from './vcache.js';
-import { checkAccess } from './config.js';
+import { cacheOf } from './vcache.js';
+import { checkAccess, resolveFullWalk } from './config.js';
 import { Dirent, ifToDt } from './dir.js';
 import { Handle } from './file.js';
 import * as flags from './flags.js';
@@ -75,35 +75,45 @@ export function resolve($, path, preserveSymlinks, extra) {
     path = resolvePath.call($, path);
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
-    try {
-        const resolved = resolveMount(path, $);
-        // Stat it to make sure it exists. The vnode cache takes precedence since it may have unsynced changes
-        const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? resolved.fs.statSync(resolved.path);
-        if (!isSymbolicLink(stats) || preserveSymlinks) {
-            return { ...resolved, fullPath: path, stats };
+    if (!resolveFullWalk)
+        try {
+            const resolved = resolveMount(path, $);
+            // Stat it to make sure it exists. The vnode cache takes precedence since it may have unsynced changes
+            const stats = resolved.cache.statSync(resolved.path);
+            if (!isSymbolicLink(stats) || preserveSymlinks) {
+                return { ...resolved, fullPath: path, stats };
+            }
+            const target = resolvePath.call($, dirname(path), readlink.call($, path));
+            return resolve($, target, preserveSymlinks, extra);
+        }
+        catch {
+            // Go the long way
         }
-        const target = resolvePath.call($, dirname(path), readlink.call($, path));
-        return resolve($, target, preserveSymlinks, extra);
+    const { base, dir } = parse(path);
+    const $ex = { syscall: 'stat', path, ...extra };
+    let realDir = '/';
+    if (dir != '/') {
+        const parent = resolve($, dir, false, extra);
+        if (parent.stats && isDirectory(parent.stats))
+            assertSearchable($, parent.stats, $ex);
+        realDir = parent.fullPath;
     }
-    catch (e) {
-        setUVMessage(Object.assign(e, { syscall: 'stat', path, ...extra }));
-        if (preserveSymlinks)
-            throw e;
+    else if (base && checkAccess) {
+        const root = resolveMount('/', $);
+        assertSearchable($, root.cache.statSync(root.path), $ex);
     }
-    const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : resolve($, dir, false, extra).fullPath;
     const maybePath = join(realDir, base);
     const resolved = resolveMount(maybePath, $);
     let stats;
     try {
-        stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? resolved.fs.statSync(resolved.path);
+        stats = resolved.cache.statSync(resolved.path);
     }
     catch (e) {
         if (e.code === 'ENOENT')
             return { ...resolved, fullPath: maybePath };
         throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
     }
-    if (!isSymbolicLink(stats)) {
+    if (!isSymbolicLink(stats) || preserveSymlinks) {
         return { ...resolved, fullPath: maybePath, stats };
     }
     const target = resolvePath.call($, realDir, readlink.call($, maybePath));
@@ -116,11 +126,11 @@ export function resolve($, path, preserveSymlinks, extra) {
 export function open($, path, opt) {
     path = normalizePath.call($, path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
-    path = opt.preserveSymlinks ? path : resolve($, path).fullPath;
-    const { fs, path: resolved } = resolveMount(path, $);
+    path = resolve($, path, opt.preserveSymlinks).fullPath;
+    const { fs, cache, path: resolved } = resolveMount(path, $);
     let stats;
     try {
-        stats = fs.statSync(resolved);
+        stats = cache.statSync(resolved);
     }
     catch {
         // nothing
@@ -133,8 +143,8 @@ export function open($, path, opt) {
             }
             // Create the file
             const parentPath = dirname(resolved);
-            const parentStats = fs.statSync(parentPath);
-            if (checkAccess && !hasAccess($, parentStats, constants.W_OK)) {
+            const parentStats = cache.statSync(parentPath, { syscall: 'open', path });
+            if (checkAccess && !hasAccess($, parentStats, constants.W_OK | constants.X_OK)) {
                 throw UV('EACCES', 'open', path);
             }
             if (!isDirectory(parentStats)) {
@@ -143,7 +153,7 @@ export function open($, path, opt) {
             if (!opt.allowDirectory && isDirectory({ mode }))
                 throw UV('EISDIR', 'open', path);
             // Serialize entry creation with other operations on the parent directory
-            const _ = __addDisposableResource(env_1, lockPathSync(fs, parentPath, 'rw', parentStats), false);
+            const _ = __addDisposableResource(env_1, cache.lockSync(parentPath, 'rw', parentStats), false);
             const { euid: uid, egid: gid } = contextOf($).credentials;
             const inode = fs.createFileSync(resolved, {
                 mode,
@@ -152,7 +162,7 @@ export function open($, path, opt) {
             });
             // A new entry in the parent directory, which is a 'rename' event
             emitChange($, 'rename', path);
-            return new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
+            return new Handle($, path, resolved, flag, cache.ref(resolved, inode));
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -162,14 +172,14 @@ export function open($, path, opt) {
             __disposeResources(env_1);
         }
     }
-    if (checkAccess && (!hasAccess($, stats, mode) || !hasAccess($, stats, flags.toMode(flag)))) {
+    if (checkAccess && !hasAccess($, stats, flags.toMode(flag))) {
         throw UV('EACCES', 'open', path);
     }
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', 'open', path);
     if (!opt.allowDirectory && isDirectory(stats))
         throw UV('EISDIR', 'open', path);
-    const file = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
+    const file = new Handle($, path, resolved, flag, cache.ref(resolved, stats));
     if (flag & constants.O_TRUNC)
         file.truncateSync(0);
     return file;
@@ -192,7 +202,7 @@ export function mkdir(path, options = {}) {
     const original = normalizePath.call(this, path);
     const $ex = { syscall: 'mkdir', path: original };
     const { fullPath: realParent } = resolve(this, dirname(original), false, $ex);
-    const { fs, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
+    const { fs, cache, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
     const followed = realParent != dirname(original);
     const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
@@ -201,11 +211,11 @@ export function mkdir(path, options = {}) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const parentPath = dirname(resolved);
-            const parent = recursive && parentPath != '/' ? __create(dirname(path), parentPath) : fs.statSync(parentPath);
+            const parent = recursive && parentPath != '/' ? __create(dirname(path), parentPath) : cache.statSync(parentPath, $ex);
             if (recursive) {
                 let existing;
                 try {
-                    existing = cacheOf(fs).get(resolved)?.inode ?? fs.statSync(resolved);
+                    existing = cache.statSync(resolved);
                 }
                 catch {
                     // It doesn't exist yet
@@ -221,9 +231,9 @@ export function mkdir(path, options = {}) {
                 if (followed && fs.existsSync(join(parentPath, basename(path))))
                     throw UV('ENOENT', $ex);
             }
-            if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+            if (checkAccess && !hasAccess(this, parent, constants.W_OK | constants.X_OK))
                 throw UV('EACCES', 'mkdir', path);
-            const _ = __addDisposableResource(env_2, lockPathSync(fs, parentPath, 'rw', parent), false);
+            const _ = __addDisposableResource(env_2, cache.lockSync(parentPath, 'rw', parent), false);
             const inode = wrap(fs, 'mkdirSync', { path, syscall: 'mkdir' })(resolved, {
                 mode,
                 uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
@@ -247,9 +257,9 @@ export function mkdir(path, options = {}) {
 }
 export function readdir(path, options = {}) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolve(this, path);
+    const { fs, cache, path: resolved } = resolve(this, path);
     // Node reports `readdir` failures as `scandir`
-    const stats = cacheOf(fs).get(resolved)?.inode ?? wrap(fs, 'statSync', { path, syscall: 'scandir' })(resolved);
+    const stats = cache.statSync(resolved, { path, syscall: 'scandir' });
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', 'scandir', path);
     if (!isDirectory(stats))
@@ -258,7 +268,7 @@ export function readdir(path, options = {}) {
     {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_3, lockPathSync(fs, resolved, 'ro', stats), false);
+            const _ = __addDisposableResource(env_3, cache.lockSync(resolved, 'ro', stats), false);
             entries = fs.readdirSync(resolved);
         }
         catch (e_3) {
@@ -269,12 +279,11 @@ export function readdir(path, options = {}) {
             __disposeResources(env_3);
         }
     }
-    // Iterate over entries and handle recursive case if needed
     const values = [];
     const addEntry = (entry) => {
         let entryStat;
         try {
-            entryStat = fs.statSync(join(resolved, entry));
+            entryStat = cache.statSync(join(resolved, entry), { syscall: 'scandir', path });
         }
         catch (e) {
             if (e.code == 'ENOENT')
@@ -304,7 +313,7 @@ export function rename(oldPath, newPath) {
         newPath = normalizePath.call(this, newPath);
         const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
         const src = resolve(this, oldPath, true, $ex);
-        const dst = resolveMount(newPath, this, $ex);
+        const dst = resolve(this, newPath, true, $ex);
         if (src.fs.uuid !== dst.fs.uuid)
             throw UV('EXDEV', $ex);
         // A directory can not be moved inside itself
@@ -312,25 +321,29 @@ export function rename(oldPath, newPath) {
             throw UV('EINVAL', $ex);
         if (!src.stats)
             throw UV('ENOENT', $ex);
-        const fs = src.fs;
-        const oldParent = fs.statSync(dirname(src.path));
-        const newParent = fs.statSync(dirname(dst.path));
+        const srcDir = dirname(src.path);
+        const dstDir = dirname(dst.path);
+        const oldParent = src.cache.statSync(srcDir, $ex);
+        const newParent = src.cache.statSync(dstDir, $ex);
         let newStats;
         try {
-            newStats = fs.statSync(dst.path);
+            newStats = src.cache.statSync(dst.path, $ex);
         }
         catch (e) {
             if (e.code != 'ENOENT')
                 throw e;
         }
-        if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
+        assertRemovable(this, oldParent, src.stats, $ex);
+        if (newStats)
+            assertRemovable(this, newParent, newStats, $ex);
+        if (checkAccess && !hasAccess(this, newParent, constants.W_OK | constants.X_OK))
+            throw UV('EACCES', $ex);
+        if (checkAccess && isDirectory(src.stats) && srcDir != dstDir && !hasAccess(this, src.stats, constants.W_OK))
             throw UV('EACCES', $ex);
         if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
             throw UV('EISDIR', $ex);
         if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
             throw UV('ENOTDIR', $ex);
-        const srcDir = dirname(src.path);
-        const dstDir = dirname(dst.path);
         // Lock both parent directories, ordered by inode number to avoid ABBA deadlocks (like Linux's `lock_two_nondirectories`)
         const parents = [
             [srcDir, oldParent],
@@ -338,10 +351,10 @@ export function rename(oldPath, newPath) {
         ];
         if (oldParent.ino > newParent.ino)
             parents.reverse();
-        const _first = __addDisposableResource(env_4, lockPathSync(fs, parents[0][0], 'rw', parents[0][1]), false);
-        const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : lockPathSync(fs, parents[1][0], 'rw', parents[1][1]), false);
+        const _first = __addDisposableResource(env_4, src.cache.lockSync(parents[0][0], 'rw', parents[0][1]), false);
+        const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : src.cache.lockSync(parents[1][0], 'rw', parents[1][1]), false);
         src.fs.renameSync(src.path, dst.path);
-        cacheOf(fs).rename(src.path, dst.path);
+        src.cache.rename(src.path, dst.path);
         // Both names change which entries exist, so both are 'rename' events
         emitChange(this, 'rename', oldPath);
         emitChange(this, 'rename', newPath);
@@ -360,24 +373,24 @@ export function link(target, link) {
         target = normalizePath.call(this, target);
         link = normalizePath.call(this, link);
         const $ex = { syscall: 'link', path: target, dest: link };
-        const { fs, path: resolved } = resolveMount(target, this, $ex);
-        const dst = resolveMount(link, this, $ex);
+        const { fs, cache, path: resolved } = resolve(this, target, true, $ex);
+        const dst = resolve(this, link, true, $ex);
         if (fs.uuid !== dst.fs.uuid)
             throw UV('EXDEV', $ex);
-        const stats = fs.statSync(resolved);
+        const stats = cache.statSync(resolved, $ex);
         if (checkAccess) {
             if (!hasAccess(this, stats, constants.R_OK))
                 throw UV('EACCES', $ex);
-            const dirStats = fs.statSync(dirname(resolved));
+            const dirStats = cache.statSync(dirname(resolved), $ex);
             if (!hasAccess(this, dirStats, constants.R_OK))
                 throw UV('EACCES', $ex);
-            const destStats = fs.statSync(dirname(dst.path));
+            const destStats = cache.statSync(dirname(dst.path), $ex);
             if (!hasAccess(this, destStats, constants.W_OK))
                 throw UV('EACCES', $ex);
         }
-        const _ = __addDisposableResource(env_5, lockPathSync(fs, dirname(dst.path), 'rw'), false);
+        const _ = __addDisposableResource(env_5, cache.lockSync(dirname(dst.path), 'rw'), false);
         fs.linkSync(resolved, dst.path);
-        cacheOf(fs).link(resolved, dst.path);
+        cache.link(resolved, dst.path);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -395,10 +408,15 @@ export function stat(path, lstat) {
         stats = resolve(this, path, false, extra).stats;
     else {
         const { base, dir } = parse(path);
-        const { fs, path: parent } = resolve(this, dir, false, extra);
+        const parent = resolve(this, dir, false, extra);
+        if (parent.stats && isDirectory(parent.stats))
+            assertSearchable(this, parent.stats, extra);
+        const { root, mounts } = contextOf(this);
+        const mounted = base && mounts.get(join(root, parent.fullPath, base));
+        const fs = mounted || parent.fs;
+        const target = mounted ? '/' : join(parent.path, base);
         try {
-            const target = base ? join(parent, base) : parent;
-            stats = cacheOf(fs).get(target)?.inode ?? fs.statSync(target);
+            stats = cacheOf(fs).statSync(target);
         }
         catch (e) {
             setUVMessage(Object.assign(e, extra));
@@ -407,7 +425,5 @@ export function stat(path, lstat) {
     }
     if (!stats)
         throw UV('ENOENT', extra);
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', extra);
     return stats;
 }

package/dist/vfs/vcache.d.ts

@@ -1,6 +1,8 @@
 import type { LockMode, LockRelease } from 'kerium/locks';
+import { type ExceptionExtra } from 'kerium';
 import type { FileSystem } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
+import '../polyfills.js';
 import { VNode } from './vnode.js';
 /**
  * The VFS-level cache of vnodes for a single file system. Modeled after Linux's dcache/icache.
@@ -35,6 +37,18 @@ export declare class VCache {
     sync(): Promise<void>;
     /** Sync all dirty vnodes to the backend synchronously */
     syncSync(): void;
+    /** Get the inode for a path, preferring the cached vnode since it may have unsynced changes */
+    stat(path: string, extra?: ExceptionExtra): Promise<InodeLike>;
+    /** Synchronous version of {@link stat} */
+    statSync(path: string, extra?: ExceptionExtra): InodeLike;
+    /**
+     * Ref and lock the vnode for a path, usually a parent directory during a namespace operation.
+     * The returned release function unlocks and unrefs the vnode.
+     * If `inode` is not provided and the vnode is not cached, the backend is `stat`ed.
+     */
+    lock(path: string, mode: LockMode, inode?: InodeLike): Promise<LockRelease>;
+    /** Synchronous version of {@link lock} */
+    lockSync(path: string, mode: LockMode, inode?: InodeLike): LockRelease;
 }
 /**
  * All vnode caches, keyed by file system UUID.
@@ -50,17 +64,3 @@ export declare const caches: Map<`${string}-${string}-${string}-${string}-${stri
  * @internal
  */
 export declare function cacheOf(fs: FileSystem): VCache;
-/**
- * Ref and lock the vnode for a path, usually a parent directory during a namespace operation.
- * The returned release function unlocks and unrefs the vnode.
- * If `inode` is not provided and the vnode is not cached, the backend is `stat`ed.
- * @category VFS
- * @internal
- */
-export declare function lockPath(fs: FileSystem, path: string, mode: LockMode, inode?: InodeLike): Promise<LockRelease>;
-/**
- * Synchronous version of `lockPath`.
- * @category VFS
- * @internal
- */
-export declare function lockPathSync(fs: FileSystem, path: string, mode: LockMode, inode?: InodeLike): LockRelease;

package/dist/vfs/vcache.js

@@ -50,7 +50,10 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { setUVMessage } from 'kerium';
 import { err } from 'kerium/log';
+import { withoutExceptionContext } from '../internal/error.js';
+import '../polyfills.js';
 import { VNode } from './vnode.js';
 /**
  * The VFS-level cache of vnodes for a single file system. Modeled after Linux's dcache/icache.
@@ -85,7 +88,6 @@ export class VCache {
         }
         else {
             node.paths.add(path);
-            // The vnode's inode is authoritative when dirty; otherwise refresh it with the newer stats
             if (!node.dirty && inode !== node.inode)
                 Object.assign(node.inode, inode);
         }
@@ -177,6 +179,67 @@ export class VCache {
             }
         }
     }
+    /** Get the inode for a path, preferring the cached vnode since it may have unsynced changes */
+    async stat(path, extra) {
+        try {
+            return this.get(path)?.inode ?? (await this.fs.stat(path));
+        }
+        catch (e) {
+            throw extra ? setUVMessage(Object.assign(e, extra)) : e;
+        }
+    }
+    /** Synchronous version of {@link stat} */
+    statSync(path, extra) {
+        try {
+            return this.get(path)?.inode ?? this.fs.statSync(path);
+        }
+        catch (e) {
+            throw extra ? setUVMessage(Object.assign(e, extra)) : e;
+        }
+    }
+    /**
+     * Ref and lock the vnode for a path, usually a parent directory during a namespace operation.
+     * The returned release function unlocks and unrefs the vnode.
+     * If `inode` is not provided and the vnode is not cached, the backend is `stat`ed.
+     */
+    async lock(path, mode, inode) {
+        inode ??= await this.stat(path);
+        const node = this.ref(path, inode);
+        const unlock = await node.lock(mode);
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            unlock();
+            this.unref(node);
+        };
+        release[Symbol.dispose] = release;
+        return release;
+    }
+    /** Synchronous version of {@link lock} */
+    lockSync(path, mode, inode) {
+        inode ??= this.statSync(path);
+        const node = this.ref(path, inode);
+        let unlock;
+        try {
+            unlock = node.lockSync(mode);
+        }
+        catch (e) {
+            this.unref(node);
+            throw e;
+        }
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            unlock();
+            this.unref(node);
+        };
+        release[Symbol.dispose] = release;
+        return release;
+    }
 }
 /**
  * All vnode caches, keyed by file system UUID.
@@ -192,61 +255,5 @@ export const caches = new Map();
  * @internal
  */
 export function cacheOf(fs) {
-    let cache = caches.get(fs.uuid);
-    if (!cache) {
-        cache = new VCache(fs);
-        caches.set(fs.uuid, cache);
-    }
-    return cache;
-}
-/**
- * Ref and lock the vnode for a path, usually a parent directory during a namespace operation.
- * The returned release function unlocks and unrefs the vnode.
- * If `inode` is not provided and the vnode is not cached, the backend is `stat`ed.
- * @category VFS
- * @internal
- */
-export async function lockPath(fs, path, mode, inode) {
-    const cache = cacheOf(fs);
-    inode ??= cache.get(path)?.inode ?? (await fs.stat(path));
-    const node = cache.ref(path, inode);
-    const unlock = await node.lock(mode);
-    let released = false;
-    const release = () => {
-        if (released)
-            return;
-        released = true;
-        unlock();
-        cache.unref(node);
-    };
-    release[Symbol.dispose] = release;
-    return release;
-}
-/**
- * Synchronous version of `lockPath`.
- * @category VFS
- * @internal
- */
-export function lockPathSync(fs, path, mode, inode) {
-    const cache = cacheOf(fs);
-    inode ??= cache.get(path)?.inode ?? fs.statSync(path);
-    const node = cache.ref(path, inode);
-    let unlock;
-    try {
-        unlock = node.lockSync(mode);
-    }
-    catch (e) {
-        cache.unref(node);
-        throw e;
-    }
-    let released = false;
-    const release = () => {
-        if (released)
-            return;
-        released = true;
-        unlock();
-        cache.unref(node);
-    };
-    release[Symbol.dispose] = release;
-    return release;
+    return caches.getOrInsertComputed(fs.uuid, () => new VCache(withoutExceptionContext(fs)));
 }

package/dist/vfs/watchers.d.ts

@@ -3,6 +3,7 @@ import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import { EventEmitter } from 'eventemitter3';
 import { type Stats } from '../node/stats.js';
+import '../polyfills.js';
 /**
  * Base class for file system watchers.
  * Provides event handling capabilities for watching file system changes.

package/dist/vfs/watchers.js

@@ -4,6 +4,7 @@ import { contextOf } from '../internal/contexts.js';
 import { isStatsEqual } from '../node/stats.js';
 import { statSync } from '../node/sync.js';
 import { basename, dirname, join, relative } from '../path.js';
+import '../polyfills.js';
 import { normalizePath } from '../utils.js';
 /** Alias so `.call` resolves to the non-bigint overload */
 const _statSync = statSync;
@@ -130,10 +131,7 @@ export class StatWatcher extends Watcher {
 const watchers = new Map();
 export function addWatcher(path, watcher) {
     const normalizedPath = normalizePath(path);
-    if (!watchers.has(normalizedPath)) {
-        watchers.set(normalizedPath, new Set());
-    }
-    watchers.get(normalizedPath).add(watcher);
+    watchers.getOrInsertComputed(normalizedPath, () => new Set()).add(watcher);
 }
 export function removeWatcher(path, watcher) {
     const normalizedPath = normalizePath(path);

package/dist/vfs/xattr.js

@@ -5,7 +5,8 @@ import { Attributes, hasAccess } from '../internal/inode.js';
 import { normalizePath } from '../utils.js';
 import { checkAccess } from './config.js';
 import { R_OK, W_OK } from '../constants.js';
-import { resolveMount } from './shared.js';
+import { resolve as resolveAsync } from './async.js';
+import { resolve as resolveSync } from './sync.js';
 /** Attributes outside the `user` namespace that are supported. */
 export const allowedRestrictedNames = new Set();
 /**
@@ -19,9 +20,9 @@ function checkName($, name, path, syscall) {
 }
 export async function get(path, name, opt = {}) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { cache, path: resolved } = await resolveAsync(this, path, opt.noFollow);
     checkName(this, name, path, 'xattr.get');
-    const inode = await fs.stat(resolved).catch(rethrow('xattr.get', path));
+    const inode = await cache.stat(resolved).catch(rethrow('xattr.get', path));
     if (checkAccess && !hasAccess(this, inode, R_OK))
         throw UV('EACCES', 'xattr.get', path);
     inode.attributes ??= new Attributes();
@@ -34,10 +35,10 @@ export async function get(path, name, opt = {}) {
 export function getSync(path, name, opt = {}) {
     path = normalizePath.call(this, path);
     checkName(this, name, path, 'xattr.get');
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { cache, path: resolved } = resolveSync(this, path, opt.noFollow);
     let inode;
     try {
-        inode = fs.statSync(resolved);
+        inode = cache.statSync(resolved);
     }
     catch (e) {
         throw setUVMessage(Object.assign(e, { path }));
@@ -61,9 +62,9 @@ export function getSync(path, name, opt = {}) {
  */
 export async function set(path, name, value, opt = {}) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = await resolveAsync(this, path, opt.noFollow);
     checkName(this, name, path, 'xattr.set');
-    const inode = await fs.stat(resolved).catch(rethrow('xattr.set', path));
+    const inode = await cache.stat(resolved).catch(rethrow('xattr.set', path));
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.set', path);
     inode.attributes ??= new Attributes();
@@ -85,11 +86,11 @@ export async function set(path, name, value, opt = {}) {
  */
 export function setSync(path, name, value, opt = {}) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = resolveSync(this, path, opt.noFollow);
     checkName(this, name, path, 'xattr.set');
     let inode;
     try {
-        inode = fs.statSync(resolved);
+        inode = cache.statSync(resolved);
     }
     catch (e) {
         throw setUVMessage(Object.assign(e, { path }));
@@ -118,9 +119,9 @@ export function setSync(path, name, value, opt = {}) {
  */
 export async function remove(path, name) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = await resolveAsync(this, path);
     checkName(this, name, path, 'xattr.remove');
-    const inode = await fs.stat(resolved).catch(rethrow('xattr.remove', path));
+    const inode = await cache.stat(resolved).catch(rethrow('xattr.remove', path));
     if (checkAccess && !hasAccess(this, inode, W_OK))
         throw UV('EACCES', 'xattr.remove', path);
     inode.attributes ??= new Attributes();
@@ -138,11 +139,11 @@ export async function remove(path, name) {
  */
 export function removeSync(path, name) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = resolveSync(this, path);
     checkName(this, name, path, 'xattr.remove');
     let inode;
     try {
-        inode = fs.statSync(resolved);
+        inode = cache.statSync(resolved);
     }
     catch (e) {
         throw setUVMessage(Object.assign(e, { path }));
@@ -169,8 +170,8 @@ export function removeSync(path, name) {
  */
 export async function list(path) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const inode = await fs.stat(resolved).catch(rethrow('xattr.list', path));
+    const { cache, path: resolved } = await resolveAsync(this, path);
+    const inode = await cache.stat(resolved).catch(rethrow('xattr.list', path));
     if (!inode.attributes)
         return [];
     return [...inode.attributes.keys()];
@@ -183,10 +184,10 @@ export async function list(path) {
  */
 export function listSync(path) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { cache, path: resolved } = resolveSync(this, path);
     let inode;
     try {
-        inode = fs.statSync(resolved);
+        inode = cache.statSync(resolved);
     }
     catch (e) {
         throw setUVMessage(Object.assign(e, { path }));