@zenfs/core 1.3.6 → 1.4.0

package/dist/emulation/sync.js

@@ -60,9 +60,9 @@ import { emitChange } from './watchers.js';
 export function renameSync(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const oldMount = resolveMount(oldPath);
-    const newMount = resolveMount(newPath);
-    if (config.checkAccess && !statSync(dirname(oldPath)).hasAccess(constants.W_OK)) {
+    const oldMount = resolveMount(oldPath, this);
+    const newMount = resolveMount(newPath, this);
+    if (config.checkAccess && !statSync.call(this, dirname(oldPath)).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -72,8 +72,8 @@ export function renameSync(oldPath, newPath) {
             emitChange('change', newPath.toString());
             return;
         }
-        writeFileSync(newPath, readFileSync(oldPath));
-        unlinkSync(oldPath);
+        writeFileSync.call(this, newPath, readFileSync(oldPath));
+        unlinkSync.call(this, oldPath);
         emitChange('rename', oldPath.toString());
     }
     catch (e) {
@@ -87,7 +87,7 @@ renameSync;
 export function existsSync(path) {
     path = normalizePath(path);
     try {
-        const { fs, path: resolvedPath } = resolveMount(realpathSync(path));
+        const { fs, path: resolvedPath } = resolveMount(realpathSync.call(this, path), this);
         return fs.existsSync(resolvedPath);
     }
     catch (e) {
@@ -100,10 +100,10 @@ export function existsSync(path) {
 existsSync;
 export function statSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync(path));
+    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
         const stats = fs.statSync(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -115,7 +115,7 @@ export function statSync(path, options) {
 statSync;
 export function lstatSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = fs.statSync(resolved);
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -128,7 +128,7 @@ lstatSync;
 export function truncateSync(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const file = __addDisposableResource(env_1, _openSync(path, 'r+'), false);
+        const file = __addDisposableResource(env_1, _openSync.call(this, path, 'r+'), false);
         len || (len = 0);
         if (len < 0) {
             throw new ErrnoError(Errno.EINVAL);
@@ -146,9 +146,9 @@ export function truncateSync(path, len = 0) {
 truncateSync;
 export function unlinkSync(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -162,8 +162,8 @@ unlinkSync;
 function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks ? realpathSync(path) : path;
-    const { fs, path: resolved } = resolveMount(path);
+    path = resolveSymlinks ? realpathSync.call(this, path) : path;
+    const { fs, path: resolved } = resolveMount(path, this);
     let stats;
     try {
         stats = fs.statSync(resolved);
@@ -177,7 +177,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         // Create the file
         const parentStats = fs.statSync(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', dirname(path), '_open');
         }
         if (!parentStats.isDirectory()) {
@@ -185,7 +185,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         return fs.createFileSync(resolved, flag, mode);
     }
-    if (config.checkAccess && (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag)))) {
+    if (config.checkAccess && (!stats.hasAccess(mode, this) || !stats.hasAccess(flagToMode(flag), this))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
@@ -202,7 +202,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
  * @see http://www.manpagez.com/man/2/open/
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return file2fd(_openSync(path, flag, mode, true));
+    return file2fd(_openSync.call(this, path, flag, mode, true));
 }
 openSync;
 /**
@@ -210,13 +210,13 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return file2fd(_openSync(path, flag, mode, false));
+    return file2fd(_openSync.call(this, path, flag, mode, false));
 }
 function _readFileSync(fname, flag, resolveSymlinks) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         // Get file.
-        const file = __addDisposableResource(env_2, _openSync(fname, flag, 0o644, resolveSymlinks), false);
+        const file = __addDisposableResource(env_2, _openSync.call(this, fname, flag, 0o644, resolveSymlinks), false);
         const stat = file.statSync();
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
@@ -237,7 +237,7 @@ export function readFileSync(path, _options = {}) {
     if (!isReadable(flag)) {
         throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
+    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -256,7 +256,7 @@ export function writeFileSync(path, data, _options = {}) {
         if (!encodedData) {
             throw new ErrnoError(Errno.EINVAL, 'Data not specified');
         }
-        const file = __addDisposableResource(env_3, _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true), false);
+        const file = __addDisposableResource(env_3, _openSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
         emitChange('change', path.toString());
     }
@@ -287,7 +287,7 @@ export function appendFileSync(filename, data, _options = {}) {
             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(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true), false);
+        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true), false);
         file.writeSync(encodedData, 0, encodedData.byteLength);
     }
     catch (e_4) {
@@ -392,13 +392,13 @@ export function futimesSync(fd, atime, mtime) {
 futimesSync;
 export function rmdirSync(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync(path));
+    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     try {
         const stats = cache.stats.get(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
-        if (config.checkAccess && !stats.hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         fs.rmdirSync(resolved);
@@ -412,12 +412,12 @@ rmdirSync;
 export function mkdirSync(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = realpathSync(path);
-    const { fs, path: resolved } = resolveMount(path);
+    path = realpathSync.call(this, path);
+    const { fs, path: resolved, root } = resolveMount(path, this);
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            if (config.checkAccess && !fs.statSync(dirname(resolved)).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, this)) {
                 throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
             }
             return fs.mkdirSync(resolved, mode);
@@ -428,13 +428,13 @@ export function mkdirSync(path, options) {
             errorPaths[dir] = original;
         }
         for (const dir of dirs) {
-            if (config.checkAccess && !fs.statSync(dirname(dir)).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !fs.statSync(dirname(dir)).hasAccess(constants.W_OK, this)) {
                 throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
             }
             fs.mkdirSync(dir, mode);
             emitChange('rename', dir);
         }
-        return dirs[0];
+        return root.length == 1 ? dirs[0] : dirs[0]?.slice(root.length);
     }
     catch (e) {
         throw fixError(e, errorPaths);
@@ -444,12 +444,12 @@ mkdirSync;
 export function readdirSync(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync(path));
+    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
     let entries;
     try {
         const stats = cache.stats.get(path) || fs.statSync(resolved);
         cache.stats.set(path, stats);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
         if (!stats.isDirectory()) {
@@ -476,7 +476,7 @@ export function readdirSync(path, options) {
         }
         if (!entryStat.isDirectory() || !options?.recursive)
             continue;
-        for (const subEntry of readdirSync(join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of readdirSync.call(this, join(path, entry), { ...options, _isIndirect: true })) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -495,23 +495,22 @@ export function readdirSync(path, options) {
     return values;
 }
 readdirSync;
-// SYMLINK METHODS
 export function linkSync(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (config.checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK)) {
+    if (config.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)) {
+    if (config.checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
     }
-    const { fs, path } = resolveMount(targetPath);
-    const link = resolveMount(linkPath);
+    const { fs, path } = resolveMount(targetPath, this);
+    const link = resolveMount(linkPath, this);
     if (fs != link.fs) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (config.checkAccess && !fs.statSync(path).hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !fs.statSync(path).hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return fs.linkSync(path, linkPath);
@@ -531,16 +530,16 @@ export function symlinkSync(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
         throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
     }
-    if (existsSync(path)) {
+    if (existsSync.call(this, path)) {
         throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
-    writeFileSync(path, target.toString());
-    const file = _openSync(path, 'r+', 0o644, false);
+    writeFileSync.call(this, path, target.toString());
+    const file = _openSync.call(this, path, 'r+', 0o644, false);
     file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync(path.toString(), 'r', false));
+    const value = Buffer.from(_readFileSync.call(this, path.toString(), 'r', false));
     const encoding = typeof options == 'object' ? options?.encoding : options;
     if (encoding == 'buffer') {
         return value;
@@ -548,27 +547,26 @@ export function readlinkSync(path, options) {
     return value.toString(encoding);
 }
 readlinkSync;
-// PROPERTY OPERATIONS
 export function chownSync(path, uid, gid) {
-    const fd = openSync(path, 'r+');
+    const fd = openSync.call(this, path, 'r+');
     fchownSync(fd, uid, gid);
     closeSync(fd);
 }
 chownSync;
 export function lchownSync(path, uid, gid) {
-    const fd = lopenSync(path, 'r+');
+    const fd = lopenSync.call(this, path, 'r+');
     fchownSync(fd, uid, gid);
     closeSync(fd);
 }
 lchownSync;
 export function chmodSync(path, mode) {
-    const fd = openSync(path, 'r+');
+    const fd = openSync.call(this, path, 'r+');
     fchmodSync(fd, mode);
     closeSync(fd);
 }
 chmodSync;
 export function lchmodSync(path, mode) {
-    const fd = lopenSync(path, 'r+');
+    const fd = lopenSync.call(this, path, 'r+');
     fchmodSync(fd, mode);
     closeSync(fd);
 }
@@ -577,7 +575,7 @@ lchmodSync;
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function utimesSync(path, atime, mtime) {
-    const fd = openSync(path, 'r+');
+    const fd = openSync.call(this, path, 'r+');
     futimesSync(fd, atime, mtime);
     closeSync(fd);
 }
@@ -586,19 +584,20 @@ utimesSync;
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function lutimesSync(path, atime, mtime) {
-    const fd = lopenSync(path, 'r+');
+    const fd = lopenSync.call(this, path, 'r+');
     futimesSync(fd, atime, mtime);
     closeSync(fd);
 }
 lutimesSync;
 export function realpathSync(path, options) {
     path = normalizePath(path);
-    if (cache.paths.has(path))
-        return cache.paths.get(path);
+    const ctx_path = (this?.root || '') + path;
+    if (cache.paths.has(ctx_path))
+        return cache.paths.get(ctx_path);
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : cache.paths.get(dir) || realpathSync(dir);
+    const realDir = dir == '/' ? '/' : cache.paths.get((this?.root || '') + dir) || realpathSync.call(this, dir);
     const lpath = join(realDir, base);
-    const { fs, path: resolvedPath } = resolveMount(lpath);
+    const { fs, path: resolvedPath } = resolveMount(lpath, this);
     try {
         const stats = cache.stats.get(lpath) || fs.statSync(resolvedPath);
         cache.stats.set(lpath, stats);
@@ -606,9 +605,9 @@ export function realpathSync(path, options) {
             cache.paths.set(path, lpath);
             return lpath;
         }
-        const target = resolve(realDir, readlinkSync(lpath, options).toString());
-        const real = cache.paths.get(target) || realpathSync(target);
-        cache.paths.set(path, real);
+        const target = resolve(realDir, readlinkSync.call(this, lpath, options).toString());
+        const real = cache.paths.get((this?.root || '') + target) || realpathSync.call(this, target);
+        cache.paths.set(ctx_path, real);
         return real;
     }
     catch (e) {
@@ -622,7 +621,7 @@ realpathSync;
 export function accessSync(path, mode = 0o600) {
     if (!config.checkAccess)
         return;
-    if (!statSync(path).hasAccess(mode)) {
+    if (!statSync.call(this, path).hasAccess(mode, this)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -635,7 +634,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.stats.get(path) || statSync(path);
+        stats = cache.stats.get(path) || lstatSync.bind(this)(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -648,17 +647,17 @@ export function rmSync(path, options) {
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
-                for (const entry of readdirSync(path, { _isIndirect: true })) {
-                    rmSync(join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of readdirSync.call(this, path, { _isIndirect: true })) {
+                    rmSync.call(this, join(path, entry), { ...options, _isIndirect: true });
                 }
             }
-            rmdirSync(path);
+            rmdirSync.call(this, path);
             break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
         case constants.S_IFBLK:
         case constants.S_IFCHR:
-            unlinkSync(path);
+            unlinkSync.call(this, path);
             break;
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
@@ -675,7 +674,7 @@ export function mkdtempSync(prefix, options) {
     const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
-    mkdirSync(resolvedPath);
+    mkdirSync.call(this, resolvedPath);
     return encoding == 'buffer' ? Buffer.from(resolvedPath) : resolvedPath;
 }
 mkdtempSync;
@@ -690,7 +689,7 @@ export function copyFileSync(source, destination, flags) {
     if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination)) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', destination, 'copyFile');
     }
-    writeFileSync(destination, readFileSync(source));
+    writeFileSync.call(this, destination, readFileSync(source));
     emitChange('rename', destination.toString());
 }
 copyFileSync;
@@ -735,7 +734,7 @@ writevSync;
  */
 export function opendirSync(path, options) {
     path = normalizePath(path);
-    return new Dir(path);
+    return new Dir(path, this);
 }
 opendirSync;
 /**
@@ -753,8 +752,8 @@ opendirSync;
 export function cpSync(source, destination, opts) {
     source = normalizePath(source);
     destination = normalizePath(destination);
-    const srcStats = lstatSync(source); // Use lstat to follow symlinks if not dereferencing
-    if (opts?.errorOnExist && existsSync(destination)) {
+    const srcStats = lstatSync.call(this, source); // Use lstat to follow symlinks if not dereferencing
+    if (opts?.errorOnExist && existsSync.call(this, destination)) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
@@ -762,17 +761,17 @@ export function cpSync(source, destination, opts) {
             if (!opts?.recursive) {
                 throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
-            mkdirSync(destination, { recursive: true }); // Ensure the destination directory exists
-            for (const dirent of readdirSync(source, { withFileTypes: true })) {
+            mkdirSync.call(this, destination, { recursive: true }); // Ensure the destination directory exists
+            for (const dirent of readdirSync.call(this, source, { withFileTypes: true })) {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
                     continue; // Skip if the filter returns false
                 }
-                cpSync(join(source, dirent.name), join(destination, dirent.name), opts);
+                cpSync.call(this, join(source, dirent.name), join(destination, dirent.name), opts);
             }
             break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
-            copyFileSync(source, destination);
+            copyFileSync.call(this, source, destination);
             break;
         case constants.S_IFBLK:
         case constants.S_IFCHR:
@@ -783,12 +782,12 @@ export function cpSync(source, destination, opts) {
     }
     // Optionally preserve timestamps
     if (opts?.preserveTimestamps) {
-        utimesSync(destination, srcStats.atime, srcStats.mtime);
+        utimesSync.call(this, destination, srcStats.atime, srcStats.mtime);
     }
 }
 cpSync;
 export function statfsSync(path, options) {
     path = normalizePath(path);
-    const { fs } = resolveMount(path);
+    const { fs } = resolveMount(path, this);
     return _statfs(fs, options?.bigint);
 }

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from './backends/store/simple.js';
 export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
+export * from './context.js';
 export * from './credentials.js';
 export * from './devices.js';
 export { default as devices } from './devices.js';

package/dist/index.js

@@ -9,6 +9,7 @@ export * from './backends/store/simple.js';
 export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
+export * from './context.js';
 export * from './credentials.js';
 export * from './devices.js';
 export { default as devices } from './devices.js';

package/dist/stats.d.ts

@@ -1,4 +1,5 @@
 import type * as Node from 'node:fs';
+import type { V_Context } from './context.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of a file. Applied to 'mode'.
@@ -138,7 +139,7 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * @returns True if the request has access, false if the request does not
      * @internal
      */
-    hasAccess(mode: number): boolean;
+    hasAccess(mode: number, context?: V_Context): boolean;
     /**
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.

package/dist/stats.js

@@ -108,12 +108,13 @@ export class StatsCommon {
      * @returns True if the request has access, false if the request does not
      * @internal
      */
-    hasAccess(mode) {
-        if (this.isSymbolicLink() || credentials.euid === 0 || credentials.egid === 0)
+    hasAccess(mode, context) {
+        const creds = context?.credentials || credentials;
+        if (this.isSymbolicLink() || creds.euid === 0 || creds.egid === 0)
             return true;
         let perm = 0;
         // Owner permissions
-        if (credentials.uid === this.uid) {
+        if (creds.uid === this.uid) {
             if (this.mode & S_IRUSR)
                 perm |= R_OK;
             if (this.mode & S_IWUSR)
@@ -122,7 +123,7 @@ export class StatsCommon {
                 perm |= X_OK;
         }
         // Group permissions
-        if (credentials.gid === this.gid || credentials.groups.includes(Number(this.gid))) {
+        if (creds.gid === this.gid || creds.groups.includes(Number(this.gid))) {
             if (this.mode & S_IRGRP)
                 perm |= R_OK;
             if (this.mode & S_IWGRP)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.3.6",
+	"version": "1.4.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -18,7 +18,6 @@
 		"zenfs-test": "scripts/test.js"
 	},
 	"files": [
-		"src",
 		"dist",
 		"tests",
 		"license.md",
@@ -49,14 +48,12 @@
 		"./mixins": "./dist/mixins/index.js",
 		"./path": "./dist/emulation/path.js",
 		"./eslint": "./eslint.shared.js",
-		"./tests/*": "./tests/*",
-		"./src/*": "./src/*"
+		"./tests/*": "./tests/*"
 	},
 	"scripts": {
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
-		"test:common": "tsx --test --experimental-test-coverage 'tests/**/!(fs)/*.test.ts' 'tests/*.test.ts'",
 		"test": "tsx --test --experimental-test-coverage",
 		"pretest": "npm run build",
 		"build": "tsc -p tsconfig.json",
@@ -83,6 +80,7 @@
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",
 		"@types/eslint__js": "^8.42.3",
+		"c8": "^10.1.2",
 		"eslint": "^9.8.0",
 		"globals": "^15.9.0",
 		"lint-staged": "^15.2.7",