@zenfs/core 2.7.6 → 2.8.0

package/dist/mixins/async.js

@@ -57,6 +57,18 @@ 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 ?? '');
+}
+/**
+ * Whether the stack has a queued replay below the innermost patched method.
+ */
+function isReplay() {
+    return /__patched__[^]*__replay__/.test(new Error().stack ?? '');
+}
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -82,8 +94,21 @@ export function Async(FS) {
             return this.sync();
         }
         _promise = Promise.resolve();
+        /** How many queued operations have not finished */
+        _pending = 0;
+        /** The async methods before patching, which do not update the sync cache */
+        _unpatched = {};
         _async(thunk) {
-            this._promise = this._promise.finally(() => thunk());
+            this._pending++;
+            const replay = async function __replay__() {
+                try {
+                    await thunk();
+                }
+                finally {
+                    this._pending--;
+                }
+            };
+            this._promise = this._promise.finally(replay.bind(this));
         }
         _isInitialized = false;
         /** Tracks how many updates to the sync. cache we skipped during initialization */
@@ -132,7 +157,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 +166,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 +197,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 +219,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();
@@ -253,30 +278,19 @@ export function Async(FS) {
         }
         /**
          * @internal
-         * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
+         * Patch all async methods to wait for queued operations,
+         * and methods that change the file system to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            const noPatch = ['read', 'readdir', 'stat', 'exists'];
-            const toPatch = _asyncFSKeys.filter(key => !noPatch.includes(key));
-            for (const key of toPatch) {
+            const reads = ['read', 'readdir', 'stat', 'exists'];
+            for (const key of _asyncFSKeys) {
                 // 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) {
+                    if (this._pending && !isReplay())
+                        await this._promise.catch(() => { });
                     const result = await originalMethod(...args);
-                    if (isInLoop(2))
+                    if (reads.includes(key) || isInLoop(key))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -287,15 +301,18 @@ 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`);
+            debug(`Async: patched ${_asyncFSKeys.length} methods`);
         }
     }
     return AsyncFS;

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;
@@ -783,130 +780,33 @@ export async function readlink(path, options) {
 }
 readlink;
 export async function chown(path, uid, gid) {
-    const env_8 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_8, await open.call(this, path, 'r+'), true);
-        await handle.chown(uid, gid);
-    }
-    catch (e_8) {
-        env_8.error = e_8;
-        env_8.hasError = true;
-    }
-    finally {
-        const result_6 = __disposeResources(env_8);
-        if (result_6)
-            await result_6;
-    }
+    await _async.chown.call(this, path, uid, gid, false);
 }
 chown;
 export async function lchown(path, uid, gid) {
-    const env_9 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_9, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.chown(uid, gid);
-    }
-    catch (e_9) {
-        env_9.error = e_9;
-        env_9.hasError = true;
-    }
-    finally {
-        const result_7 = __disposeResources(env_9);
-        if (result_7)
-            await result_7;
-    }
+    await _async.chown.call(this, path, uid, gid, true);
 }
 lchown;
 export async function chmod(path, mode) {
-    const env_10 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_10, await open.call(this, path, 'r+').catch(rethrow({ syscall: 'chmod', path: normalizePath.call(this, path) })), true);
-        await handle.chmod(mode);
-    }
-    catch (e_10) {
-        env_10.error = e_10;
-        env_10.hasError = true;
-    }
-    finally {
-        const result_8 = __disposeResources(env_10);
-        if (result_8)
-            await result_8;
-    }
+    await _async.chmod.call(this, path, mode, false);
 }
 chmod;
 export async function lchmod(path, mode) {
-    const env_11 = { stack: [], error: void 0, hasError: false };
-    try {
-        mode = normalizeMode(mode);
-        const handle = __addDisposableResource(env_11, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.chmod(mode);
-    }
-    catch (e_11) {
-        env_11.error = e_11;
-        env_11.hasError = true;
-    }
-    finally {
-        const result_9 = __disposeResources(env_11);
-        if (result_9)
-            await result_9;
-    }
+    await _async.chmod.call(this, path, mode, true);
 }
 lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function utimes(path, atime, mtime) {
-    const env_12 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_12, await _async.open(this, path, {
-            flag: 'r+',
-            allowDirectory: true,
-        }), true);
-        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
-    }
-    catch (e_12) {
-        env_12.error = e_12;
-        env_12.hasError = true;
-    }
-    finally {
-        const result_10 = __disposeResources(env_12);
-        if (result_10)
-            await result_10;
-    }
+    await _async.utimes.call(this, path, atime, mtime, false);
 }
 utimes;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function lutimes(path, atime, mtime) {
-    const env_13 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_13, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
-    }
-    catch (e_13) {
-        env_13.error = e_13;
-        env_13.hasError = true;
-    }
-    finally {
-        const result_11 = __disposeResources(env_13);
-        if (result_11)
-            await result_11;
-    }
+    await _async.utimes.call(this, path, atime, mtime, true);
 }
 lutimes;
 export async function realpath(path, options) {
@@ -1079,8 +979,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 +1016,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;
@@ -457,60 +453,33 @@ export function readlinkSync(path, options) {
 }
 readlinkSync;
 export function chownSync(path, uid, gid) {
-    const env_7 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_7, _sync.open(this, path, { flag: 'r+', mode: constants.F_OK }), false);
-        handle.chownSync(uid, gid);
-    }
-    catch (e_7) {
-        env_7.error = e_7;
-        env_7.hasError = true;
-    }
-    finally {
-        __disposeResources(env_7);
-    }
+    _sync.chown.call(this, path, uid, gid);
 }
 chownSync;
 export function lchownSync(path, uid, gid) {
-    const fd = lopenSync.call(this, path, 'r+');
-    fchownSync.call(this, fd, uid, gid);
-    closeSync.call(this, fd);
+    _sync.chown.call(this, path, uid, gid, true);
 }
 lchownSync;
 export function chmodSync(path, mode) {
-    let fd;
-    try {
-        fd = openSync.call(this, path, 'r+');
-    }
-    catch (e) {
-        throw setUVMessage(Object.assign(e, { syscall: 'chmod', path: normalizePath.call(this, path) }));
-    }
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
+    _sync.chmod.call(this, path, mode);
 }
 chmodSync;
 export function lchmodSync(path, mode) {
-    const fd = lopenSync.call(this, path, 'r+');
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
+    _sync.chmod.call(this, path, mode, true);
 }
 lchmodSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function utimesSync(path, atime, mtime) {
-    const fd = openSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
+    _sync.utimes.call(this, path, atime, mtime);
 }
 utimesSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function lutimesSync(path, atime, mtime) {
-    const fd = lopenSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
+    _sync.utimes.call(this, path, atime, mtime, true);
 }
 lutimesSync;
 export function realpathSync(path, options) {
@@ -706,7 +675,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 */

package/dist/vfs/async.d.ts

@@ -1,4 +1,4 @@
-import type { PathLike } from 'node:fs';
+import type { Mode, PathLike, TimeLike } from 'node:fs';
 import type { V_Context } from '../internal/contexts.js';
 import type { MkdirOptions, OpenOptions, ReaddirOptions, ResolvedPath } from './shared.js';
 import { type ExceptionExtra } from 'kerium';
@@ -22,3 +22,6 @@ export declare function readdir(this: V_Context, path: PathLike, options?: Readd
 export declare function rename(this: V_Context, oldPath: PathLike, newPath: PathLike): Promise<void>;
 export declare function link(this: V_Context, target: PathLike, link: PathLike): Promise<void>;
 export declare function stat(this: V_Context, path: PathLike, lstat: boolean): Promise<InodeLike>;
+export declare function chmod(this: V_Context, path: PathLike, mode: Mode, noFollow?: boolean): Promise<void>;
+export declare function chown(this: V_Context, path: PathLike, uid: number, gid: number, noFollow?: boolean): Promise<void>;
+export declare function utimes(this: V_Context, path: PathLike, atime: TimeLike, mtime: TimeLike, noFollow?: boolean): Promise<void>;