@zenfs/core 2.7.6 → 2.8.0

package/dist/vfs/sync.js

@@ -53,13 +53,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
-import { contextOf } from '../internal/contexts.js';
+import { applyUmask, 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 { normalizeMode, normalizePath, normalizeTime } from '../utils.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);
         }
-        const target = resolvePath.call($, dirname(path), readlink.call($, path));
-        return resolve($, target, preserveSymlinks, extra);
+        catch {
+            // Go the long way
+        }
+    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,16 +153,16 @@ 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,
+                mode: applyUmask($, mode),
                 uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
                 gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
             });
             // 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,20 +202,21 @@ 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;
+    const { recursive } = options;
+    const mode = applyUmask(this, options.mode ?? 0o777);
     let firstCreated;
     const __create = (path, resolved) => {
         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 +232,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 +258,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 +269,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) {
@@ -273,7 +284,7 @@ export function readdir(path, options = {}) {
     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')
@@ -303,7 +314,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
@@ -311,25 +322,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],
@@ -337,10 +352,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);
@@ -359,24 +374,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;
@@ -394,10 +409,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));
@@ -406,7 +426,65 @@ 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;
 }
+/**
+ * Opens a handle for changing metadata, which does not need read or write access to the file.
+ */
+function _openMetadata($, path, syscall, noFollow) {
+    const { fullPath, cache, path: resolved, stats } = resolve($, path, noFollow, { syscall });
+    if (!stats)
+        throw UV('ENOENT', syscall, path);
+    return new Handle($, fullPath, resolved, constants.O_RDONLY, cache.ref(resolved, stats));
+}
+export function chmod(path, mode, noFollow) {
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const numMode = normalizeMode(mode, -1);
+        if (numMode < 0)
+            throw UV('EINVAL', 'chmod', path);
+        const handle = __addDisposableResource(env_6, _openMetadata(this, path, 'chmod', noFollow), false);
+        handle.chmodSync(numMode);
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
+    finally {
+        __disposeResources(env_6);
+    }
+}
+export function chown(path, uid, gid, noFollow) {
+    const env_7 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const handle = __addDisposableResource(env_7, _openMetadata(this, path, 'chown', noFollow), false);
+        handle.chownSync(uid, gid);
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
+    }
+    finally {
+        __disposeResources(env_7);
+    }
+}
+export function utimes(path, atime, mtime, noFollow) {
+    const env_8 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath.call(this, path);
+        const handle = __addDisposableResource(env_8, _openMetadata(this, path, 'utimes', noFollow), false);
+        handle.utimesSync(normalizeTime(atime), normalizeTime(mtime));
+        emitChange(this, 'change', handle.path);
+    }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
+    finally {
+        __disposeResources(env_8);
+    }
+}

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.
@@ -176,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.
@@ -191,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);