@zenfs/core 1.3.6 → 1.4.1

package/dist/backends/file_index.d.ts

@@ -42,23 +42,7 @@ export declare class Index extends Map<string, Stats> {
      */
     static parse(data: string): Index;
 }
-declare const IndexFS_base: import("../index.js").Mixin<typeof FileSystem, {
-    metadata(): import("../filesystem.js").FileSystemMetadata;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    renameSync(oldPath: string, newPath: string): void;
-    createFile(path: string, flag: string, mode: number): Promise<import("../file.js").File>;
-    createFileSync(path: string, flag: string, mode: number): import("../file.js").File;
-    unlink(path: string): Promise<void>;
-    unlinkSync(path: string): void;
-    rmdir(path: string): Promise<void>;
-    rmdirSync(path: string): void;
-    mkdir(path: string, mode: number): Promise<void>;
-    mkdirSync(path: string, mode: number): void;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+declare const IndexFS_base: import("../index.js").Mixin<typeof FileSystem, import("../mixins/readonly.js").ReadonlyMixin>;
 export declare abstract class IndexFS extends IndexFS_base {
     private indexData;
     protected index: Index;

package/dist/backends/memory.d.ts

@@ -10,10 +10,6 @@ export declare class InMemoryStore extends Map<bigint, Uint8Array> implements Si
     clearSync(): void;
     transaction(): SimpleTransaction;
 }
-/**
- * A simple in-memory file system backed by an InMemoryStore.
- * Files are not persisted across page loads.
- */
 declare const _InMemory: {
     readonly name: "InMemory";
     readonly isAvailable: () => boolean;
@@ -30,5 +26,9 @@ declare const _InMemory: {
 type _InMemory = typeof _InMemory;
 export interface InMemory extends _InMemory {
 }
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
 export declare const InMemory: InMemory;
 export {};

package/dist/backends/memory.js

@@ -16,10 +16,6 @@ export class InMemoryStore extends Map {
         return new SimpleTransaction(this);
     }
 }
-/**
- * A simple in-memory file system backed by an InMemoryStore.
- * Files are not persisted across page loads.
- */
 const _InMemory = {
     name: 'InMemory',
     isAvailable() {
@@ -34,4 +30,8 @@ const _InMemory = {
         return fs;
     },
 };
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
 export const InMemory = _InMemory;

package/dist/backends/overlay.d.ts

@@ -109,12 +109,10 @@ declare const _Overlay: {
         readonly writable: {
             readonly type: "object";
             readonly required: true;
-            readonly description: "The file system to write modified files to.";
         };
         readonly readable: {
             readonly type: "object";
             readonly required: true;
-            readonly description: "The file system that initially populates this file system.";
         };
     };
     readonly isAvailable: () => boolean;
@@ -123,5 +121,10 @@ declare const _Overlay: {
 type _Overlay = typeof _Overlay;
 export interface Overlay extends _Overlay {
 }
+/**
+ * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
+ * @internal
+ */
 export declare const Overlay: Overlay;
 export {};

package/dist/backends/overlay.js

@@ -529,16 +529,8 @@ export class OverlayFS extends Mutexed(UnmutexedOverlayFS) {
 const _Overlay = {
     name: 'Overlay',
     options: {
-        writable: {
-            type: 'object',
-            required: true,
-            description: 'The file system to write modified files to.',
-        },
-        readable: {
-            type: 'object',
-            required: true,
-            description: 'The file system that initially populates this file system.',
-        },
+        writable: { type: 'object', required: true },
+        readable: { type: 'object', required: true },
     },
     isAvailable() {
         return true;
@@ -547,4 +539,9 @@ const _Overlay = {
         return new OverlayFS(options);
     },
 };
+/**
+ * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
+ * @internal
+ */
 export const Overlay = _Overlay;

package/dist/backends/port/fs.d.ts

@@ -3,7 +3,6 @@ import type { ExtractProperties } from 'utilium';
 import { type MountConfiguration } from '../../config.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
-import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
@@ -51,7 +50,7 @@ export interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Requ
     method: TMethod;
     args: Parameters<FSMethods[TMethod]>;
 }
-declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, Async>;
+declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, import("../../mixins/async.js").AsyncMixin>;
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
  *

package/dist/backends/port/fs.js

@@ -218,10 +218,7 @@ const _Port = {
                 }
             },
         },
-        timeout: {
-            type: 'number',
-            required: false,
-        },
+        timeout: { type: 'number', required: false },
     },
     isAvailable() {
         return true;

package/dist/config.js

@@ -94,20 +94,16 @@ export async function configure(configuration) {
     config.updateOnRead = !configuration.disableUpdateOnRead;
     config.syncImmediately = !configuration.onlySyncOnClose;
     if (configuration.mounts) {
-        const toMount = [];
-        let unmountRoot = false;
-        for (const [_point, mountConfig] of Object.entries(configuration.mounts)) {
+        // sort to make sure any root replacement is done first
+        for (const [_point, mountConfig] of Object.entries(configuration.mounts).sort(([a], [b]) => (a.length > b.length ? 1 : -1))) {
             const point = _point.startsWith('/') ? _point : '/' + _point;
             if (isBackendConfig(mountConfig)) {
                 mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
             }
             if (point == '/')
-                unmountRoot = true;
-            toMount.push([point, await resolveMountConfig(mountConfig)]);
+                fs.umount('/');
+            await mount(point, await resolveMountConfig(mountConfig));
         }
-        if (unmountRoot)
-            fs.umount('/');
-        await Promise.all(toMount.map(([point, fs]) => mount(point, fs)));
     }
     if (configuration.addDevices) {
         const devfs = new DeviceFS();

package/dist/context.d.ts

@@ -0,0 +1,32 @@
+import { type ExtractProperties } from 'utilium';
+import { type CredentialInit, type Credentials } from './credentials.js';
+import * as fs from './emulation/index.js';
+type Fn_FS = Omit<ExtractProperties<typeof fs, (...args: any[]) => any>, 'mountObject'>;
+type Fn_Promises = ExtractProperties<typeof fs.promises, (...args: any[]) => any>;
+/**
+ * Represents some context used for FS operations
+ * @experimental
+ */
+export interface FSContext {
+    root: string;
+    readonly credentials: Credentials;
+}
+/**
+ * maybe an FS context
+ * @experimental @hidden
+ */
+export type V_Context = void | (Partial<FSContext> & object);
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * @experimental
+ */
+export interface BoundContext extends Fn_FS, FSContext {
+    promises: Fn_Promises;
+}
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * Note that the default credentials of a bound context are copied from the global credentials.
+ * @experimental
+ */
+export declare function bindContext(root: string, credentials?: CredentialInit): BoundContext;
+export {};

package/dist/context.js

@@ -0,0 +1,23 @@
+import { createCredentials, credentials as defaultCredentials } from './credentials.js';
+import * as fs from './emulation/index.js';
+/**
+ * Binds a this value for all of the functions in an object (not recursive)
+ * @internal
+ */
+function _bindFunctions(fns, thisValue) {
+    return Object.fromEntries(Object.entries(fns).map(([k, v]) => [k, typeof v == 'function' ? v.bind(thisValue) : v]));
+}
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * Note that the default credentials of a bound context are copied from the global credentials.
+ * @experimental
+ */
+export function bindContext(root, credentials = structuredClone(defaultCredentials)) {
+    const ctx = {
+        root,
+        credentials: createCredentials(credentials),
+    };
+    const fn_fs = _bindFunctions(fs, ctx);
+    const fn_promises = _bindFunctions(fs.promises, ctx);
+    return { ...ctx, ...fn_fs, promises: fn_promises };
+}

package/dist/credentials.d.ts

@@ -16,14 +16,14 @@ export interface Credentials {
     groups: number[];
 }
 export declare const credentials: Credentials;
-export interface CredentialInit {
+/**
+ * Initialization for a set of credentials
+ */
+export interface CredentialInit extends Partial<Credentials> {
     uid: number;
     gid: number;
-    suid?: number;
-    sgid?: number;
-    euid?: number;
-    egid?: number;
 }
+export declare function createCredentials(source: CredentialInit): Credentials;
 /**
  * Uses credentials from the provided uid and gid.
  */

package/dist/credentials.js

@@ -7,15 +7,19 @@ export const credentials = {
     egid: 0,
     groups: [],
 };
-/**
- * Uses credentials from the provided uid and gid.
- */
-export function useCredentials(source) {
-    Object.assign(credentials, {
+export function createCredentials(source) {
+    return {
         suid: source.uid,
         sgid: source.gid,
         euid: source.uid,
         egid: source.gid,
+        groups: [],
         ...source,
-    });
+    };
+}
+/**
+ * Uses credentials from the provided uid and gid.
+ */
+export function useCredentials(source) {
+    Object.assign(credentials, createCredentials(source));
 }

package/dist/emulation/async.d.ts

@@ -8,40 +8,41 @@ import type { Dir } from './dir.js';
 import * as promises from './promises.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher } from './watchers.js';
+import type { V_Context } from '../context.js';
 /**
  * Asynchronous rename. No arguments other than a possible exception are given to the completion callback.
  */
-export declare function rename(oldPath: fs.PathLike, newPath: fs.PathLike, cb?: Callback): void;
+export declare function rename(this: V_Context, oldPath: fs.PathLike, newPath: fs.PathLike, cb?: Callback): void;
 /**
  * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
  * @deprecated Use {@link stat} or {@link access} instead.
  */
-export declare function exists(path: fs.PathLike, cb?: (exists: boolean) => unknown): void;
-export declare function stat(path: fs.PathLike, callback: Callback<[Stats]>): void;
-export declare function stat(path: fs.PathLike, options: {
+export declare function exists(this: V_Context, path: fs.PathLike, cb?: (exists: boolean) => unknown): void;
+export declare function stat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint?: false;
 }, callback: Callback<[Stats]>): void;
-export declare function stat(path: fs.PathLike, options: {
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint: true;
 }, callback: Callback<[BigIntStats]>): void;
-export declare function stat(path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats] | [BigIntStats]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats] | [BigIntStats]>): void;
 /**
  * Asynchronous `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
  * then the link itself is stat-ed, not the file that it refers to.
  */
-export declare function lstat(path: fs.PathLike, callback: Callback<[Stats]>): void;
-export declare function lstat(path: fs.PathLike, options: fs.StatOptions & {
+export declare function lstat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
+export declare function lstat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint?: false;
 }, callback: Callback<[Stats]>): void;
-export declare function lstat(path: fs.PathLike, options: fs.StatOptions & {
+export declare function lstat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
 }, callback: Callback<[BigIntStats]>): void;
-export declare function lstat(path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats | BigIntStats]>): void;
-export declare function truncate(path: fs.PathLike, cb?: Callback): void;
-export declare function truncate(path: fs.PathLike, len: number, cb?: Callback): void;
-export declare function unlink(path: fs.PathLike, cb?: Callback): void;
+export declare function lstat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats | BigIntStats]>): void;
+export declare function truncate(this: V_Context, path: fs.PathLike, cb?: Callback): void;
+export declare function truncate(this: V_Context, path: fs.PathLike, len: number, cb?: Callback): void;
+export declare function unlink(this: V_Context, path: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous file open.
  * Exclusive mode ensures that path is newly created.
@@ -64,19 +65,19 @@ export declare function unlink(path: fs.PathLike, cb?: Callback): void;
  *
  * @see http://www.manpagez.com/man/2/open/
  */
-export declare function open(path: fs.PathLike, flag: string, cb?: Callback<[number]>): void;
-export declare function open(path: fs.PathLike, flag: string, mode: number | string, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: string, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: string, mode: number | string, cb?: Callback<[number]>): void;
 /**
  * Asynchronously reads the entire contents of a file.
  * @option encoding The string encoding for the file contents. Defaults to `null`.
  * @option flag Defaults to `'r'`.
  * @param cb If no encoding is specified, then the raw buffer is returned.
  */
-export declare function readFile(filename: fs.PathLike, cb: Callback<[Uint8Array]>): void;
-export declare function readFile(filename: fs.PathLike, options: {
+export declare function readFile(this: V_Context, filename: fs.PathLike, cb: Callback<[Uint8Array]>): void;
+export declare function readFile(this: V_Context, filename: fs.PathLike, options: {
     flag?: string;
 }, callback?: Callback<[Uint8Array]>): void;
-export declare function readFile(filename: fs.PathLike, options: {
+export declare function readFile(this: V_Context, filename: fs.PathLike, options: {
     encoding: BufferEncoding;
     flag?: string;
 } | BufferEncoding, cb: Callback<[string]>): void;
@@ -90,9 +91,9 @@ export declare function readFile(filename: fs.PathLike, options: {
  * @option mode Defaults to `0644`.
  * @option flag Defaults to `'w'`.
  */
-export declare function writeFile(filename: fs.PathLike, data: FileContents, cb?: Callback): void;
-export declare function writeFile(filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
-export declare function writeFile(filename: fs.PathLike, data: FileContents, options?: fs.WriteFileOptions, cb?: Callback): void;
+export declare function writeFile(this: V_Context, filename: fs.PathLike, data: FileContents, cb?: Callback): void;
+export declare function writeFile(this: V_Context, filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
+export declare function writeFile(this: V_Context, filename: fs.PathLike, data: FileContents, options?: fs.WriteFileOptions, cb?: Callback): void;
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
@@ -101,28 +102,28 @@ export declare function writeFile(filename: fs.PathLike, data: FileContents, opt
  * @option mode Defaults to `0644`.
  * @option flag Defaults to `'a'`.
  */
-export declare function appendFile(filename: fs.PathLike, data: FileContents, cb?: Callback): void;
-export declare function appendFile(filename: fs.PathLike, data: FileContents, options?: fs.EncodingOption & {
+export declare function appendFile(this: V_Context, filename: fs.PathLike, data: FileContents, cb?: Callback): void;
+export declare function appendFile(this: V_Context, filename: fs.PathLike, data: FileContents, options?: fs.EncodingOption & {
     mode?: fs.Mode;
     flag?: fs.OpenMode;
 }, cb?: Callback): void;
-export declare function appendFile(filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
+export declare function appendFile(this: V_Context, filename: fs.PathLike, data: FileContents, encoding?: BufferEncoding, cb?: Callback): void;
 /**
  * Asynchronous `fstat`.
  * `fstat()` is identical to `stat()`, except that the file to be stat-ed is specified by the file descriptor `fd`.
  */
-export declare function fstat(fd: number, cb: Callback<[Stats]>): void;
-export declare function fstat(fd: number, options: fs.StatOptions & {
+export declare function fstat(this: V_Context, fd: number, cb: Callback<[Stats]>): void;
+export declare function fstat(this: V_Context, fd: number, options: fs.StatOptions & {
     bigint?: false;
 }, cb: Callback<[Stats]>): void;
-export declare function fstat(fd: number, options: fs.StatOptions & {
+export declare function fstat(this: V_Context, fd: number, options: fs.StatOptions & {
     bigint: true;
 }, cb: Callback<[BigIntStats]>): void;
-export declare function close(fd: number, cb?: Callback): void;
-export declare function ftruncate(fd: number, cb?: Callback): void;
-export declare function ftruncate(fd: number, len?: number, cb?: Callback): void;
-export declare function fsync(fd: number, cb?: Callback): void;
-export declare function fdatasync(fd: number, cb?: Callback): void;
+export declare function close(this: V_Context, fd: number, cb?: Callback): void;
+export declare function ftruncate(this: V_Context, fd: number, cb?: Callback): void;
+export declare function ftruncate(this: V_Context, fd: number, len?: number, cb?: Callback): void;
+export declare function fsync(this: V_Context, fd: number, cb?: Callback): void;
+export declare function fdatasync(this: V_Context, fd: number, cb?: Callback): void;
 /**
  * Write buffer to the file specified by `fd`.
  * Note that it is unsafe to use fs.write multiple times on the same file without waiting for the callback.
@@ -133,11 +134,11 @@ export declare function fdatasync(fd: number, cb?: Callback): void;
  * If position is null, the data will be written at the current position.
  * @param cb The number specifies the number of bytes written into the file.
  */
-export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, cb?: Callback<[number, Uint8Array]>): void;
-export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
-export declare function write(fd: number, data: FileContents, cb?: Callback<[number, string]>): void;
-export declare function write(fd: number, data: FileContents, position?: number, cb?: Callback<[number, string]>): void;
-export declare function write(fd: number, data: FileContents, position: number | null, encoding: BufferEncoding, cb?: Callback<[number, string]>): void;
+export declare function write(this: V_Context, fd: number, buffer: Uint8Array, offset: number, length: number, cb?: Callback<[number, Uint8Array]>): void;
+export declare function write(this: V_Context, fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
+export declare function write(this: V_Context, fd: number, data: FileContents, cb?: Callback<[number, string]>): void;
+export declare function write(this: V_Context, fd: number, data: FileContents, position?: number, cb?: Callback<[number, string]>): void;
+export declare function write(this: V_Context, fd: number, data: FileContents, position: number | null, encoding: BufferEncoding, cb?: Callback<[number, string]>): void;
 /**
  * Read data from the file specified by `fd`.
  * @param buffer The buffer that the data will be written to.
@@ -147,64 +148,64 @@ export declare function write(fd: number, data: FileContents, position: number |
  * If position is null, data will be read from the current file position.
  * @param cb The number is the number of bytes read
  */
-export declare function read(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
-export declare function fchown(fd: number, uid: number, gid: number, cb?: Callback): void;
-export declare function fchmod(fd: number, mode: string | number, cb: Callback): void;
+export declare function read(this: V_Context, fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: Callback<[number, Uint8Array]>): void;
+export declare function fchown(this: V_Context, fd: number, uid: number, gid: number, cb?: Callback): void;
+export declare function fchmod(this: V_Context, fd: number, mode: string | number, cb: Callback): void;
 /**
  * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
-export declare function futimes(fd: number, atime: number | Date, mtime: number | Date, cb?: Callback): void;
-export declare function rmdir(path: fs.PathLike, cb?: Callback): void;
+export declare function futimes(this: V_Context, fd: number, atime: number | Date, mtime: number | Date, cb?: Callback): void;
+export declare function rmdir(this: V_Context, path: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous `mkdir`.
  * @param mode defaults to `0777`
  */
-export declare function mkdir(path: fs.PathLike, mode?: fs.Mode, cb?: Callback): void;
+export declare function mkdir(this: V_Context, path: fs.PathLike, mode?: fs.Mode, cb?: Callback): void;
 /**
  * Asynchronous `readdir`. Reads the contents of a directory.
  * The callback gets two arguments `(err, files)` where `files` is an array of
  * the names of the files in the directory excluding `'.'` and `'..'`.
  */
-export declare function readdir(path: fs.PathLike, cb: Callback<[string[]]>): void;
-export declare function readdir(path: fs.PathLike, options: {
+export declare function readdir(this: V_Context, path: fs.PathLike, cb: Callback<[string[]]>): void;
+export declare function readdir(this: V_Context, path: fs.PathLike, options: {
     withFileTypes?: false;
 }, cb: Callback<[string[]]>): void;
-export declare function readdir(path: fs.PathLike, options: {
+export declare function readdir(this: V_Context, path: fs.PathLike, options: {
     withFileTypes: true;
 }, cb: Callback<[Dirent[]]>): void;
-export declare function link(existing: fs.PathLike, newpath: fs.PathLike, cb?: Callback): void;
+export declare function link(this: V_Context, existing: fs.PathLike, newpath: fs.PathLike, cb?: Callback): void;
 /**
  * Asynchronous `symlink`.
  * @param target target path
  * @param path link path
  * Type defaults to file
  */
-export declare function symlink(target: fs.PathLike, path: fs.PathLike, cb?: Callback): void;
-export declare function symlink(target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type, cb?: Callback): void;
-export declare function readlink(path: fs.PathLike, callback: Callback<[string]>): void;
-export declare function readlink(path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
-export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
-export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;
-export declare function chown(path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
-export declare function lchown(path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
-export declare function chmod(path: fs.PathLike, mode: number | string, cb?: Callback): void;
-export declare function lchmod(path: fs.PathLike, mode: number | string, cb?: Callback): void;
+export declare function symlink(this: V_Context, target: fs.PathLike, path: fs.PathLike, cb?: Callback): void;
+export declare function symlink(this: V_Context, target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type, cb?: Callback): void;
+export declare function readlink(this: V_Context, path: fs.PathLike, callback: Callback<[string]>): void;
+export declare function readlink(this: V_Context, path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
+export declare function readlink(this: V_Context, path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
+export declare function readlink(this: V_Context, path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;
+export declare function chown(this: V_Context, path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
+export declare function lchown(this: V_Context, path: fs.PathLike, uid: number, gid: number, cb?: Callback): void;
+export declare function chmod(this: V_Context, path: fs.PathLike, mode: number | string, cb?: Callback): void;
+export declare function lchmod(this: V_Context, path: fs.PathLike, mode: number | string, cb?: Callback): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
-export declare function utimes(path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
+export declare function utimes(this: V_Context, path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
-export declare function lutimes(path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
+export declare function lutimes(this: V_Context, path: fs.PathLike, atime: number | Date, mtime: number | Date, cb?: Callback): void;
 /**
  * Asynchronous `realpath`. The callback gets two arguments
  * `(err, resolvedPath)`. May use `process.cwd` to resolve relative paths.
  */
-export declare function realpath(path: fs.PathLike, cb?: Callback<[string]>): void;
-export declare function realpath(path: fs.PathLike, options: fs.EncodingOption, cb: Callback<[string]>): void;
-export declare function access(path: fs.PathLike, cb: Callback): void;
-export declare function access(path: fs.PathLike, mode: number, cb: Callback): void;
+export declare function realpath(this: V_Context, path: fs.PathLike, cb?: Callback<[string]>): void;
+export declare function realpath(this: V_Context, path: fs.PathLike, options: fs.EncodingOption, cb: Callback<[string]>): void;
+export declare function access(this: V_Context, path: fs.PathLike, cb: Callback): void;
+export declare function access(this: V_Context, path: fs.PathLike, mode: number, cb: Callback): void;
 /**
  * Watch for changes on a file. The callback listener will be called each time the file is accessed.
  *
@@ -216,8 +217,8 @@ export declare function access(path: fs.PathLike, mode: number, cb: Callback): v
  * @param options Optional options object specifying `persistent` and `interval`.
  * @param listener The callback listener to be called when the file changes.
  */
-export declare function watchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
-export declare function watchFile(path: fs.PathLike, options: {
+export declare function watchFile(this: V_Context, path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
+export declare function watchFile(this: V_Context, path: fs.PathLike, options: {
     persistent?: boolean;
     interval?: number;
 }, listener: (curr: Stats, prev: Stats) => void): void;
@@ -230,9 +231,9 @@ export declare function watchFile(path: fs.PathLike, options: {
  * @param path The path to the file to stop watching.
  * @param listener Optional listener to remove.
  */
-export declare function unwatchFile(path: fs.PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
-export declare function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): FSWatcher;
-export declare function watch(path: fs.PathLike, options: {
+export declare function unwatchFile(this: V_Context, path: fs.PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
+export declare function watch(this: V_Context, path: fs.PathLike, listener?: (event: string, filename: string) => any): FSWatcher;
+export declare function watch(this: V_Context, path: fs.PathLike, options: {
     persistent?: boolean;
 }, listener?: (event: string, filename: string) => any): FSWatcher;
 interface StreamOptions {
@@ -270,7 +271,7 @@ interface WriteStreamOptions extends StreamOptions {
  * @param options Options for the ReadStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
  * @returns A ReadStream object for interacting with the file's contents.
  */
-export declare function createReadStream(path: fs.PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
+export declare function createReadStream(this: V_Context, path: fs.PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
 /**
  * Opens a file in write mode and creates a Node.js-like WriteStream.
  *
@@ -278,34 +279,34 @@ export declare function createReadStream(path: fs.PathLike, options?: BufferEnco
  * @param options Options for the WriteStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
  * @returns A WriteStream object for writing to the file.
  */
-export declare function createWriteStream(path: fs.PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
-export declare function rm(path: fs.PathLike, callback: Callback): void;
-export declare function rm(path: fs.PathLike, options: fs.RmOptions, callback: Callback): void;
+export declare function createWriteStream(this: V_Context, path: fs.PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
+export declare function rm(this: V_Context, path: fs.PathLike, callback: Callback): void;
+export declare function rm(this: V_Context, path: fs.PathLike, options: fs.RmOptions, callback: Callback): void;
 /**
  * Asynchronously creates a unique temporary directory.
  * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
  */
-export declare function mkdtemp(prefix: string, callback: Callback<[string]>): void;
-export declare function mkdtemp(prefix: string, options: fs.EncodingOption, callback: Callback<[string]>): void;
-export declare function mkdtemp(prefix: string, options: fs.BufferEncodingOption, callback: Callback<[Buffer]>): void;
-export declare function copyFile(src: fs.PathLike, dest: fs.PathLike, callback: Callback): void;
-export declare function copyFile(src: fs.PathLike, dest: fs.PathLike, flags: number, callback: Callback): void;
+export declare function mkdtemp(this: V_Context, prefix: string, callback: Callback<[string]>): void;
+export declare function mkdtemp(this: V_Context, prefix: string, options: fs.EncodingOption, callback: Callback<[string]>): void;
+export declare function mkdtemp(this: V_Context, prefix: string, options: fs.BufferEncodingOption, callback: Callback<[Buffer]>): void;
+export declare function copyFile(this: V_Context, src: fs.PathLike, dest: fs.PathLike, callback: Callback): void;
+export declare function copyFile(this: V_Context, src: fs.PathLike, dest: fs.PathLike, flags: number, callback: Callback): void;
 type readvCb = Callback<[number, NodeJS.ArrayBufferView[]]>;
-export declare function readv(fd: number, buffers: NodeJS.ArrayBufferView[], cb: readvCb): void;
-export declare function readv(fd: number, buffers: NodeJS.ArrayBufferView[], position: number, cb: readvCb): void;
+export declare function readv(this: V_Context, fd: number, buffers: NodeJS.ArrayBufferView[], cb: readvCb): void;
+export declare function readv(this: V_Context, fd: number, buffers: NodeJS.ArrayBufferView[], position: number, cb: readvCb): void;
 type writevCb = Callback<[number, NodeJS.ArrayBufferView[]]>;
-export declare function writev(fd: number, buffers: Uint8Array[], cb: writevCb): void;
-export declare function writev(fd: number, buffers: Uint8Array[], position: number, cb: writevCb): void;
-export declare function opendir(path: fs.PathLike, cb: Callback<[Dir]>): void;
-export declare function opendir(path: fs.PathLike, options: fs.OpenDirOptions, cb: Callback<[Dir]>): void;
-export declare function cp(source: fs.PathLike, destination: fs.PathLike, callback: Callback): void;
-export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyOptions, callback: Callback): void;
-export declare function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
-export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
+export declare function writev(this: V_Context, fd: number, buffers: Uint8Array[], cb: writevCb): void;
+export declare function writev(this: V_Context, fd: number, buffers: Uint8Array[], position: number, cb: writevCb): void;
+export declare function opendir(this: V_Context, path: fs.PathLike, cb: Callback<[Dir]>): void;
+export declare function opendir(this: V_Context, path: fs.PathLike, options: fs.OpenDirOptions, cb: Callback<[Dir]>): void;
+export declare function cp(this: V_Context, source: fs.PathLike, destination: fs.PathLike, callback: Callback): void;
+export declare function cp(this: V_Context, source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyOptions, callback: Callback): void;
+export declare function statfs(this: V_Context, path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
+export declare function statfs(this: V_Context, path: fs.PathLike, options: fs.StatFsOptions & {
     bigint?: false;
 }, callback: Callback<[fs.StatsFs]>): void;
-export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
+export declare function statfs(this: V_Context, path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
 }, callback: Callback<[fs.BigIntStatsFs]>): void;
-export declare function openAsBlob(path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
+export declare function openAsBlob(this: V_Context, path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
 export {};