@zenfs/core 1.3.6 → 1.4.0

package/dist/emulation/promises.js

@@ -62,7 +62,8 @@ import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
 export class FileHandle {
-    constructor(fdOrFile) {
+    constructor(fdOrFile, context) {
+        this.context = context;
         const isFile = typeof fdOrFile != 'number';
         this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
         this.file = isFile ? fdOrFile : fd2file(fdOrFile);
@@ -219,7 +220,7 @@ export class FileHandle {
     }
     async stat(opts) {
         const stats = await this.file.stat();
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this.context)) {
             throw ErrnoError.With('EACCES', this.file.path, 'stat');
         }
         return opts?.bigint ? new BigIntStats(stats) : stats;
@@ -351,9 +352,9 @@ export class FileHandle {
 export async function rename(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const src = resolveMount(oldPath);
-    const dst = resolveMount(newPath);
-    if (config.checkAccess && !(await stat(dirname(oldPath))).hasAccess(constants.W_OK)) {
+    const src = resolveMount(oldPath, this);
+    const dst = resolveMount(newPath, this);
+    if (config.checkAccess && !(await stat.call(this, dirname(oldPath))).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -363,8 +364,8 @@ export async function rename(oldPath, newPath) {
             emitChange('change', newPath.toString());
             return;
         }
-        await writeFile(newPath, await readFile(oldPath));
-        await unlink(oldPath);
+        await writeFile.call(this, newPath, await readFile(oldPath));
+        await unlink.call(this, oldPath);
         emitChange('rename', oldPath.toString());
     }
     catch (e) {
@@ -377,7 +378,7 @@ rename;
  */
 export async function exists(path) {
     try {
-        const { fs, path: resolved } = resolveMount(await realpath(path));
+        const { fs, path: resolved } = resolveMount(await realpath.call(this, path), this);
         return await fs.exists(resolved);
     }
     catch (e) {
@@ -389,10 +390,10 @@ export async function exists(path) {
 }
 export async function stat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(await realpath(path));
+    const { fs, path: resolved } = resolveMount(await realpath.call(this, path), this);
     try {
         const stats = await fs.stat(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;
@@ -404,7 +405,7 @@ export async function stat(path, options) {
 stat;
 export async function lstat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = await fs.stat(resolved);
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -418,7 +419,7 @@ lstat;
 export async function truncate(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_1, await open(path, 'r+'), true);
+        const handle = __addDisposableResource(env_1, await open.call(this, path, 'r+'), true);
         await handle.truncate(len);
     }
     catch (e_1) {
@@ -434,9 +435,9 @@ export async function truncate(path, len = 0) {
 truncate;
 export async function unlink(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(await (cache.stats.getAsync(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.stats.getAsync(path) || fs.stat(resolved))).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -454,8 +455,8 @@ unlink;
 async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks ? await realpath(path) : path;
-    const { fs, path: resolved } = resolveMount(path);
+    path = resolveSymlinks ? await realpath.call(this, path) : path;
+    const { fs, path: resolved } = resolveMount(path, this);
     const stats = await fs.stat(resolved).catch(() => null);
     if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
@@ -463,21 +464,21 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
         }
         // Create the file
         const parentStats = await fs.stat(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()) {
             throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
-        return new FileHandle(await fs.createFile(resolved, flag, mode));
+        return new FileHandle(await fs.createFile(resolved, flag, mode), this);
     }
-    if (config.checkAccess && !stats.hasAccess(flagToMode(flag))) {
+    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), this)) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
         throw ErrnoError.With('EEXIST', path, '_open');
     }
-    const handle = new FileHandle(await fs.openFile(resolved, flag));
+    const handle = new FileHandle(await fs.openFile(resolved, flag), this);
     /*
         In a previous implementation, we deleted the file and
         re-created it. However, this created a race condition if another
@@ -496,14 +497,14 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
-    return await _open(path, flag, mode, true);
+    return await _open.call(this, path, flag, mode, true);
 }
 open;
 export async function readFile(path, _options) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, null, 'r', 0o644);
-        const handle = __addDisposableResource(env_2, typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_2, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         return await handle.readFile(options);
     }
     catch (e_2) {
@@ -529,7 +530,7 @@ export async function writeFile(path, data, _options) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-        const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
         const _data = typeof data == 'string' ? data : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
             throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
@@ -565,7 +566,7 @@ export async function appendFile(path, 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 handle = __addDisposableResource(env_4, typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_4, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         await handle.appendFile(encodedData, options);
     }
     catch (e_4) {
@@ -581,8 +582,8 @@ export async function appendFile(path, data, _options) {
 appendFile;
 // DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
-    path = await realpath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    path = await realpath.call(this, path);
+    const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = await (cache.stats.getAsync(path) || fs.stat(resolved));
         if (!stats) {
@@ -591,7 +592,7 @@ export async function rmdir(path) {
         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');
         }
         await fs.rmdir(resolved);
@@ -605,12 +606,12 @@ rmdir;
 export async function mkdir(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = await realpath(path);
-    const { fs, path: resolved } = resolveMount(path);
+    path = await realpath.call(this, path);
+    const { fs, path: resolved, root } = resolveMount(path, this);
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            if (config.checkAccess && !(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, this)) {
                 throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
             }
             await fs.mkdir(resolved, mode);
@@ -623,13 +624,13 @@ export async function mkdir(path, options) {
             errorPaths[dir] = origDir;
         }
         for (const dir of dirs) {
-            if (config.checkAccess && !(await fs.stat(dirname(dir))).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, this)) {
                 throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
             }
             await fs.mkdir(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);
@@ -638,18 +639,18 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
-    path = await realpath(path);
+    path = await realpath.call(this, path);
     const handleError = (e) => {
         throw fixError(e, { [resolved]: path });
     };
-    const { fs, path: resolved } = resolveMount(path);
+    const { fs, path: resolved } = resolveMount(path, this);
     const _stats = cache.stats.getAsync(path) || fs.stat(resolved).catch(handleError);
     cache.stats.setAsync(path, _stats);
     const stats = await _stats;
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
     }
-    if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
+    if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
     if (!stats.isDirectory()) {
@@ -675,7 +676,7 @@ export async function readdir(path, options) {
         }
         if (!options?.recursive || !entryStats?.isDirectory())
             return;
-        for (const subEntry of await readdir(join(path, entry), { ...options, _isIndirect: true })) {
+        for (const subEntry of await readdir.call(this, join(path, entry), { ...options, _isIndirect: true })) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -699,19 +700,19 @@ readdir;
 export async function link(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
     linkPath = normalizePath(linkPath);
-    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 && !(await fs.stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !(await fs.stat(dirname(targetPath))).hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', dirname(path), 'link');
         }
-        if (config.checkAccess && !(await stat(dirname(linkPath))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await stat.call(this, dirname(linkPath))).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
         }
-        if (config.checkAccess && !(await fs.stat(path)).hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !(await fs.stat(path)).hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return await fs.link(path, link.path);
@@ -733,10 +734,10 @@ export async function symlink(target, path, type = 'file') {
         if (!['file', 'dir', 'junction'].includes(type)) {
             throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
         }
-        if (await exists(path)) {
+        if (await exists.call(this, path)) {
             throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
         }
-        const handle = __addDisposableResource(env_5, await _open(path, 'w+', 0o644, false), true);
+        const handle = __addDisposableResource(env_5, await _open.call(this, path, 'w+', 0o644, false), true);
         await handle.writeFile(target.toString());
         await handle.file.chmod(constants.S_IFLNK);
     }
@@ -754,7 +755,7 @@ symlink;
 export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await _open(normalizePath(path), 'r', 0o644, false), true);
+        const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), 'r', 0o644, false), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options?.encoding : options;
         return encoding == 'buffer' ? value : value.toString(encoding);
@@ -770,11 +771,10 @@ export async function readlink(path, options) {
     }
 }
 readlink;
-// PROPERTY OPERATIONS
 export async function chown(path, uid, gid) {
     const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, await open(path, 'r+'), true);
+        const handle = __addDisposableResource(env_7, await open.call(this, path, 'r+'), true);
         await handle.chown(uid, gid);
     }
     catch (e_7) {
@@ -791,7 +791,7 @@ chown;
 export async function lchown(path, uid, gid) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await _open(path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_8, await _open.call(this, path, 'r+', 0o644, false), true);
         await handle.chown(uid, gid);
     }
     catch (e_8) {
@@ -808,7 +808,7 @@ lchown;
 export async function chmod(path, mode) {
     const env_9 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_9, await open(path, 'r+'), true);
+        const handle = __addDisposableResource(env_9, await open.call(this, path, 'r+'), true);
         await handle.chmod(mode);
     }
     catch (e_9) {
@@ -825,7 +825,7 @@ chmod;
 export async function lchmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _open(path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_10, await _open.call(this, path, 'r+', 0o644, false), true);
         await handle.chmod(mode);
     }
     catch (e_10) {
@@ -845,7 +845,7 @@ lchmod;
 export async function utimes(path, atime, mtime) {
     const env_11 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_11, await open(path, 'r+'), true);
+        const handle = __addDisposableResource(env_11, await open.call(this, path, 'r+'), true);
         await handle.utimes(atime, mtime);
     }
     catch (e_11) {
@@ -865,7 +865,7 @@ utimes;
 export async function lutimes(path, atime, mtime) {
     const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_12, await _open(path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_12, await _open.call(this, path, 'r+', 0o644, false), true);
         await handle.utimes(new Date(atime), new Date(mtime));
     }
     catch (e_12) {
@@ -881,12 +881,13 @@ export async function lutimes(path, atime, mtime) {
 lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);
-    if (cache.paths.hasAsync(path))
-        return cache.paths.getAsync(path);
+    const ctx_path = (this?.root || '') + path;
+    if (cache.paths.hasAsync(ctx_path))
+        return cache.paths.getAsync(ctx_path);
     const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : await (cache.paths.getAsync(dir) || realpath(dir));
+    const realDir = dir == '/' ? '/' : await (cache.paths.getAsync((this?.root || '') + dir) || realpath.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.getAsync(lpath) || fs.stat(resolvedPath);
         cache.stats.setAsync(lpath, _stats);
@@ -894,9 +895,9 @@ export async function realpath(path, options) {
             cache.paths.set(path, lpath);
             return lpath;
         }
-        const target = resolve(realDir, await readlink(lpath));
-        const real = cache.paths.getAsync(target) || realpath(target);
-        cache.paths.setAsync(path, real);
+        const target = resolve(realDir, (await readlink.call(this, lpath)).toString());
+        const real = cache.paths.getAsync((this?.root || '') + target) || realpath.call(this, target);
+        cache.paths.setAsync(ctx_path, real);
         return await real;
     }
     catch (e) {
@@ -940,8 +941,8 @@ watch;
 export async function access(path, mode = constants.F_OK) {
     if (!config.checkAccess)
         return;
-    const stats = await stat(path);
-    if (!stats.hasAccess(mode)) {
+    const stats = await stat.call(this, path);
+    if (!stats.hasAccess(mode, this)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -953,7 +954,7 @@ access;
 export async function rm(path, options) {
     path = normalizePath(path);
     const stats = await (cache.stats.getAsync(path) ||
-        stat(path).catch((error) => {
+        lstat.call(this, path).catch((error) => {
             if (error.code == 'ENOENT' && options?.force)
                 return undefined;
             throw error;
@@ -965,17 +966,17 @@ export async function rm(path, options) {
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
-                for (const entry of await readdir(path, { _isIndirect: true })) {
-                    await rm(join(path, entry), { ...options, _isIndirect: true });
+                for (const entry of await readdir.call(this, path, { _isIndirect: true })) {
+                    await rm.call(this, join(path, entry), { ...options, _isIndirect: true });
                 }
             }
-            await rmdir(path);
+            await rmdir.call(this, path);
             break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
         case constants.S_IFBLK:
         case constants.S_IFCHR:
-            await unlink(path);
+            await unlink.call(this, path);
             break;
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
@@ -992,7 +993,7 @@ export async function mkdtemp(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;
-    await mkdir(resolvedPath);
+    await mkdir.call(this, resolvedPath);
     return encoding == 'buffer' ? Buffer.from(resolvedPath) : resolvedPath;
 }
 mkdtemp;
@@ -1006,10 +1007,10 @@ mkdtemp;
 export async function copyFile(src, dest, mode) {
     src = normalizePath(src);
     dest = normalizePath(dest);
-    if (mode && mode & constants.COPYFILE_EXCL && (await exists(dest))) {
+    if (mode && mode & constants.COPYFILE_EXCL && (await exists.call(this, dest))) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
-    await writeFile(dest, await readFile(src));
+    await writeFile.call(this, dest, await readFile.call(this, src));
     emitChange('rename', dest.toString());
 }
 copyFile;
@@ -1022,7 +1023,7 @@ copyFile;
  */
 export function opendir(path, options) {
     path = normalizePath(path);
-    return Promise.resolve(new Dir(path));
+    return Promise.resolve(new Dir(path, this));
 }
 opendir;
 /**
@@ -1040,8 +1041,8 @@ opendir;
 export async function cp(source, destination, opts) {
     source = normalizePath(source);
     destination = normalizePath(destination);
-    const srcStats = await lstat(source); // Use lstat to follow symlinks if not dereferencing
-    if (opts?.errorOnExist && (await exists(destination))) {
+    const srcStats = await lstat.call(this, source); // Use lstat to follow symlinks if not dereferencing
+    if (opts?.errorOnExist && (await exists.call(this, destination))) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
@@ -1049,20 +1050,20 @@ export async function cp(source, destination, opts) {
             if (!opts?.recursive) {
                 throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
-            const [entries] = await Promise.all([readdir(source, { withFileTypes: true }), mkdir(destination, { recursive: true })] // Ensure the destination directory exists
+            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
                 }
-                await cp(join(source, dirent.name), join(destination, dirent.name), opts);
+                await cp.call(this, join(source, dirent.name), join(destination, dirent.name), opts);
             };
             await Promise.all(entries.map(_cp));
             break;
         }
         case constants.S_IFREG:
         case constants.S_IFLNK:
-            await copyFile(source, destination);
+            await copyFile.call(this, source, destination);
             break;
         case constants.S_IFBLK:
         case constants.S_IFCHR:
@@ -1073,12 +1074,12 @@ export async function cp(source, destination, opts) {
     }
     // Optionally preserve timestamps
     if (opts?.preserveTimestamps) {
-        await utimes(destination, srcStats.atime, srcStats.mtime);
+        await utimes.call(this, destination, srcStats.atime, srcStats.mtime);
     }
 }
 cp;
-export function statfs(path, opts) {
+export async function statfs(path, opts) {
     path = normalizePath(path);
-    const { fs } = resolveMount(path);
+    const { fs } = resolveMount(path, this);
     return Promise.resolve(_statfs(fs, opts?.bigint));
 }

package/dist/emulation/shared.d.ts

@@ -1,11 +1,24 @@
 import type { BigIntStatsFs, StatsFs } from 'node:fs';
+import { type BoundContext, type V_Context } from '../context.js';
 import { ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
+/**
+ * @internal @hidden
+ */
 export declare const fdMap: Map<number, File>;
+/**
+ * @internal @hidden
+ */
 export declare function file2fd(file: File): number;
+/**
+ * @internal @hidden
+ */
 export declare function fd2file(fd: number): File;
+/**
+ * @internal @hidden
+ */
 export type MountObject = Record<AbsolutePath, FileSystem>;
 /**
  * The map of mount points
@@ -14,6 +27,7 @@ export type MountObject = Record<AbsolutePath, FileSystem>;
 export declare const mounts: Map<string, FileSystem>;
 /**
  * Mounts the file system at `mountPoint`.
+ * @internal
  */
 export declare function mount(mountPoint: string, fs: FileSystem): void;
 /**
@@ -21,13 +35,19 @@ export declare function mount(mountPoint: string, fs: FileSystem): void;
  */
 export declare function umount(mountPoint: string): void;
 /**
- * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
+ * @internal @hidden
  */
-export declare function resolveMount(path: string): {
+export interface ResolvedMount {
     fs: FileSystem;
     path: string;
     mountPoint: string;
-};
+    root: string;
+}
+/**
+ * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
+ * @internal @hidden
+ */
+export declare function resolveMount(path: string, ctx: V_Context): ResolvedMount;
 /**
  * Wait for all file systems to be ready and synced.
  * May be removed at some point.
@@ -36,25 +56,25 @@ export declare function resolveMount(path: string): {
 export declare function _synced(): Promise<void>;
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
- * @hidden
+ * @internal @hidden
  */
 export declare function fixPaths(text: string, paths: Record<string, string>): string;
 /**
  * Fix paths in error stacks
- * @hidden
+ * @internal @hidden
  */
 export declare function fixError<E extends ErrnoError>(e: E, paths: Record<string, string>): E;
 /**
- * @deprecated
+ * @internal @deprecated
  */
 export declare function mountObject(mounts: MountObject): void;
 /**
- * @hidden
+ * @internal @hidden
  */
 export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;
 /**
  * Options used for caching, among other things.
- * @internal *UNSTABLE*
+ * @internal @hidden *UNSTABLE*
  */
 export interface InternalOptions {
     /**
@@ -68,3 +88,10 @@ export interface ReaddirOptions extends InternalOptions {
     withFileTypes?: boolean;
     recursive?: boolean;
 }
+/**
+ * Change the root path
+ * @param inPlace if true, this changes the root for the current context instead of creating a new one (if associated with a context).
+ * @experimental
+ */
+export declare function chroot(this: V_Context, path: string, inPlace?: false): BoundContext;
+export declare function chroot<T extends V_Context>(this: T, path: string, inPlace: true): T;