just-bash 2.5.0 → 2.5.2

package/dist/commands/rg/file-types.d.ts

@@ -9,14 +9,40 @@ export interface FileType {
     globs: string[];
 }
 /**
- * Built-in file type definitions
- * Use `rg --type-list` to see all types in real ripgrep
+ * Mutable file type registry for runtime type modifications
+ * Supports --type-add and --type-clear flags
  */
-export declare const FILE_TYPES: Record<string, FileType>;
-/**
- * Check if a filename matches any of the specified types
- */
-export declare function matchesType(filename: string, types: string[]): boolean;
+export declare class FileTypeRegistry {
+    private types;
+    constructor();
+    /**
+     * Add a type definition
+     * Format: "name:pattern" where pattern can be:
+     * - "*.ext" - glob pattern
+     * - "include:other" - include patterns from another type
+     */
+    addType(spec: string): void;
+    /**
+     * Clear all patterns from a type
+     */
+    clearType(name: string): void;
+    /**
+     * Get a type by name
+     */
+    getType(name: string): FileType | undefined;
+    /**
+     * Get all type names
+     */
+    getAllTypes(): Map<string, FileType>;
+    /**
+     * Check if a filename matches any of the specified types
+     */
+    matchesType(filename: string, typeNames: string[]): boolean;
+    /**
+     * Check if a filename matches any recognized type
+     */
+    private matchesAnyType;
+}
 /**
  * Format type list for --type-list output
  */

package/dist/commands/rg/gitignore.d.ts

@@ -29,6 +29,14 @@ export declare class GitignoreParser {
      * @returns true if the path should be ignored
      */
     matches(relativePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern
+     *
+     * @param relativePath Path relative to the gitignore location
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(relativePath: string, isDirectory: boolean): boolean;
     /**
      * Get the base path for this gitignore
      */
@@ -43,12 +51,24 @@ export declare class GitignoreParser {
 export declare class GitignoreManager {
     private parsers;
     private fs;
-    private rootPath;
-    constructor(fs: IFileSystem, rootPath: string);
+    private skipDotIgnore;
+    private skipVcsIgnore;
+    private loadedDirs;
+    constructor(fs: IFileSystem, _rootPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean);
     /**
      * Load all .gitignore and .ignore files from root to the specified path
      */
     load(targetPath: string): Promise<void>;
+    /**
+     * Load ignore files for a directory during traversal.
+     * Only loads if the directory hasn't been loaded before.
+     */
+    loadForDirectory(dir: string): Promise<void>;
+    /**
+     * Add patterns from raw content at the specified base path.
+     * Used for --ignore-file flag.
+     */
+    addPatternsFromContent(content: string, basePath: string): void;
     /**
      * Check if a path should be ignored
      *
@@ -57,6 +77,15 @@ export declare class GitignoreManager {
      * @returns true if the path should be ignored
      */
     matches(absolutePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern.
+     * Used to include hidden files that have negation patterns like "!.foo"
+     *
+     * @param absolutePath Absolute path to check
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(absolutePath: string, isDirectory: boolean): boolean;
     /**
      * Quick check for common ignored directories
      * Used for early pruning during traversal
@@ -66,4 +95,4 @@ export declare class GitignoreManager {
 /**
  * Load gitignore files for a search starting at the given path
  */
-export declare function loadGitignores(fs: IFileSystem, startPath: string): Promise<GitignoreManager>;
+export declare function loadGitignores(fs: IFileSystem, startPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean, customIgnoreFiles?: string[]): Promise<GitignoreManager>;

package/dist/commands/rg/rg-options.d.ts

@@ -10,16 +10,20 @@ export interface RgOptions {
     lineRegexp: boolean;
     invertMatch: boolean;
     multiline: boolean;
+    multilineDotall: boolean;
     patterns: string[];
     patternFiles: string[];
     count: boolean;
     countMatches: boolean;
+    files: boolean;
     filesWithMatches: boolean;
     filesWithoutMatch: boolean;
+    stats: boolean;
     onlyMatching: boolean;
     maxCount: number;
     lineNumber: boolean;
     noFilename: boolean;
+    withFilename: boolean;
     nullSeparator: boolean;
     byteOffset: boolean;
     column: boolean;
@@ -35,13 +39,23 @@ export interface RgOptions {
     sort: "path" | "none";
     json: boolean;
     globs: string[];
+    iglobs: string[];
+    globCaseInsensitive: boolean;
     types: string[];
     typesNot: string[];
+    typeAdd: string[];
+    typeClear: string[];
     hidden: boolean;
     noIgnore: boolean;
+    noIgnoreDot: boolean;
+    noIgnoreVcs: boolean;
+    ignoreFiles: string[];
     maxDepth: number;
+    maxFilesize: number;
     followSymlinks: boolean;
     searchZip: boolean;
     searchBinary: boolean;
+    preprocessor: string | null;
+    preprocessorGlobs: string[];
 }
 export declare function createDefaultOptions(): RgOptions;

package/dist/commands/search-engine/index.d.ts

@@ -7,4 +7,4 @@
  * - Regex building for different modes (basic, extended, fixed, perl)
  */
 export { type SearchOptions, type SearchResult, searchContent, } from "./matcher.js";
-export { buildRegex, type RegexMode, type RegexOptions } from "./regex.js";
+export { buildRegex, convertReplacement, type RegexMode, type RegexOptions, } from "./regex.js";

package/dist/commands/search-engine/regex.d.ts

@@ -15,3 +15,13 @@ export interface RegexOptions {
  * Build a JavaScript RegExp from a pattern with the specified mode
  */
 export declare function buildRegex(pattern: string, options: RegexOptions): RegExp;
+/**
+ * Convert replacement string syntax to JavaScript's String.replace format
+ *
+ * Conversions:
+ * - $0 and ${0} -> $& (full match)
+ * - $name -> $<name> (named capture groups)
+ * - ${name} -> $<name> (braced named capture groups)
+ * - Preserves $1, $2, etc. for numbered groups
+ */
+export declare function convertReplacement(replacement: string): string;

package/dist/fs/in-memory-fs/in-memory-fs.d.ts

@@ -0,0 +1,51 @@
+import type { BufferEncoding, CpOptions, DirectoryEntry, DirentEntry, FileContent, FileEntry, FsEntry, FsStat, IFileSystem, InitialFiles, MkdirOptions, ReadFileOptions, RmOptions, SymlinkEntry, WriteFileOptions } from "../interface.js";
+export type { BufferEncoding, FileContent, FileEntry, DirectoryEntry, SymlinkEntry, FsEntry, FsStat, IFileSystem, };
+export interface FsData {
+    [path: string]: FsEntry;
+}
+export declare class InMemoryFs implements IFileSystem {
+    private data;
+    constructor(initialFiles?: InitialFiles);
+    private normalizePath;
+    private dirname;
+    private ensureParentDirs;
+    writeFileSync(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding, metadata?: {
+        mode?: number;
+        mtime?: Date;
+    }): void;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    private resolveSymlink;
+    /**
+     * Resolve symlinks in intermediate path components only (not the final component).
+     * Used by lstat which should not follow the final symlink.
+     */
+    private resolveIntermediateSymlinks;
+    /**
+     * Resolve all symlinks in a path, including intermediate components.
+     * For example: /home/user/linkdir/file.txt where linkdir is a symlink to "subdir"
+     * would resolve to /home/user/subdir/file.txt
+     */
+    private resolvePathWithSymlinks;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Synchronous version of mkdir
+     */
+    mkdirSync(path: string, options?: MkdirOptions): void;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    getAllPaths(): string[];
+    resolvePath(base: string, path: string): string;
+    chmod(path: string, mode: number): Promise<void>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+}

package/dist/fs/in-memory-fs/index.d.ts

@@ -0,0 +1 @@
+export { InMemoryFs } from "./in-memory-fs.js";

package/dist/fs/init.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filesystem Initialization
+ *
+ * Sets up the default filesystem structure for the bash environment
+ * including /dev, /proc, and common directories.
+ */
+import type { IFileSystem } from "./interface.js";
+/**
+ * Initialize the filesystem with standard directories and files
+ * Works with both InMemoryFs and OverlayFs (both write to memory)
+ */
+export declare function initFilesystem(fs: IFileSystem, useDefaultLayout: boolean): void;

package/dist/fs/interface.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Supported buffer encodings
+ */
+export type BufferEncoding = "utf8" | "utf-8" | "ascii" | "binary" | "base64" | "hex" | "latin1";
+/**
+ * File content can be string or Buffer
+ */
+export type FileContent = string | Uint8Array;
+/**
+ * Options for reading files
+ */
+export interface ReadFileOptions {
+    encoding?: BufferEncoding | null;
+}
+/**
+ * Options for writing files
+ */
+export interface WriteFileOptions {
+    encoding?: BufferEncoding;
+}
+/**
+ * File system entry types
+ */
+export interface FileEntry {
+    type: "file";
+    content: string | Uint8Array;
+    mode: number;
+    mtime: Date;
+}
+export interface DirectoryEntry {
+    type: "directory";
+    mode: number;
+    mtime: Date;
+}
+export interface SymlinkEntry {
+    type: "symlink";
+    target: string;
+    mode: number;
+    mtime: Date;
+}
+export type FsEntry = FileEntry | DirectoryEntry | SymlinkEntry;
+/**
+ * Directory entry with type information (similar to Node's Dirent)
+ * Used by readdirWithFileTypes for efficient directory listing without stat calls
+ */
+export interface DirentEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+}
+/**
+ * Stat result from the filesystem
+ */
+export interface FsStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    mode: number;
+    size: number;
+    mtime: Date;
+}
+/**
+ * Options for mkdir operation
+ */
+export interface MkdirOptions {
+    recursive?: boolean;
+}
+/**
+ * Options for rm operation
+ */
+export interface RmOptions {
+    recursive?: boolean;
+    force?: boolean;
+}
+/**
+ * Options for cp operation
+ */
+export interface CpOptions {
+    recursive?: boolean;
+}
+/**
+ * Abstract filesystem interface that can be implemented by different backends.
+ * This allows BashEnv to work with:
+ * - InMemoryFs (in-memory, default)
+ * - Real filesystem (via node:fs)
+ * - Custom implementations (e.g., remote storage, browser IndexedDB)
+ */
+export interface IFileSystem {
+    /**
+     * Read the contents of a file as a string (default: utf8)
+     * @throws Error if file doesn't exist or is a directory
+     */
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    /**
+     * Read the contents of a file as a Uint8Array (binary)
+     * @throws Error if file doesn't exist or is a directory
+     */
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    /**
+     * Write content to a file, creating it if it doesn't exist
+     */
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    /**
+     * Append content to a file, creating it if it doesn't exist
+     */
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    /**
+     * Check if a path exists
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Get file/directory information
+     * @throws Error if path doesn't exist
+     */
+    stat(path: string): Promise<FsStat>;
+    /**
+     * Create a directory
+     * @throws Error if parent doesn't exist (unless recursive) or path exists
+     */
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Read directory contents
+     * @returns Array of entry names (not full paths)
+     * @throws Error if path doesn't exist or is not a directory
+     */
+    readdir(path: string): Promise<string[]>;
+    /**
+     * Read directory contents with file type information (optional)
+     * This is more efficient than readdir + stat for each entry
+     * @returns Array of DirentEntry objects with name and type
+     * @throws Error if path doesn't exist or is not a directory
+     */
+    readdirWithFileTypes?(path: string): Promise<DirentEntry[]>;
+    /**
+     * Remove a file or directory
+     * @throws Error if path doesn't exist (unless force) or directory not empty (unless recursive)
+     */
+    rm(path: string, options?: RmOptions): Promise<void>;
+    /**
+     * Copy a file or directory
+     * @throws Error if source doesn't exist or trying to copy directory without recursive
+     */
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    /**
+     * Move/rename a file or directory
+     */
+    mv(src: string, dest: string): Promise<void>;
+    /**
+     * Resolve a relative path against a base path
+     */
+    resolvePath(base: string, path: string): string;
+    /**
+     * Get all paths in the filesystem (useful for glob matching)
+     * Optional - implementations may return empty array if not supported
+     */
+    getAllPaths(): string[];
+    /**
+     * Change file/directory permissions
+     * @throws Error if path doesn't exist
+     */
+    chmod(path: string, mode: number): Promise<void>;
+    /**
+     * Create a symbolic link
+     * @param target - The path the symlink should point to
+     * @param linkPath - The path where the symlink will be created
+     * @throws Error if linkPath already exists
+     */
+    symlink(target: string, linkPath: string): Promise<void>;
+    /**
+     * Create a hard link
+     * @param existingPath - The existing file to link to
+     * @param newPath - The path where the new link will be created
+     * @throws Error if existingPath doesn't exist or newPath already exists
+     */
+    link(existingPath: string, newPath: string): Promise<void>;
+    /**
+     * Read the target of a symbolic link
+     * @throws Error if path doesn't exist or is not a symlink
+     */
+    readlink(path: string): Promise<string>;
+    /**
+     * Get file/directory information without following symlinks
+     * @throws Error if path doesn't exist
+     */
+    lstat(path: string): Promise<FsStat>;
+}
+/**
+ * Extended file initialization options with optional metadata
+ */
+export interface FileInit {
+    content: FileContent;
+    mode?: number;
+    mtime?: Date;
+}
+/**
+ * Initial files can be simple content or extended options with metadata
+ */
+export type InitialFiles = Record<string, FileContent | FileInit>;
+/**
+ * Factory function type for creating filesystem instances
+ */
+export type FileSystemFactory = (initialFiles?: InitialFiles) => IFileSystem;

package/dist/fs/mountable-fs/index.d.ts

@@ -0,0 +1 @@
+export { MountableFs, type MountableFsOptions, type MountConfig, } from "./mountable-fs.js";

package/dist/fs/mountable-fs/mountable-fs.d.ts

@@ -0,0 +1,108 @@
+import type { BufferEncoding, CpOptions, FileContent, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
+/**
+ * Configuration for a mount point
+ */
+export interface MountConfig {
+    /** Virtual path where the filesystem is mounted */
+    mountPoint: string;
+    /** The filesystem to mount at this path */
+    filesystem: IFileSystem;
+}
+/**
+ * Options for creating a MountableFs
+ */
+export interface MountableFsOptions {
+    /** Base filesystem used for unmounted paths (defaults to InMemoryFs) */
+    base?: IFileSystem;
+    /** Initial mounts to configure */
+    mounts?: MountConfig[];
+}
+/**
+ * A filesystem that supports mounting other filesystems at specific paths.
+ *
+ * This allows combining multiple filesystem backends into a unified namespace.
+ * For example, mounting a read-only knowledge base at /mnt/knowledge and a
+ * read-write workspace at /home/agent.
+ *
+ * @example
+ * ```typescript
+ * const fs = new MountableFs({ base: new InMemoryFs() });
+ * fs.mount('/mnt/knowledge', new OverlayFs({ root: "/path/to/knowledge", readOnly: true }));
+ * fs.mount('/home/agent', new ReadWriteFs({ root: "/path/to/workspace" }));
+ * ```
+ */
+export declare class MountableFs implements IFileSystem {
+    private baseFs;
+    private mounts;
+    constructor(options?: MountableFsOptions);
+    /**
+     * Mount a filesystem at the specified virtual path.
+     *
+     * @param mountPoint - The virtual path where the filesystem will be accessible
+     * @param filesystem - The filesystem to mount
+     * @throws Error if mounting at root '/' or inside an existing mount
+     */
+    mount(mountPoint: string, filesystem: IFileSystem): void;
+    /**
+     * Unmount the filesystem at the specified path.
+     *
+     * @param mountPoint - The virtual path to unmount
+     * @throws Error if no filesystem is mounted at this path
+     */
+    unmount(mountPoint: string): void;
+    /**
+     * Get all current mounts.
+     */
+    getMounts(): ReadonlyArray<{
+        mountPoint: string;
+        filesystem: IFileSystem;
+    }>;
+    /**
+     * Check if a path is exactly a mount point.
+     */
+    isMountPoint(path: string): boolean;
+    /**
+     * Validate mount path format before normalization.
+     * Rejects paths containing . or .. segments.
+     */
+    private validateMountPath;
+    /**
+     * Validate that a mount point is allowed.
+     */
+    private validateMount;
+    /**
+     * Normalize a path to a consistent format.
+     */
+    private normalizePath;
+    /**
+     * Route a path to the appropriate filesystem.
+     * Returns the filesystem and the relative path within that filesystem.
+     */
+    private routePath;
+    /**
+     * Get mount points that are immediate children of a directory.
+     */
+    private getChildMountPoints;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    resolvePath(base: string, path: string): string;
+    getAllPaths(): string[];
+    chmod(path: string, mode: number): Promise<void>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    /**
+     * Perform a cross-mount copy operation.
+     */
+    private crossMountCopy;
+}

package/dist/fs/overlay-fs/index.d.ts

@@ -0,0 +1 @@
+export { OverlayFs, type OverlayFsOptions } from "./overlay-fs.js";

package/dist/fs/overlay-fs/overlay-fs.d.ts

@@ -0,0 +1,107 @@
+/**
+ * OverlayFs - Copy-on-write filesystem backed by a real directory
+ *
+ * Reads come from the real filesystem, writes go to an in-memory layer.
+ * Changes don't persist to disk and can't escape the root directory.
+ */
+import type { CpOptions, DirentEntry, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
+import { type FileContent } from "../utils.js";
+export interface OverlayFsOptions {
+    /**
+     * The root directory on the real filesystem.
+     * All paths are relative to this root and cannot escape it.
+     */
+    root: string;
+    /**
+     * The virtual mount point where the root directory appears.
+     * Defaults to "/home/user/project".
+     */
+    mountPoint?: string;
+    /**
+     * If true, all write operations will throw an error.
+     * Useful for truly read-only access to the filesystem.
+     * Defaults to false.
+     */
+    readOnly?: boolean;
+}
+export declare class OverlayFs implements IFileSystem {
+    private readonly root;
+    private readonly mountPoint;
+    private readonly readOnly;
+    private readonly memory;
+    private readonly deleted;
+    constructor(options: OverlayFsOptions);
+    /**
+     * Throws an error if the filesystem is in read-only mode.
+     */
+    private assertWritable;
+    /**
+     * Create directory entries for the mount point path
+     */
+    private createMountPointDirs;
+    /**
+     * Get the mount point for this overlay
+     */
+    getMountPoint(): string;
+    /**
+     * Create a virtual directory in memory (sync, for initialization)
+     */
+    mkdirSync(path: string, _options?: MkdirOptions): void;
+    /**
+     * Create a virtual file in memory (sync, for initialization)
+     */
+    writeFileSync(path: string, content: string | Uint8Array): void;
+    private getDirname;
+    /**
+     * Normalize a virtual path (resolve . and .., ensure starts with /)
+     */
+    private normalizePath;
+    /**
+     * Check if a normalized virtual path is under the mount point.
+     * Returns the relative path within the mount point, or null if not under it.
+     */
+    private getRelativeToMount;
+    /**
+     * Convert a virtual path to a real filesystem path.
+     * Returns null if the path is not under the mount point or would escape the root.
+     */
+    private toRealPath;
+    private dirname;
+    private ensureParentDirs;
+    /**
+     * Check if a path exists in the overlay (memory + real fs - deleted)
+     */
+    private existsInOverlay;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBuffer(path: string, seen?: Set<string>): Promise<Uint8Array>;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string, seen?: Set<string>): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    private resolveSymlink;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Core readdir implementation that returns entries with file types.
+     * Both readdir and readdirWithFileTypes use this shared implementation.
+     */
+    private readdirCore;
+    /**
+     * Follow symlinks to resolve the final directory path.
+     * Returns outsideOverlay: true if the symlink points outside the overlay or
+     * the resolved target doesn't exist (security - broken symlinks return []).
+     */
+    private resolveForReaddir;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    resolvePath(base: string, path: string): string;
+    getAllPaths(): string[];
+    private scanRealFs;
+    chmod(path: string, mode: number): Promise<void>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+}

package/dist/fs/read-write-fs/index.d.ts

@@ -0,0 +1 @@
+export { ReadWriteFs, type ReadWriteFsOptions } from "./read-write-fs.js";