@zenfs/core 2.7.6 → 2.7.7

package/dist/backends/store/fs.js

@@ -93,9 +93,7 @@ export class StoreFS extends FileSystem {
      * Add a inode/path pair
      */
     _add(ino, path) {
-        if (!this._paths.has(ino))
-            this._paths.set(ino, new Set());
-        this._paths.get(ino).add(path);
+        this._paths.getOrInsertComputed(ino, () => new Set()).add(path);
         this._ids.set(path, ino);
     }
     /**

package/dist/backends/store/store.js

@@ -202,9 +202,7 @@ export class WrappedTransaction {
      * on during the transaction.
      */
     stash(id, data, offset = 0) {
-        if (!this.originalData.has(id))
-            this.originalData.set(id, []);
-        this.originalData.get(id).push({ data, offset });
+        this.originalData.getOrInsertComputed(id, () => []).push({ data, offset });
     }
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.

package/dist/config.d.ts

@@ -72,6 +72,12 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     disableAccessChecks: boolean;
+    /**
+     * If true, path resolution always walks each directory in a path, checking search permission on each.
+     * This is more correct but can be much slower.
+     * @default false
+     */
+    resolveFullWalk: boolean;
     /**
      * If true, files will only sync to the file system when closed.
      * This overrides `disableUpdateOnRead`
@@ -79,6 +85,7 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * This can increase performance.
      * @experimental
      * @default false
+     * @deprecated Replaced by the `Sync` inode flag in v2.0.0
      */
     onlySyncOnClose: boolean;
     /**

package/dist/config.js

@@ -6,7 +6,7 @@ import { DeviceFS } from './internal/devices.js';
 import { FileSystem } from './internal/filesystem.js';
 import { exists, mkdir, stat } from './node/promises.js';
 import { existsSync, mkdirSync, statSync } from './node/sync.js';
-import { _setAccessChecks } from './vfs/config.js';
+import { _setVFSConfig } from './vfs/config.js';
 import { mount, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
@@ -209,7 +209,10 @@ export async function configure(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {
@@ -257,7 +260,10 @@ export function configureSync(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {

package/dist/internal/error.d.ts

@@ -25,3 +25,8 @@ export declare function wrap<const FS, const Prop extends keyof FS & string>(fs:
  * Wraps an `fs` so that thrown errors aren't empty
  */
 export declare function withExceptionContext<const FS extends FileSystem>(fs: FS, context: ExceptionExtra): FS;
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export declare function withoutExceptionContext<const FS extends FileSystem>(fs: FS): FS;

package/dist/internal/error.js

@@ -26,6 +26,7 @@ export function wrap(fs, prop, path, dest) {
         }
     };
 }
+const kTarget = Symbol('withExceptionContext:target');
 /**
  * @internal
  * Wraps an `fs` so that thrown errors aren't empty
@@ -33,6 +34,8 @@ export function wrap(fs, prop, path, dest) {
 export function withExceptionContext(fs, context) {
     return new Proxy(fs, {
         get(target, prop) {
+            if (prop === kTarget)
+                return target;
             const value = Reflect.get(target, prop);
             if (typeof value != 'function')
                 return value;
@@ -58,3 +61,10 @@ export function withExceptionContext(fs, context) {
         },
     });
 }
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export function withoutExceptionContext(fs) {
+    return fs[kTarget] ?? fs;
+}

package/dist/internal/inode.d.ts

@@ -1,3 +1,4 @@
+import { type ExceptionExtra } from 'kerium';
 import { BufferView } from 'utilium/buffer';
 import { Stats } from '../node/stats.js';
 import { type V_Context } from './contexts.js';
@@ -234,10 +235,34 @@ export declare function isFIFO(metadata: {
  * @internal
  */
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export declare function assertSearchable($: V_Context, dir: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export declare function assertRemovable($: V_Context, parent: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, entry: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export declare function assertOwner($: V_Context, inode: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export declare function assertCanChown($: V_Context, inode: Pick<InodeLike, 'uid' | 'gid'>, uid: number, gid: number, extra?: ExceptionExtra): void;
 /**
  * @hidden @internal
  *
  * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
+/**
+ * @hidden @internal
+ */
+export declare function _chmod($: V_Context, inode: Pick<InodeLike, 'mode' | 'gid'>, mode: number): void;
 export {};

package/dist/internal/inode.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { withErrno } from 'kerium';
+import { UV, withErrno } from 'kerium';
 import { crit, warn } from 'kerium/log';
 import { sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
@@ -41,6 +41,7 @@ import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer';
 import * as c from '../constants.js';
 import { Stats } from '../node/stats.js';
+import { checkAccess } from '../vfs/config.js';
 import { contextOf } from './contexts.js';
 /**
  * Root inode
@@ -654,10 +655,10 @@ export function hasAccess($, inode, access) {
     const { credentials } = contextOf($);
     if (isSymbolicLink(inode))
         return true;
-    if (credentials.euid === 0 || credentials.egid === 0)
+    if (credentials.euid === 0)
         return !(access & c.X_OK) || isDirectory(inode) || !!(inode.mode & (c.S_IXUSR | c.S_IXGRP | c.S_IXOTH));
     let perm = 0;
-    if (credentials.uid === inode.uid) {
+    if (credentials.euid === inode.uid) {
         if (inode.mode & c.S_IRUSR)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWUSR)
@@ -665,7 +666,7 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXUSR)
             perm |= c.X_OK;
     }
-    if (credentials.gid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
+    else if (credentials.egid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
         if (inode.mode & c.S_IRGRP)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWGRP)
@@ -673,14 +674,64 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXGRP)
             perm |= c.X_OK;
     }
-    if (inode.mode & c.S_IROTH)
-        perm |= c.R_OK;
-    if (inode.mode & c.S_IWOTH)
-        perm |= c.W_OK;
-    if (inode.mode & c.S_IXOTH)
-        perm |= c.X_OK;
+    else {
+        if (inode.mode & c.S_IROTH)
+            perm |= c.R_OK;
+        if (inode.mode & c.S_IWOTH)
+            perm |= c.W_OK;
+        if (inode.mode & c.S_IXOTH)
+            perm |= c.X_OK;
+    }
     return (perm & access) === access;
 }
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export function assertSearchable($, dir, extra) {
+    if (checkAccess && !hasAccess($, dir, c.X_OK))
+        throw UV('EACCES', extra);
+}
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export function assertRemovable($, parent, entry, extra) {
+    if (!checkAccess)
+        return;
+    if (!hasAccess($, parent, c.W_OK | c.X_OK))
+        throw UV('EACCES', extra);
+    const { euid } = contextOf($).credentials;
+    if (parent.mode & c.S_ISVTX && euid !== 0 && euid !== entry.uid && euid !== parent.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export function assertOwner($, inode, extra) {
+    if (!checkAccess)
+        return;
+    const { euid } = contextOf($).credentials;
+    if (euid !== 0 && euid !== inode.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export function assertCanChown($, inode, uid, gid, extra) {
+    if (!checkAccess)
+        return;
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (euid === 0)
+        return;
+    const isOwner = euid === inode.uid;
+    if (uid !== -1 && !(isOwner && uid === inode.uid))
+        throw UV('EPERM', extra);
+    if (gid !== -1 && !(isOwner && (gid === inode.gid || gid === egid || groups.includes(gid))))
+        throw UV('EPERM', extra);
+}
 /**
  * @hidden @internal
  *
@@ -696,5 +747,19 @@ export function _chown(stats, uid, gid) {
         stats.gid = gid;
     else
         valid = false;
+    if (stats.mode !== undefined && !isDirectory({ mode: stats.mode })) {
+        stats.mode &= ~c.S_ISUID;
+        if (stats.mode & c.S_IXGRP)
+            stats.mode &= ~c.S_ISGID;
+    }
     return valid;
 }
+/**
+ * @hidden @internal
+ */
+export function _chmod($, inode, mode) {
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (checkAccess && euid !== 0 && egid !== inode.gid && !groups.includes(inode.gid))
+        mode &= ~c.S_ISGID;
+    inode.mode = (inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+}

package/dist/mixins/async.js

@@ -57,6 +57,12 @@ import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
 import { _asyncFSKeys } from './shared.js';
+/**
+ * Whether the stack of `error` has a patched method or `key`'s sync method below the innermost patched method.
+ */
+function isInLoop(key, error = new Error()) {
+    return new RegExp(`__patched__[^]*(__patched__|\\b${key}Sync\\b)`).test(error.stack ?? '');
+}
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -82,6 +88,8 @@ export function Async(FS) {
             return this.sync();
         }
         _promise = Promise.resolve();
+        /** The async methods before patching, which do not update the sync cache */
+        _unpatched = {};
         _async(thunk) {
             this._promise = this._promise.finally(() => thunk());
         }
@@ -132,7 +140,7 @@ export function Async(FS) {
         renameSync(oldPath, newPath) {
             this.checkSync();
             this._sync.renameSync(oldPath, newPath);
-            this._async(() => this.rename(oldPath, newPath));
+            this._async(() => this._unpatched.rename(oldPath, newPath));
         }
         statSync(path) {
             this.checkSync();
@@ -141,28 +149,28 @@ export function Async(FS) {
         touchSync(path, metadata) {
             this.checkSync();
             this._sync.touchSync(path, metadata);
-            this._async(() => this.touch(path, metadata));
+            this._async(() => this._unpatched.touch(path, metadata));
         }
         createFileSync(path, options) {
             this.checkSync();
             const result = this._sync.createFileSync(path, options);
-            this._async(() => this.createFile(path, options));
+            this._async(() => this._unpatched.createFile(path, options));
             return result;
         }
         unlinkSync(path) {
             this.checkSync();
             this._sync.unlinkSync(path);
-            this._async(() => this.unlink(path));
+            this._async(() => this._unpatched.unlink(path));
         }
         rmdirSync(path) {
             this.checkSync();
             this._sync.rmdirSync(path);
-            this._async(() => this.rmdir(path));
+            this._async(() => this._unpatched.rmdir(path));
         }
         mkdirSync(path, options) {
             this.checkSync();
             const result = this._sync.mkdirSync(path, options);
-            this._async(() => this.mkdir(path, options));
+            this._async(() => this._unpatched.mkdir(path, options));
             return result;
         }
         readdirSync(path) {
@@ -172,7 +180,7 @@ export function Async(FS) {
         linkSync(srcpath, dstpath) {
             this.checkSync();
             this._sync.linkSync(srcpath, dstpath);
-            this._async(() => this.link(srcpath, dstpath));
+            this._async(() => this._unpatched.link(srcpath, dstpath));
         }
         async sync() {
             if (!this.attributes.has('no_async_preload') && this._sync)
@@ -194,7 +202,7 @@ export function Async(FS) {
         writeSync(path, buffer, offset) {
             this.checkSync();
             this._sync.writeSync(path, buffer, offset);
-            this._async(() => this.write(path, buffer, offset));
+            this._async(() => this._unpatched.write(path, buffer, offset));
         }
         ioctlSync(context, command, ...args) {
             this.checkSync();
@@ -261,22 +269,9 @@ export function Async(FS) {
             for (const key of toPatch) {
                 // TS does not narrow the union based on the key
                 const originalMethod = this[key].bind(this);
-                function isInLoop(depth, error) {
-                    if (!error) {
-                        error = new Error();
-                        Error.captureStackTrace(error, isInLoop);
-                    }
-                    if (!error.stack)
-                        return false;
-                    const stack = error.stack.split('\n').slice(depth).join('\n');
-                    // From the async queue
-                    return (stack.includes(`at <computed> [as ${key}]`)
-                        || stack.includes(`at async <computed> [as ${key}]`)
-                        || stack.includes(`${key}Sync `));
-                }
-                this[key] = async (...args) => {
+                const fn = async function __patched__(...args) {
                     const result = await originalMethod(...args);
-                    if (isInLoop(2))
+                    if (isInLoop(key))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -287,13 +282,16 @@ export function Async(FS) {
                         this._sync?.[`${key}Sync`]?.(...args);
                     }
                     catch (e) {
-                        if (isInLoop(3, e))
+                        if (isInLoop(key, e))
                             return result;
                         e.message += ' (Out of sync!)';
                         throw err(e);
                     }
                     return result;
                 };
+                Object.defineProperty(fn, 'name', { get: () => key });
+                this._unpatched[key] = originalMethod;
+                this[key] = fn;
             }
             debug(`Async: patched ${toPatch.length} methods`);
         }

package/dist/node/promises.js

@@ -55,7 +55,7 @@ import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
-import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
+import { assertRemovable, hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
 import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import '../polyfills.js';
 import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
@@ -63,8 +63,7 @@ import * as _async from '../vfs/async.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
-import { _statfs, resolveMount } from '../vfs/shared.js';
-import { cacheOf, lockPath } from '../vfs/vcache.js';
+import { _statfs } from '../vfs/shared.js';
 import { emitChange, FSWatcher } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { createInterface } from './readline.js';
@@ -535,7 +534,7 @@ export async function exists(path) {
         return await fs.exists(resolved);
     }
     catch (e) {
-        if (e instanceof Exception && e.code == 'ENOENT') {
+        if (e instanceof Exception && (e.code == 'ENOENT' || e.code == 'ENOTDIR' || e.code == 'EACCES')) {
             return false;
         }
         throw e;
@@ -580,14 +579,13 @@ export async function unlink(path) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = resolveMount(path, this);
         const $ex = { syscall: 'unlink', path };
-        const stats = await fs.stat(resolved).catch(rethrow($ex));
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', $ex);
-        const _ = __addDisposableResource(env_2, await lockPath(fs, dirname(resolved), 'rw'), false);
+        const { fs, cache, path: resolved } = await _async.resolve(this, path, true, $ex);
+        const stats = await cache.stat(resolved).catch(rethrow($ex));
+        assertRemovable(this, await cache.stat(dirname(resolved)).catch(rethrow($ex)), stats, $ex);
+        const _ = __addDisposableResource(env_2, await cache.lock(dirname(resolved), 'rw'), false);
         await fs.unlink(resolved).catch(rethrow($ex));
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_2) {
@@ -692,18 +690,17 @@ export async function rmdir(path) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = await _async.resolve(this, path);
+        const { fs, cache, path: resolved } = await _async.resolve(this, path, true);
         const $ex = { syscall: 'rmdir', path };
-        const stats = await fs.stat(resolved).catch(rethrow($ex));
+        const stats = await cache.stat(resolved).catch(rethrow($ex));
         if (!stats)
             throw UV('ENOENT', $ex);
         if (!isDirectory(stats))
             throw UV('ENOTDIR', $ex);
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', $ex);
-        const _ = __addDisposableResource(env_6, await lockPath(fs, dirname(resolved), 'rw'), false);
+        assertRemovable(this, await cache.stat(dirname(resolved)).catch(rethrow($ex)), stats, $ex);
+        const _ = __addDisposableResource(env_6, await cache.lock(dirname(resolved), 'rw'), false);
         await fs.rmdir(resolved).catch(rethrow($ex));
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_6) {
@@ -761,7 +758,7 @@ export async function symlink(dest, path, type = 'file') {
         const handle = __addDisposableResource(env_7, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         const encoded = encodeUTF8(normalizePath.call(this, dest, true));
         await handle.write(encoded, 0, encoded.length, 0);
-        await handle.chmod(constants.S_IFLNK);
+        await handle.chmod(constants.S_IFLNK | 0o777);
     }
     catch (e_7) {
         env_7.error = e_7;
@@ -1079,8 +1076,7 @@ export async function cp(source, destination, opts) {
             const [entries] = await Promise.all([
                 readdir.call(this, source, { withFileTypes: true }),
                 mkdir.call(this, destination, { recursive: true }),
-            ] // Ensure the destination directory exists
-            );
+            ]);
             const _cp = async (dirent) => {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
                     return; // Skip if the filter returns false
@@ -1117,8 +1113,8 @@ export async function cp(source, destination, opts) {
 cp;
 export async function statfs(path, opts) {
     path = normalizePath.call(this, path);
-    const { fs } = resolveMount(path, this);
-    return Promise.resolve(_statfs(fs, opts?.bigint));
+    const { fs } = await _async.resolve(this, path);
+    return _statfs(fs, opts?.bigint);
 }
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];

package/dist/node/stats.d.ts

@@ -65,7 +65,7 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     /** @internal Used by inodes */
     version?: number;
     /** Creates a new stats instance from a stats-like object. Can be used to copy stats (note) */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest }?: Partial<InodeLike<number | bigint>>);
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, rdev, dev, blksize, ...rest }?: Partial<InodeLike<number | bigint> & StatsExtra<number | bigint>>);
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;

package/dist/node/stats.js

@@ -96,7 +96,7 @@ export class StatsCommon {
     /** @internal Used by inodes */
     version;
     /** Creates a new stats instance from a stats-like object. Can be used to copy stats (note) */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest } = {}) {
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, rdev, dev, blksize, ...rest } = {}) {
         const now = Date.now();
         this.atimeMs = this._convert(atimeMs ?? now);
         this.mtimeMs = this._convert(mtimeMs ?? now);
@@ -107,6 +107,9 @@ export class StatsCommon {
         this.size = this._convert(size ?? 0);
         this.ino = this._convert(ino ?? 0);
         this.mode = this._convert(mode ?? 0o644 & c.S_IFREG);
+        this.rdev = this._convert(rdev ?? 0);
+        this.dev = this._convert(dev ?? 0);
+        this.blksize = this._convert(blksize ?? 4096);
         if ((this.mode & c.S_IFMT) == 0) {
             this.mode = (this.mode | this._convert(c.S_IFREG));
         }

package/dist/node/sync.js

@@ -56,15 +56,14 @@ import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
-import { hasAccess, isDirectory } from '../internal/inode.js';
+import { assertRemovable, hasAccess, isDirectory } from '../internal/inode.js';
 import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
-import { _statfs, resolveMount } from '../vfs/shared.js';
+import { _statfs } from '../vfs/shared.js';
 import * as _sync from '../vfs/sync.js';
-import { cacheOf, lockPathSync } from '../vfs/vcache.js';
 import { emitChange } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { BigIntStats, Stats } from './stats.js';
@@ -82,7 +81,7 @@ export function existsSync(path) {
         return fs.existsSync(resolvedPath);
     }
     catch (e) {
-        if (e.errno == Errno.ENOENT)
+        if (e.errno == Errno.ENOENT || e.errno == Errno.ENOTDIR || e.errno == Errno.EACCES)
             return false;
         throw e;
     }
@@ -134,16 +133,14 @@ export function truncateSync(path, len = 0) {
 truncateSync;
 export function unlinkSync(path) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = _sync.resolve(this, path, true, { syscall: 'unlink', path });
     try {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
-                throw UV('EACCES', 'unlink');
-            }
-            const _ = __addDisposableResource(env_2, lockPathSync(fs, dirname(resolved), 'rw'), false);
+            assertRemovable(this, cache.statSync(dirname(resolved)), cache.statSync(resolved));
+            const _ = __addDisposableResource(env_2, cache.lockSync(dirname(resolved), 'rw'), false);
             fs.unlinkSync(resolved);
-            cacheOf(fs).remove(resolved);
+            cache.remove(resolved);
         }
         catch (e_2) {
             env_2.error = e_2;
@@ -372,15 +369,14 @@ export function rmdirSync(path) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = _sync.resolve(this, path);
-        const stats = wrap(fs, 'statSync', { path, syscall: 'rmdir' })(resolved);
+        const { fs, cache, path: resolved } = _sync.resolve(this, path, true);
+        const stats = cache.statSync(resolved, { path, syscall: 'rmdir' });
         if (!isDirectory(stats))
             throw UV('ENOTDIR', 'rmdir', path);
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', 'rmdir', path);
-        const _ = __addDisposableResource(env_5, lockPathSync(fs, dirname(resolved), 'rw'), false);
+        assertRemovable(this, cache.statSync(dirname(resolved), { path, syscall: 'rmdir' }), stats, { syscall: 'rmdir', path });
+        const _ = __addDisposableResource(env_5, cache.lockSync(dirname(resolved), 'rw'), false);
         wrap(fs, 'rmdirSync', path)(resolved);
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_5) {
@@ -435,7 +431,7 @@ export function symlinkSync(target, path, type = 'file') {
         path = normalizePath.call(this, path);
         const file = __addDisposableResource(env_6, _sync.open(this, path, { flag: 'wx', mode: 0o644 }), false);
         file.writeSync(encodeUTF8(normalizePath.call(this, target, true)));
-        file.chmodSync(constants.S_IFLNK);
+        file.chmodSync(constants.S_IFLNK | 0o777);
     }
     catch (e_6) {
         env_6.error = e_6;
@@ -706,7 +702,7 @@ export function cpSync(source, destination, opts) {
 cpSync;
 export function statfsSync(path, options) {
     path = normalizePath.call(this, path);
-    const { fs } = resolveMount(path, this);
+    const { fs } = _sync.resolve(this, path);
     return _statfs(fs, options?.bigint);
 }
 export function globSync(pattern, options = {}) {

package/dist/polyfills.js

@@ -66,4 +66,20 @@ Array.fromAsync ??=
             }
             return results;
         });
+Map.prototype.getOrInsert ??=
+    (warn('Using a polyfill of Map.prototype.getOrInsert'),
+        function getOrInsert(key, defaultValue) {
+            if (!this.has(key))
+                this.set(key, defaultValue);
+            return this.get(key);
+        });
+Map.prototype.getOrInsertComputed ??=
+    (warn('Using a polyfill of Map.prototype.getOrInsertComputed'),
+        function getOrInsertComputed(key, callback) {
+            if (this.has(key))
+                return this.get(key);
+            const value = callback(key);
+            this.set(key, value);
+            return value;
+        });
 /* node:coverage enable */