sandbox-fs 1.0.0 → 1.1.0

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "sandbox-fs",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A read-only virtual file system that maps Unix-style virtual paths to a real directory root",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && mocha -r ts-node/register 'test/**/*.spec.ts' --exit"
   },
   "keywords": [
     "filesystem",
@@ -17,13 +18,16 @@
     "readonly",
     "fs"
   ],
-  "author": "",
+  "author": "Brian Choi",
   "license": "MIT",
   "engines": {
     "node": ">=18.0.0"
   },
   "devDependencies": {
     "@types/node": "^18.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "mocha": "^10.0.0",
+    "ts-node": "^10.0.0",
+    "@types/mocha": "^10.0.0"
   }
 }

package/dist/FSModule.d.ts

@@ -1,153 +0,0 @@
-import * as fs from 'fs';
-import type { PathMapper } from './PathMapper';
-import type { ResourceTracker } from './ResourceTracker';
-/**
- * Create a Node.js fs-compatible module
- */
-export declare function createFSModule(pathMapper: PathMapper, resourceTracker: ResourceTracker): {
-    promises: {
-        readFile: (virtualPath: string, options?: any) => Promise<Buffer | string>;
-        readdir: (virtualPath: string, options?: any) => Promise<string[] | Buffer[] | fs.Dirent[]>;
-        stat: (virtualPath: string, options?: any) => Promise<fs.Stats>;
-        lstat: (virtualPath: string, options?: any) => Promise<fs.Stats>;
-        access: (virtualPath: string, mode?: number) => Promise<void>;
-        realpath: (virtualPath: string, options?: any) => Promise<string | Buffer>;
-        open: (virtualPath: string, flags?: string | number, mode?: number) => Promise<number>;
-        read: (fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null) => Promise<{
-            bytesRead: number;
-            buffer: NodeJS.ArrayBufferView;
-        }>;
-        close: (fd: number) => Promise<void>;
-        fstat: (fd: number, options?: any) => Promise<fs.Stats>;
-        opendir: (virtualPath: string, options?: any) => Promise<import("./wrappers/VirtualDir").VirtualDir>;
-        exists: (virtualPath: string) => Promise<boolean>;
-        writeFile: (path: string, data: any, options?: any) => Promise<void>;
-        appendFile: (path: string, data: any, options?: any) => Promise<void>;
-        mkdir: (path: string, options?: any) => Promise<void | string>;
-        rmdir: (path: string, options?: any) => Promise<void>;
-        rm: (path: string, options?: any) => Promise<void>;
-        unlink: (path: string) => Promise<void>;
-        rename: (oldPath: string, newPath: string) => Promise<void>;
-        copyFile: (src: string, dest: string, mode?: number) => Promise<void>;
-        truncate: (path: string, len?: number) => Promise<void>;
-        ftruncate: (fd: number, len?: number) => Promise<void>;
-        chmod: (path: string, mode: string | number) => Promise<void>;
-        fchmod: (fd: number, mode: string | number) => Promise<void>;
-        lchmod: (path: string, mode: string | number) => Promise<void>;
-        chown: (path: string, uid: number, gid: number) => Promise<void>;
-        fchown: (fd: number, uid: number, gid: number) => Promise<void>;
-        lchown: (path: string, uid: number, gid: number) => Promise<void>;
-        utimes: (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-        futimes: (fd: number, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-        lutimes: (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-        write: (fd: number, buffer: any, offset?: any, length?: any, position?: any) => Promise<any>;
-        writev: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<any>;
-        fsync: (fd: number) => Promise<void>;
-        fdatasync: (fd: number) => Promise<void>;
-        symlink: (target: string, path: string, type?: string) => Promise<void>;
-        link: (existingPath: string, newPath: string) => Promise<void>;
-        readlink: (path: string, options?: any) => Promise<string | Buffer>;
-        glob: (pattern: string, options?: any) => AsyncIterableIterator<string>;
-        statfs: (virtualPath: string, options?: any) => Promise<fs.StatsFsBase<any>>;
-        cp: (source: string, destination: string, options?: any) => Promise<void>;
-        openAsBlob: (virtualPath: string, options?: any) => Promise<Blob>;
-        readv: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<number>;
-    };
-    constants: typeof fs.constants;
-    Stats: typeof fs.Stats;
-    Dirent: typeof fs.Dirent;
-    ReadStream: typeof fs.ReadStream;
-    WriteStream: typeof fs.WriteStream;
-    watch: (virtualPath: string, options?: any) => fs.FSWatcher;
-    watchFile: (virtualPath: string, options: any, listener?: any) => void;
-    unwatchFile: (virtualPath: string, listener?: any) => void;
-    createReadStream: (virtualPath: string, options?: any) => fs.ReadStream;
-    createWriteStream: (path: string, options?: any) => never;
-    readFileSync: (path: string, options?: any) => NonSharedBuffer;
-    readdirSync: (path: string, options?: any) => string[];
-    statSync: (path: string, options?: any) => fs.Stats;
-    lstatSync: (path: string, options?: any) => fs.Stats;
-    accessSync: (path: string, mode?: number) => void;
-    realpathSync: (path: string, options?: any) => string;
-    openSync: (path: string, flags?: string | number, mode?: number) => number;
-    readSync: (fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null) => number;
-    closeSync: (fd: number) => void;
-    fstatSync: (fd: number, options?: any) => fs.Stats;
-    opendirSync: (path: string, options?: any) => any;
-    existsSync: (path: string) => boolean;
-    writeFileSync: (path: string) => never;
-    appendFileSync: (path: string) => never;
-    mkdirSync: (path: string) => never;
-    rmdirSync: (path: string) => never;
-    rmSync: (path: string) => never;
-    unlinkSync: (path: string) => never;
-    renameSync: (oldPath: string) => never;
-    copyFileSync: (src: string, dest: string) => never;
-    truncateSync: (path: string) => never;
-    ftruncateSync: (fd: number) => never;
-    chmodSync: (path: string) => never;
-    fchmodSync: (fd: number) => never;
-    lchmodSync: (path: string) => never;
-    chownSync: (path: string) => never;
-    fchownSync: (fd: number) => never;
-    lchownSync: (path: string) => never;
-    utimesSync: (path: string) => never;
-    futimesSync: (fd: number) => never;
-    lutimesSync: (path: string) => never;
-    writeSync: (fd: number) => never;
-    writevSync: (fd: number) => never;
-    fsyncSync: (fd: number) => never;
-    fdatasyncSync: (fd: number) => never;
-    symlinkSync: (target: string, path: string) => never;
-    linkSync: (existingPath: string, newPath: string) => never;
-    readlinkSync: (path: string) => never;
-    cpSync: (source: string, destination: string) => never;
-    statfsSync: (path: string, options?: any) => fs.StatsFs;
-    readvSync: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => any;
-    readFile: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
-    readdir: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string[] | Buffer<ArrayBufferLike>[] | fs.Dirent<string>[] | undefined) => void) => void;
-    stat: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
-    lstat: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
-    access: (virtualPath: string, mode: number | undefined, args_2: (err: Error | null) => void) => void;
-    realpath: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
-    open: (virtualPath: string, flags: string | number | undefined, mode: number | undefined, args_3: (err: Error | null, result?: number | undefined) => void) => void;
-    read: (fd: number, buffer: NodeJS.ArrayBufferView<ArrayBufferLike>, offset: number, length: number, position: number | null, args_5: (err: Error | null, result?: {
-        bytesRead: number;
-        buffer: NodeJS.ArrayBufferView;
-    } | undefined) => void) => void;
-    close: (fd: number, args_1: (err: Error | null) => void) => void;
-    fstat: (fd: number, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
-    opendir: (virtualPath: string, options: any, args_2: (err: Error | null, result?: import("./wrappers/VirtualDir").VirtualDir | undefined) => void) => void;
-    exists: (path: string, callback: (exists: boolean) => void) => void;
-    writeFile: (path: string, data: any, options: any, args_3: (err: Error | null) => void) => void;
-    appendFile: (path: string, data: any, options: any, args_3: (err: Error | null) => void) => void;
-    mkdir: (path: string, options: any, args_2: (err: Error | null, result?: string | void | undefined) => void) => void;
-    rmdir: (path: string, options: any, args_2: (err: Error | null) => void) => void;
-    rm: (path: string, options: any, args_2: (err: Error | null) => void) => void;
-    unlink: (path: string, args_1: (err: Error | null) => void) => void;
-    rename: (oldPath: string, newPath: string, args_2: (err: Error | null) => void) => void;
-    copyFile: (src: string, dest: string, mode: number | undefined, args_3: (err: Error | null) => void) => void;
-    truncate: (path: string, len: number | undefined, args_2: (err: Error | null) => void) => void;
-    ftruncate: (fd: number, len: number | undefined, args_2: (err: Error | null) => void) => void;
-    chmod: (path: string, mode: string | number, args_2: (err: Error | null) => void) => void;
-    fchmod: (fd: number, mode: string | number, args_2: (err: Error | null) => void) => void;
-    lchmod: (path: string, mode: string | number, args_2: (err: Error | null) => void) => void;
-    chown: (path: string, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
-    fchown: (fd: number, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
-    lchown: (path: string, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
-    utimes: (path: string, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
-    futimes: (fd: number, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
-    lutimes: (path: string, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
-    write: (fd: number, buffer: any, offset: any, length: any, position: any, args_5: (err: Error | null, result?: any) => void) => void;
-    writev: (fd: number, buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[], position: number | undefined, args_3: (err: Error | null, result?: any) => void) => void;
-    fsync: (fd: number, args_1: (err: Error | null) => void) => void;
-    fdatasync: (fd: number, args_1: (err: Error | null) => void) => void;
-    symlink: (target: string, path: string, type: string | undefined, args_3: (err: Error | null) => void) => void;
-    link: (existingPath: string, newPath: string, args_2: (err: Error | null) => void) => void;
-    readlink: (path: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
-    statfs: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.StatsFsBase<any> | undefined) => void) => void;
-    cp: (source: string, destination: string, options: any, args_3: (err: Error | null) => void) => void;
-    openAsBlob: (virtualPath: string, options: any, args_2: (err: Error | null, result?: Blob | undefined) => void) => void;
-    readv: (fd: number, buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[], position: number | undefined, args_3: (err: Error | null, result?: number | undefined) => void) => void;
-};
-//# sourceMappingURL=FSModule.d.ts.map

package/dist/PathMapper.d.ts

@@ -1,30 +0,0 @@
-/**
- * Handles conversion between virtual Unix-style paths and real platform-native paths
- */
-export declare class PathMapper {
-    private readonly normalizedRoot;
-    constructor(rootPath: string);
-    /**
-     * Get the normalized root path
-     */
-    getRoot(): string;
-    /**
-     * Convert a virtual path (Unix-style with forward slashes) to a real platform-native path
-     * @param virtualPath - Virtual path starting with /
-     * @returns Real absolute path
-     * @throws Error if path traversal is detected
-     */
-    toRealPath(virtualPath: string): string;
-    /**
-     * Convert a real platform-native path to a virtual Unix-style path
-     * @param realPath - Real absolute path
-     * @returns Virtual path starting with /
-     * @throws Error if real path is not within VFS root
-     */
-    toVirtualPath(realPath: string): string;
-    /**
-     * Check if a real path is within the VFS root
-     */
-    isWithinRoot(realPath: string): boolean;
-}
-//# sourceMappingURL=PathMapper.d.ts.map

package/dist/PathModule.d.ts

@@ -1,69 +0,0 @@
-import * as path from 'path';
-/**
- * Creates a path module that operates in virtual path space
- * All paths use Unix-style forward slashes
- * Fixed virtual CWD of '/'
- */
-export declare function createPathModule(): {
-    /**
-     * Normalize a path, reducing '..' and '.' parts
-     */
-    normalize(p: string): string;
-    /**
-     * Join all path segments together and normalize the result
-     */
-    join(...paths: string[]): string;
-    /**
-     * Resolve a sequence of paths to an absolute path
-     */
-    resolve(...paths: string[]): string;
-    /**
-     * Return the relative path from 'from' to 'to'
-     */
-    relative(from: string, to: string): string;
-    /**
-     * Return the directory name of a path
-     */
-    dirname(p: string): string;
-    /**
-     * Return the last portion of a path
-     */
-    basename(p: string, ext?: string): string;
-    /**
-     * Return the extension of the path
-     */
-    extname(p: string): string;
-    /**
-     * Parse a path into an object
-     */
-    parse(p: string): path.ParsedPath;
-    /**
-     * Format a path object into a string
-     */
-    format(pathObject: path.FormatInputPathObject): string;
-    /**
-     * Check if a path is absolute
-     */
-    isAbsolute(p: string): boolean;
-    /**
-     * Convert path to namespaced path (Windows-only, no-op in virtual space)
-     */
-    toNamespacedPath(p: string): string;
-    /**
-     * Path segment separator (always / in virtual space)
-     */
-    sep: string;
-    /**
-     * Path delimiter (always : in virtual space)
-     */
-    delimiter: string;
-    /**
-     * POSIX-specific methods (same as main module in virtual space)
-     */
-    posix: any;
-    /**
-     * Windows-specific methods (same as main module in virtual space)
-     */
-    win32: any;
-};
-//# sourceMappingURL=PathModule.d.ts.map

package/dist/ResourceTracker.d.ts

@@ -1,74 +0,0 @@
-import { Readable, Writable } from 'stream';
-/**
- * Information about a tracked file descriptor
- */
-export interface FDInfo {
-    fd: number;
-    virtualPath: string;
-    realPath: string;
-    flags: string | number;
-    mode?: number;
-    isStream: boolean;
-}
-/**
- * Manages lifecycle of file descriptors and streams to prevent resource leaks
- * and ensure proper cleanup when VFS is closed
- */
-export declare class ResourceTracker {
-    private fdMap;
-    private streams;
-    private abortControllers;
-    private _closed;
-    /**
-     * Check if the VFS has been closed
-     */
-    get closed(): boolean;
-    /**
-     * Assert that the VFS is not closed, throwing EBADF if it is
-     */
-    assertNotClosed(): void;
-    /**
-     * Track a file descriptor
-     */
-    trackFD(fd: number, info: Omit<FDInfo, 'fd'>): void;
-    /**
-     * Get information about a tracked file descriptor
-     */
-    getFD(fd: number): FDInfo | undefined;
-    /**
-     * Check if a file descriptor is tracked
-     */
-    isTracked(fd: number): boolean;
-    /**
-     * Untrack a file descriptor (when closed)
-     */
-    untrackFD(fd: number): FDInfo | undefined;
-    /**
-     * Track a stream
-     */
-    trackStream(stream: Readable | Writable): void;
-    /**
-     * Untrack a stream (when closed)
-     */
-    untrackStream(stream: Readable | Writable): void;
-    /**
-     * Register an AbortSignal listener for cleanup
-     */
-    registerAbortListener(signal: AbortSignal | undefined, cleanup: () => void): void;
-    /**
-     * Dispose all tracked resources and mark as closed
-     */
-    dispose(): void;
-    /**
-     * Get all tracked file descriptors (for debugging)
-     */
-    getAllFDs(): FDInfo[];
-    /**
-     * Get count of tracked resources
-     */
-    getResourceCount(): {
-        fds: number;
-        streams: number;
-    };
-}
-//# sourceMappingURL=ResourceTracker.d.ts.map

package/dist/VirtualFileSystem.d.ts

@@ -1,145 +0,0 @@
-/**
- * Options for creating a VirtualFileSystem
- */
-export interface VFSOptions {
-    /**
-     * The real filesystem path to use as the VFS root.
-     * Can be a Windows path (C:\data) or Unix path (/opt/data).
-     * All virtual paths will be mapped relative to this root.
-     */
-    root: string;
-}
-/**
- * A read-only virtual file system that maps Unix-style virtual paths
- * to a real directory root.
- *
- * @example
- * ```typescript
- * const vfs = new VirtualFileSystem({ root: '/opt/data' });
- * const fs = vfs.createNodeFSModule();
- * const path = vfs.createNodePathModule();
- *
- * // Read a file (real path: /opt/data/file.txt)
- * const content = fs.readFileSync('/file.txt', 'utf8');
- *
- * // Write operations are denied
- * fs.writeFileSync('/file.txt', 'data'); // throws EACCES
- *
- * // Clean up when done
- * vfs.close();
- * ```
- */
-export declare class VirtualFileSystem {
-    private pathMapper;
-    private resourceTracker;
-    /**
-     * Create a new VirtualFileSystem instance
-     *
-     * @param options - Configuration options
-     * @throws Error if root path doesn't exist or is not a directory
-     */
-    constructor(options: VFSOptions);
-    /**
-     * Convert a virtual path to a real filesystem path
-     *
-     * @param virtualPath - Virtual path (Unix-style, starts with /)
-     * @returns Real filesystem path (platform-native)
-     * @throws Error if path traversal is detected
-     *
-     * @example
-     * ```typescript
-     * const vfs = new VirtualFileSystem({ root: 'C:\\data' });
-     * vfs.toRealPath('/foo/bar.txt'); // Returns: C:\data\foo\bar.txt
-     * ```
-     */
-    toRealPath(virtualPath: string): string;
-    /**
-     * Convert a real filesystem path to a virtual path
-     *
-     * @param realPath - Real filesystem path (platform-native)
-     * @returns Virtual path (Unix-style, starts with /)
-     * @throws Error if real path is outside VFS root
-     *
-     * @example
-     * ```typescript
-     * const vfs = new VirtualFileSystem({ root: 'C:\\data' });
-     * vfs.toVirtualPath('C:\\data\\foo\\bar.txt'); // Returns: /foo/bar.txt
-     * ```
-     */
-    toVirtualPath(realPath: string): string;
-    /**
-     * Create a Node.js fs-compatible module
-     *
-     * Returns an object that matches the Node.js fs module API.
-     * All read operations work normally, write operations return EACCES,
-     * and symlink operations return EACCES. Error messages have real paths
-     * filtered out and replaced with virtual paths.
-     *
-     * @returns An fs-compatible object with both callback and promise APIs
-     *
-     * @example
-     * ```typescript
-     * const vfs = new VirtualFileSystem({ root: '/opt/data' });
-     * const fs = vfs.createNodeFSModule();
-     *
-     * // Callback API
-     * fs.readFile('/file.txt', 'utf8', (err, data) => {
-     *   if (err) throw err;
-     *   console.log(data);
-     * });
-     *
-     * // Promise API
-     * const data = await fs.promises.readFile('/file.txt', 'utf8');
-     *
-     * // Sync API
-     * const data = fs.readFileSync('/file.txt', 'utf8');
-     * ```
-     */
-    createNodeFSModule(): any;
-    /**
-     * Create a Node.js path-compatible module
-     *
-     * Returns an object that matches the Node.js path module API.
-     * All operations use Unix-style paths with forward slashes.
-     * The virtual current working directory is always '/'.
-     *
-     * @returns A path-compatible object
-     *
-     * @example
-     * ```typescript
-     * const vfs = new VirtualFileSystem({ root: '/opt/data' });
-     * const path = vfs.createNodePathModule();
-     *
-     * path.resolve('.');           // Returns: /
-     * path.resolve('foo/bar.txt'); // Returns: /foo/bar.txt
-     * path.join('/foo', 'bar');    // Returns: /foo/bar
-     * path.sep;                     // Returns: /
-     * ```
-     */
-    createNodePathModule(): any;
-    /**
-     * Close the VFS and release all resources
-     *
-     * Closes all tracked file descriptors, destroys all streams,
-     * and marks the VFS as closed. After calling close(), all
-     * subsequent fs operations will throw EBADF errors.
-     *
-     * @example
-     * ```typescript
-     * const vfs = new VirtualFileSystem({ root: '/opt/data' });
-     * const fs = vfs.createNodeFSModule();
-     *
-     * const fd = fs.openSync('/file.txt', 'r');
-     *
-     * vfs.close(); // Closes fd and all other resources
-     *
-     * fs.readFileSync('/file.txt'); // Throws EBADF
-     * ```
-     */
-    close(): void;
-    /**
-     * Check if the VFS has been closed
-     */
-    get closed(): boolean;
-}
-//# sourceMappingURL=VirtualFileSystem.d.ts.map

package/dist/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * sandbox-fs - A read-only virtual file system for Node.js
- *
- * Maps Unix-style virtual paths to a real directory root while preventing
- * write operations and filtering real paths from error messages.
- */
-export { VirtualFileSystem, VirtualFileSystem as default } from './VirtualFileSystem';
-export type { VFSOptions } from './VirtualFileSystem';
-//# sourceMappingURL=index.d.ts.map

package/dist/operations/newer.d.ts

@@ -1,36 +0,0 @@
-import * as fs from 'fs';
-import type { PathMapper } from '../PathMapper';
-import type { ResourceTracker } from '../ResourceTracker';
-/**
- * glob - Pattern matching (Node.js 22+)
- */
-export declare function createGlobOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (pattern: string, options?: any) => AsyncIterableIterator<string>;
-/**
- * statfs - File system statistics (Node.js 19+)
- */
-export declare function createStatfsOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<fs.StatsFsBase<any>>;
-/**
- * cp - Copy files/directories (read source only, write dest is denied)
- */
-export declare function createCpOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (source: string, destination: string, options?: any) => Promise<void>;
-/**
- * openAsBlob - Open file as Blob (Node.js 19+)
- */
-export declare function createOpenAsBlobOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<Blob>;
-/**
- * readv - Vector read (Node.js 13+)
- */
-export declare function createReadvOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<number>;
-/**
- * watch - Watch for file changes
- */
-export declare function createWatchOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => fs.FSWatcher;
-/**
- * watchFile - Watch a file for changes
- */
-export declare function createWatchFileOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options: any, listener?: any) => void;
-/**
- * unwatchFile - Stop watching a file
- */
-export declare function createUnwatchFileOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, listener?: any) => void;
-//# sourceMappingURL=newer.d.ts.map

package/dist/operations/read.d.ts

@@ -1,24 +0,0 @@
-import * as fs from 'fs';
-import type { PathMapper } from '../PathMapper';
-import type { ResourceTracker } from '../ResourceTracker';
-import { VirtualDir } from '../wrappers/VirtualDir';
-/**
- * Read file operations
- */
-export declare function createReadFileOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<Buffer | string>;
-export declare function createReaddirOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<string[] | Buffer[] | fs.Dirent[]>;
-export declare function createStatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<fs.Stats>;
-export declare function createLstatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<fs.Stats>;
-export declare function createAccessOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, mode?: number) => Promise<void>;
-export declare function createRealpathOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<string | Buffer>;
-export declare function createOpenOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, flags?: string | number, mode?: number) => Promise<number>;
-export declare function createReadOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null) => Promise<{
-    bytesRead: number;
-    buffer: NodeJS.ArrayBufferView;
-}>;
-export declare function createCloseOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (fd: number) => Promise<void>;
-export declare function createFstatOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (fd: number, options?: any) => Promise<fs.Stats>;
-export declare function createOpendirOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => Promise<VirtualDir>;
-export declare function createExistsOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string) => Promise<boolean>;
-export declare function createCreateReadStreamOperation(pathMapper: PathMapper, resourceTracker: ResourceTracker): (virtualPath: string, options?: any) => fs.ReadStream;
-//# sourceMappingURL=read.d.ts.map

package/dist/operations/symlink.d.ts

@@ -1,8 +0,0 @@
-/**
- * All symlink operations return EACCES (access denied)
- * This module provides all symlink-related fs operations
- */
-export declare function createSymlinkOperation(): (target: string, path: string, type?: string) => Promise<void>;
-export declare function createLinkOperation(): (existingPath: string, newPath: string) => Promise<void>;
-export declare function createReadlinkOperation(): (path: string, options?: any) => Promise<string | Buffer>;
-//# sourceMappingURL=symlink.d.ts.map

package/dist/operations/write.d.ts

@@ -1,29 +0,0 @@
-/**
- * All write operations return EACCES (access denied)
- * This module provides all write-related fs operations
- */
-export declare function createWriteFileOperation(): (path: string, data: any, options?: any) => Promise<void>;
-export declare function createAppendFileOperation(): (path: string, data: any, options?: any) => Promise<void>;
-export declare function createMkdirOperation(): (path: string, options?: any) => Promise<void | string>;
-export declare function createRmdirOperation(): (path: string, options?: any) => Promise<void>;
-export declare function createRmOperation(): (path: string, options?: any) => Promise<void>;
-export declare function createUnlinkOperation(): (path: string) => Promise<void>;
-export declare function createRenameOperation(): (oldPath: string, newPath: string) => Promise<void>;
-export declare function createCopyFileOperation(): (src: string, dest: string, mode?: number) => Promise<void>;
-export declare function createTruncateOperation(): (path: string, len?: number) => Promise<void>;
-export declare function createFtruncateOperation(): (fd: number, len?: number) => Promise<void>;
-export declare function createChmodOperation(): (path: string, mode: string | number) => Promise<void>;
-export declare function createFchmodOperation(): (fd: number, mode: string | number) => Promise<void>;
-export declare function createLchmodOperation(): (path: string, mode: string | number) => Promise<void>;
-export declare function createChownOperation(): (path: string, uid: number, gid: number) => Promise<void>;
-export declare function createFchownOperation(): (fd: number, uid: number, gid: number) => Promise<void>;
-export declare function createLchownOperation(): (path: string, uid: number, gid: number) => Promise<void>;
-export declare function createUtimesOperation(): (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-export declare function createFutimesOperation(): (fd: number, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-export declare function createLutimesOperation(): (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
-export declare function createWriteOperation(): (fd: number, buffer: any, offset?: any, length?: any, position?: any) => Promise<any>;
-export declare function createWritevOperation(): (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<any>;
-export declare function createCreateWriteStreamOperation(): (path: string, options?: any) => never;
-export declare function createFsyncOperation(): (fd: number) => Promise<void>;
-export declare function createFdatasyncOperation(): (fd: number) => Promise<void>;
-//# sourceMappingURL=write.d.ts.map

package/dist/utils/ErrorFilter.d.ts

@@ -1,6 +0,0 @@
-import type { PathMapper } from "../PathMapper";
-/**
- * Filter error messages to replace real paths with virtual paths
- */
-export declare function filterError(error: Error, pathMapper: PathMapper): Error;
-//# sourceMappingURL=ErrorFilter.d.ts.map

package/dist/utils/callbackify.d.ts

@@ -1,9 +0,0 @@
-/**
- * Convert a promise-based function to a callback-based function
- */
-export declare function callbackify<T extends any[], R>(fn: (...args: T) => Promise<R>): (...args: [...T, (err: Error | null, result?: R) => void]) => void;
-/**
- * Callbackify for void-returning promises
- */
-export declare function callbackifyVoid<T extends any[]>(fn: (...args: T) => Promise<void>): (...args: [...T, (err: Error | null) => void]) => void;
-//# sourceMappingURL=callbackify.d.ts.map