@zenfs/core 1.11.3 → 2.0.0

package/dist/vfs/sync.js

@@ -50,24 +50,28 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { deleteFD, fromFD, SyncHandle, toFD } from './file.js';
+import { Stats } from './stats.js';
 import { Buffer } from 'buffer';
-import { credentials } from '../internal/credentials.js';
+import { decodeUTF8, encodeUTF8 } from 'utilium';
+import { defaultContext } from '../internal/contexts.js';
 import { Errno, ErrnoError } from '../internal/error.js';
-import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
-import { BigIntStats } from '../stats.js';
-import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { config } from './config.js';
+import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { dirname, join, parse, resolve } from '../path.js';
+import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse, resolve } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
+import * as flags from './flags.js';
+import { _statfs, fixError, resolveMount } from './shared.js';
+import { BigIntStats } from './stats.js';
 import { emitChange } from './watchers.js';
 export function renameSync(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
     const oldMount = resolveMount(oldPath, this);
     const newMount = resolveMount(newPath, this);
-    if (config.checkAccess && !statSync.call(this, dirname(oldPath)).hasAccess(constants.W_OK, this)) {
+    if (checkAccess && !statSync.call(this, dirname(oldPath)).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -108,10 +112,10 @@ export function statSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
         const stats = fs.statSync(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'stat');
         }
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -123,7 +127,10 @@ export function lstatSync(path, options) {
     const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = fs.statSync(resolved);
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
+            throw ErrnoError.With('EACCES', resolved, 'lstat');
+        }
+        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -138,7 +145,7 @@ export function truncateSync(path, len = 0) {
         if (len < 0) {
             throw new ErrnoError(Errno.EINVAL);
         }
-        file.truncateSync(len);
+        file.truncate(len);
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -153,7 +160,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !fs.statSync(resolved).hasAccess(constants.W_OK, this)) {
+        if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -164,20 +171,10 @@ export function unlinkSync(path) {
     }
 }
 unlinkSync;
-/**
- * Manually apply setuid/setgid.
- */
-function applySetId(file, uid, gid) {
-    if (file.fs.attributes.has('setid'))
-        return;
-    const parent = file.fs.statSync(dirname(file.path));
-    file.chownSync(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
-    parent.mode & constants.S_ISGID ? parent.gid : gid);
-}
 function _openSync(path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
+    const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     path = opt.preserveSymlinks ? path : realpathSync.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     let stats;
@@ -188,44 +185,49 @@ function _openSync(path, opt) {
         // nothing
     }
     if (!stats) {
-        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+        if (!(flag & constants.O_CREAT)) {
             throw ErrnoError.With('ENOENT', path, '_open');
         }
         // Create the file
         const parentStats = fs.statSync(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, this)) {
+        if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
             throw ErrnoError.With('EACCES', dirname(path), '_open');
         }
-        if (!parentStats.isDirectory()) {
+        if (!isDirectory(parentStats)) {
             throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
-        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
-        const file = fs.createFileSync(resolved, flag, mode, { uid, gid });
         if (!opt.allowDirectory && mode & constants.S_IFDIR)
             throw ErrnoError.With('EISDIR', path, '_open');
-        applySetId(file, uid, gid);
-        return file;
-    }
-    if (config.checkAccess && (!stats.hasAccess(mode, this) || !stats.hasAccess(flagToMode(flag), this))) {
+        if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
+            throw ErrnoError.With('EACCES', dirname(resolved), '_open');
+        }
+        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
+        const inode = fs.createFileSync(resolved, {
+            mode,
+            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
+            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
+        });
+        return new SyncHandle(this, path, fs, resolved, flag, inode);
+    }
+    if (checkAccess && (!hasAccess(this, stats, mode) || !hasAccess(this, stats, flags.toMode(flag)))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
-    if (isExclusive(flag)) {
+    if (flag & constants.O_EXCL)
         throw ErrnoError.With('EEXIST', path, '_open');
-    }
-    const file = fs.openFileSync(resolved, flag);
-    if (isTruncating(flag)) {
-        file.truncateSync(0);
-    }
+    const file = new SyncHandle(this, path, fs, resolved, flag, stats);
+    if (flag & constants.O_TRUNC)
+        file.truncate(0);
     if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
         throw ErrnoError.With('EISDIR', path, '_open');
     return file;
 }
 /**
  * Synchronous file open.
- * @see http://www.manpagez.com/man/2/open/
+ * @see https://nodejs.org/api/fs.html#fsopensyncpath-flags-mode
+ * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return file2fd(_openSync.call(this, path, { flag, mode }));
+    return toFD(_openSync.call(this, path, { flag, mode }));
 }
 openSync;
 /**
@@ -233,18 +235,15 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return file2fd(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
+    return toFD(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
 function _readFileSync(path, flag, preserveSymlinks) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
-        // Get file.
-        const file = __addDisposableResource(env_2, _openSync.call(this, path, { flag, mode: 0o644, preserveSymlinks }), false);
-        const stat = file.statSync();
-        // Allocate buffer.
-        const data = new Uint8Array(stat.size);
-        file.readSync(data, 0, stat.size, 0);
+        const file = __addDisposableResource(env_2, typeof path == 'number' ? fromFD(this, path) : _openSync.call(this, path.toString(), { flag, mode: 0o644, preserveSymlinks }), false);
+        const { size } = file.stat();
+        const data = new Uint8Array(size);
+        file.read(data, 0, size, 0);
         return data;
     }
     catch (e_2) {
@@ -257,11 +256,11 @@ function _readFileSync(path, flag, preserveSymlinks) {
 }
 export function readFileSync(path, _options = {}) {
     const options = normalizeOptions(_options, null, 'r', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isReadable(flag)) {
+    const flag = flags.parse(options.flag);
+    if (flag & constants.O_WRONLY) {
         throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading');
     }
-    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path, options.flag, false));
+    const data = Buffer.from(_readFileSync.call(this, path, options.flag, false));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -269,8 +268,8 @@ export function writeFileSync(path, data, _options = {}) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isWriteable(flag)) {
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR)) {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing');
         }
         if (typeof data != 'string' && !options.encoding) {
@@ -280,12 +279,14 @@ export function writeFileSync(path, data, _options = {}) {
         if (!encodedData) {
             throw new ErrnoError(Errno.EINVAL, 'Data not specified');
         }
-        const file = __addDisposableResource(env_3, _openSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), {
-            flag,
-            mode: options.mode,
-            preserveSymlinks: true,
-        }), false);
-        file.writeSync(encodedData, 0, encodedData.byteLength, 0);
+        const file = __addDisposableResource(env_3, typeof path == 'number'
+            ? fromFD(this, path)
+            : _openSync.call(this, path.toString(), {
+                flag,
+                mode: options.mode,
+                preserveSymlinks: true,
+            }), false);
+        file.write(encodedData, 0, encodedData.byteLength, 0);
         emitChange(this, 'change', path.toString());
     }
     catch (e_3) {
@@ -307,20 +308,20 @@ export function appendFileSync(filename, data, _options = {}) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'a+', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isAppendable(flag)) {
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_APPEND)) {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fd2file(filename).path : filename.toString(), {
+        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fromFD(this, filename).path : filename.toString(), {
             flag,
             mode: options.mode,
             preserveSymlinks: true,
         }), false);
-        file.writeSync(encodedData, 0, encodedData.byteLength);
+        file.write(encodedData, 0, encodedData.byteLength);
     }
     catch (e_4) {
         env_4.error = e_4;
@@ -332,13 +333,13 @@ export function appendFileSync(filename, data, _options = {}) {
 }
 appendFileSync;
 export function fstatSync(fd, options) {
-    const stats = fd2file(fd).statSync();
-    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+    const stats = fromFD(this, fd).stat();
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 fstatSync;
 export function closeSync(fd) {
-    fd2file(fd).closeSync();
-    fdMap.delete(fd);
+    fromFD(this, fd).close();
+    deleteFD(this, fd);
 }
 closeSync;
 export function ftruncateSync(fd, len = 0) {
@@ -346,15 +347,15 @@ export function ftruncateSync(fd, len = 0) {
     if (len < 0) {
         throw new ErrnoError(Errno.EINVAL);
     }
-    fd2file(fd).truncateSync(len);
+    fromFD(this, fd).truncate(len);
 }
 ftruncateSync;
 export function fsyncSync(fd) {
-    fd2file(fd).syncSync();
+    fromFD(this, fd).sync();
 }
 fsyncSync;
 export function fdatasyncSync(fd) {
-    fd2file(fd).datasyncSync();
+    fromFD(this, fd).datasync();
 }
 fdatasyncSync;
 export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
@@ -374,9 +375,9 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
         length = lenOrEnc;
         position = typeof pos === 'number' ? pos : null;
     }
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     position !== null && position !== void 0 ? position : (position = file.position);
-    const bytesWritten = file.writeSync(buffer, offset, length, position);
+    const bytesWritten = file.write(buffer, offset, length, position);
     emitChange(this, 'change', file.path);
     return bytesWritten;
 }
@@ -390,7 +391,7 @@ writeSync;
  * If position is null, data will be read from the current file position.
  */
 export function readSync(fd, buffer, options, length, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     const offset = typeof options == 'object' ? options.offset : options;
     if (typeof options == 'object') {
         length = options.length;
@@ -400,11 +401,11 @@ export function readSync(fd, buffer, options, length, position) {
     if (isNaN(position)) {
         position = file.position;
     }
-    return file.readSync(buffer, offset, length, position);
+    return file.read(buffer, offset, length, position);
 }
 readSync;
 export function fchownSync(fd, uid, gid) {
-    fd2file(fd).chownSync(uid, gid);
+    fromFD(this, fd).chown(uid, gid);
 }
 fchownSync;
 export function fchmodSync(fd, mode) {
@@ -412,14 +413,14 @@ export function fchmodSync(fd, mode) {
     if (numMode < 0) {
         throw new ErrnoError(Errno.EINVAL, `Invalid mode.`);
     }
-    fd2file(fd).chmodSync(numMode);
+    fromFD(this, fd).chmod(numMode);
 }
 fchmodSync;
 /**
  * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
 export function futimesSync(fd, atime, mtime) {
-    fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
+    fromFD(this, fd).utimes(normalizeTime(atime), normalizeTime(mtime));
 }
 futimesSync;
 export function rmdirSync(path) {
@@ -427,10 +428,10 @@ export function rmdirSync(path) {
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
         const stats = fs.statSync(resolved);
-        if (!stats.isDirectory()) {
+        if (!isDirectory(stats)) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
-        if (config.checkAccess && !stats.hasAccess(constants.W_OK, this)) {
+        if (checkAccess && !hasAccess(this, stats, constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         fs.rmdirSync(resolved);
@@ -443,19 +444,27 @@ export function rmdirSync(path) {
 rmdirSync;
 export function mkdirSync(path, options) {
     var _a, _b;
-    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
+    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options === null || options === void 0 ? void 0 : options.mode, 0o777);
     path = realpathSync.call(this, path);
     const { fs, path: resolved, root } = resolveMount(path, this);
     const errorPaths = { [resolved]: path };
+    const __create = (path, parent) => {
+        if (checkAccess && !hasAccess(this, parent, constants.W_OK)) {
+            throw ErrnoError.With('EACCES', dirname(path), 'mkdir');
+        }
+        const inode = fs.mkdirSync(path, {
+            mode,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
+        emitChange(this, 'rename', path);
+        return inode;
+    };
     try {
         if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
-            if (config.checkAccess && !fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
-            }
-            fs.mkdirSync(resolved, mode, { uid, gid });
-            applySetId(fs.openFileSync(resolved, 'r+'), uid, gid);
+            __create(resolved, fs.statSync(dirname(resolved)));
             return;
         }
         const dirs = [];
@@ -463,13 +472,11 @@ export function mkdirSync(path, options) {
             dirs.unshift(dir);
             errorPaths[dir] = original;
         }
-        for (const dir of dirs) {
-            if (config.checkAccess && !fs.statSync(dirname(dir)).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
-            }
-            fs.mkdirSync(dir, mode, { uid, gid });
-            applySetId(fs.openFileSync(dir, 'r+'), uid, gid);
-            emitChange(this, 'rename', dir);
+        if (!dirs.length)
+            return;
+        const stats = [fs.statSync(dirname(dirs[0]))];
+        for (const [i, dir] of dirs.entries()) {
+            stats.push(__create(dir, stats[i]));
         }
         return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
     }
@@ -485,10 +492,10 @@ export function readdirSync(path, options) {
     let entries;
     try {
         const stats = fs.statSync(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
-        if (!stats.isDirectory()) {
+        if (!isDirectory(stats)) {
             throw ErrnoError.With('ENOTDIR', resolved, 'readdir');
         }
         entries = fs.readdirSync(resolved);
@@ -515,7 +522,7 @@ export function readdirSync(path, options) {
         else {
             values.push(entry);
         }
-        if (!entryStat.isDirectory() || !(options === null || options === void 0 ? void 0 : options.recursive))
+        if (!isDirectory(entryStat) || !(options === null || options === void 0 ? void 0 : options.recursive))
             continue;
         for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
@@ -535,11 +542,11 @@ export function readdirSync(path, options) {
 readdirSync;
 export function linkSync(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (config.checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
+    if (checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
         throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
     }
     linkPath = normalizePath(linkPath);
-    if (config.checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
+    if (checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
     }
     const { fs, path } = resolveMount(targetPath, this);
@@ -548,7 +555,7 @@ export function linkSync(targetPath, linkPath) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (config.checkAccess && !fs.statSync(path).hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, fs.statSync(path), constants.R_OK)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return fs.linkSync(path, link.path);
@@ -565,15 +572,23 @@ linkSync;
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export function symlinkSync(target, path, type = 'file') {
-    if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        if (!['file', 'dir', 'junction'].includes(type)) {
+            throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
+        }
+        path = normalizePath(path);
+        const file = __addDisposableResource(env_5, _openSync.call(this, path, { flag: 'wx', mode: 0o644 }), false);
+        file.write(encodeUTF8(normalizePath(target, true)));
+        file.chmod(constants.S_IFLNK);
     }
-    if (existsSync.call(this, path)) {
-        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
     }
-    writeFileSync.call(this, path, normalizePath(target, true));
-    const file = _openSync.call(this, path, { flag: 'r+', mode: 0o644, preserveSymlinks: true });
-    file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
@@ -588,26 +603,26 @@ export function readlinkSync(path, options) {
 readlinkSync;
 export function chownSync(path, uid, gid) {
     const fd = openSync.call(this, path, 'r+');
-    fchownSync(fd, uid, gid);
-    closeSync(fd);
+    fchownSync.call(this, fd, uid, gid);
+    closeSync.call(this, fd);
 }
 chownSync;
 export function lchownSync(path, uid, gid) {
     const fd = lopenSync.call(this, path, 'r+');
-    fchownSync(fd, uid, gid);
-    closeSync(fd);
+    fchownSync.call(this, fd, uid, gid);
+    closeSync.call(this, fd);
 }
 lchownSync;
 export function chmodSync(path, mode) {
     const fd = openSync.call(this, path, 'r+');
-    fchmodSync(fd, mode);
-    closeSync(fd);
+    fchmodSync.call(this, fd, mode);
+    closeSync.call(this, fd);
 }
 chmodSync;
 export function lchmodSync(path, mode) {
     const fd = lopenSync.call(this, path, 'r+');
-    fchmodSync(fd, mode);
-    closeSync(fd);
+    fchmodSync.call(this, fd, mode);
+    closeSync.call(this, fd);
 }
 lchmodSync;
 /**
@@ -615,8 +630,8 @@ lchmodSync;
  */
 export function utimesSync(path, atime, mtime) {
     const fd = openSync.call(this, path, 'r+');
-    futimesSync(fd, atime, mtime);
-    closeSync(fd);
+    futimesSync.call(this, fd, atime, mtime);
+    closeSync.call(this, fd);
 }
 utimesSync;
 /**
@@ -624,8 +639,8 @@ utimesSync;
  */
 export function lutimesSync(path, atime, mtime) {
     const fd = lopenSync.call(this, path, 'r+');
-    futimesSync(fd, atime, mtime);
-    closeSync(fd);
+    futimesSync.call(this, fd, atime, mtime);
+    closeSync.call(this, fd);
 }
 lutimesSync;
 /**
@@ -645,10 +660,10 @@ function _resolveSync($, path, preserveSymlinks) {
         const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
         const stats = resolved.fs.statSync(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
         }
-        const target = resolve(dirname(path), readlinkSync.call($, path).toString());
+        const target = resolve.call($, dirname(path), readlinkSync.call($, path).toString());
         return _resolveSync($, target);
     }
     catch {
@@ -660,10 +675,10 @@ function _resolveSync($, path, preserveSymlinks) {
     const resolved = resolveMount(maybePath, $);
     try {
         const stats = resolved.fs.statSync(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, readlinkSync.call($, maybePath).toString());
+        const target = resolve.call($, realDir, readlinkSync.call($, maybePath).toString());
         return _resolveSync($, target);
     }
     catch (e) {
@@ -687,9 +702,9 @@ export function realpathSync(path, options) {
 }
 realpathSync;
 export function accessSync(path, mode = 0o600) {
-    if (!config.checkAccess)
+    if (!checkAccess)
         return;
-    if (!statSync.call(this, path).hasAccess(mode, this)) {
+    if (!hasAccess(this, statSync.call(this, path), mode)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -763,10 +778,10 @@ copyFileSync;
  * @returns The number of bytes read.
  */
 export function readvSync(fd, buffers, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     let bytesRead = 0;
     for (const buffer of buffers) {
-        bytesRead += file.readSync(buffer, 0, buffer.byteLength, position + bytesRead);
+        bytesRead += file.read(buffer, 0, buffer.byteLength, position + bytesRead);
     }
     return bytesRead;
 }
@@ -779,10 +794,10 @@ readvSync;
  * @returns The number of bytes written.
  */
 export function writevSync(fd, buffers, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     let bytesWritten = 0;
     for (const buffer of buffers) {
-        bytesWritten += file.writeSync(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
+        bytesWritten += file.write(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
     }
     return bytesWritten;
 }

package/dist/vfs/watchers.d.ts

@@ -2,7 +2,7 @@ import type { EventEmitter as NodeEventEmitter } from 'node:events';
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import { EventEmitter } from 'eventemitter3';
-import { type Stats } from '../stats.js';
+import { type Stats } from './stats.js';
 /**
  * Base class for file system watchers.
  * Provides event handling capabilities for watching file system changes.
@@ -75,5 +75,5 @@ export declare function removeWatcher(path: string, watcher: FSWatcher): void;
 /**
  * @internal @hidden
  */
-export declare function emitChange(context: V_Context, eventType: fs.WatchEventType, filename: string): void;
+export declare function emitChange($: V_Context, eventType: fs.WatchEventType, filename: string): void;
 export {};

package/dist/vfs/watchers.js

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'eventemitter3';
 import { ErrnoError } from '../internal/error.js';
-import { isStatsEqual } from '../stats.js';
+import { isStatsEqual } from './stats.js';
 import { normalizePath } from '../utils.js';
-import { basename, dirname, join, relative } from './path.js';
+import { basename, dirname, join, relative } from '../path.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -138,10 +138,10 @@ export function removeWatcher(path, watcher) {
 /**
  * @internal @hidden
  */
-export function emitChange(context, eventType, filename) {
+export function emitChange($, eventType, filename) {
     var _a;
-    if (context)
-        filename = join((_a = context.root) !== null && _a !== void 0 ? _a : '/', filename);
+    if ($)
+        filename = join((_a = $.root) !== null && _a !== void 0 ? _a : '/', filename);
     filename = normalizePath(filename);
     // Notify watchers, including ones on parent directories if they are watching recursively
     for (let path = filename; path != '/'; path = dirname(path)) {
@@ -149,7 +149,7 @@ export function emitChange(context, eventType, filename) {
         if (!watchersForPath)
             continue;
         for (const watcher of watchersForPath) {
-            watcher.emit('change', eventType, relative(path, filename) || basename(filename));
+            watcher.emit('change', eventType, relative.call(watcher._context, path, filename) || basename(filename));
         }
     }
 }