just-binary 2.9.8

package/dist/commands/xan/xan-data.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Data utility commands: transpose, shuffle, fixlengths, split, partition
+ * Commands that exist in real xan
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Transpose: swap rows and columns
+ * Usage: xan transpose [FILE]
+ *   First column becomes header row, first row becomes header column
+ */
+export declare function cmdTranspose(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Shuffle: randomly reorder rows
+ * Usage: xan shuffle [OPTIONS] [FILE]
+ *   --seed N    Random seed for reproducibility
+ */
+export declare function cmdShuffle(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Fixlengths: fix ragged CSV by padding/truncating rows
+ * Usage: xan fixlengths [OPTIONS] [FILE]
+ *   -l, --length N    Target number of columns (default: max row length)
+ *   -d, --default V   Default value for missing fields (default: empty)
+ */
+export declare function cmdFixlengths(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Split: split CSV into multiple files by row count
+ * Usage: xan split [OPTIONS] FILE
+ *   -c, --chunks N    Split into N equal chunks
+ *   -S, --size N      Split into chunks of N rows each
+ *   -o, --output DIR  Output directory (default: current)
+ *
+ * In sandbox mode, outputs as JSON with parts as array
+ */
+export declare function cmdSplit(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Partition: split CSV by column value into separate outputs
+ * Usage: xan partition COLUMN [OPTIONS] [FILE]
+ *   -o, --output DIR  Output directory (default: current)
+ */
+export declare function cmdPartition(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * To: convert CSV to other formats
+ * Usage: xan to FORMAT [OPTIONS] [FILE]
+ *   FORMAT: json
+ */
+export declare function cmdTo(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * From: convert other formats to CSV
+ * Usage: xan from [OPTIONS] [FILE]
+ *   -f, --format FORMAT   Input format (json)
+ */
+export declare function cmdFrom(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-filter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filter and sort commands: filter, sort, dedup, top
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdFilter(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdSort(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdDedup(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTop(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-map.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Map command: add computed columns
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdMap(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Transform command: modify existing columns in-place
+ * Usage: xan transform COLUMN EXPR [FILE]
+ *   -r, --rename NAME  Rename the column after transformation
+ */
+export declare function cmdTransform(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-reshape.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Reshape commands: explode, implode, flatmap, pivot, join, merge
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Explode: split delimited column values into multiple rows
+ * Usage: xan explode COLUMN [OPTIONS] [FILE]
+ *   -s, --separator SEP  Value separator (default: |)
+ *   --drop-empty         Drop rows where column is empty
+ *   -r, --rename NAME    Rename the column
+ */
+export declare function cmdExplode(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Implode: combine consecutive rows with same key, joining column values
+ * Usage: xan implode COLUMN [OPTIONS] [FILE]
+ *   -s, --separator SEP  Value separator (default: |)
+ *   -r, --rename NAME    Rename the column
+ */
+export declare function cmdImplode(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Join: join two CSV files on key columns
+ * Usage: xan join KEY1 FILE1 KEY2 FILE2 [OPTIONS]
+ *   --left       Left outer join (keep all rows from first file)
+ *   --right      Right outer join (keep all rows from second file)
+ *   --full       Full outer join (keep all rows from both files)
+ *   -D, --default VALUE  Default value for missing fields
+ */
+export declare function cmdJoin(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Pivot: reshape data by turning row values into columns
+ * Usage: xan pivot COLUMN AGG_EXPR [OPTIONS] [FILE]
+ *   -g, --groupby COLS   Group by these columns (default: all other columns)
+ */
+export declare function cmdPivot(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Merge: merge multiple sorted CSV files
+ * Usage: xan merge [OPTIONS] FILE1 FILE2 ...
+ *   -s, --sort COLUMN   Sort column (files must be pre-sorted by this)
+ */
+export declare function cmdMerge(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-simple.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Simple commands: behead, sample, cat, search, flatmap, fmt
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Behead: remove header row from CSV (output data rows only)
+ * Usage: xan behead [FILE]
+ */
+export declare function cmdBehead(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Sample: randomly sample N rows from CSV
+ * Usage: xan sample [OPTIONS] <sample-size> [FILE]
+ *   --seed SEED    Random seed for reproducibility
+ */
+export declare function cmdSample(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Cat: concatenate CSV files
+ * Usage: xan cat [OPTIONS] FILE1 FILE2 ...
+ *   -p, --pad    Pad missing columns with empty values
+ */
+export declare function cmdCat(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Search: filter rows by regex match on any/specific columns
+ * Usage: xan search [OPTIONS] PATTERN [FILE]
+ *   -s, --select COLS    Only search in these columns
+ *   -v, --invert         Invert match (exclude matching rows)
+ *   -i, --ignore-case    Case insensitive match
+ */
+export declare function cmdSearch(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Flatmap: like map but expression can return multiple rows
+ * Usage: xan flatmap EXPR [FILE]
+ *   The expression should return an array; each element becomes a row
+ */
+export declare function cmdFlatmap(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Fmt: format CSV as a table (alias for view with options)
+ * Usage: xan fmt [OPTIONS] [FILE]
+ */
+export declare function cmdFmt(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-view.d.ts

@@ -0,0 +1,12 @@
+/**
+ * View commands: pretty print CSV as table or flattened records
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Flatten: display records vertically, one field per line
+ * Usage: xan flatten [OPTIONS] [FILE]
+ *   -l, --limit N    Maximum number of rows to display
+ *   -s, --select COLS  Select columns to display
+ */
+export declare function cmdFlatten(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdView(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan.d.ts

@@ -0,0 +1,10 @@
+/**
+ * xan - CSV toolkit command
+ *
+ * Provides ergonomic CLI for CSV operations, translating commands to jq expressions
+ * and using the shared query engine. Inspired by xsv and xan tools.
+ */
+import type { Command } from "../../types.js";
+export declare const xanCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/xargs/xargs.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const xargsCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/yq/formats.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Format parsing and output for yq command
+ *
+ * Supports YAML, JSON, XML, INI, CSV, and TOML formats with conversion between them.
+ */
+import type { QueryValue } from "../query-engine/index.js";
+export type InputFormat = "yaml" | "xml" | "json" | "ini" | "csv" | "toml";
+export type OutputFormat = "yaml" | "json" | "xml" | "ini" | "csv" | "toml";
+/**
+ * Type guard to validate input format strings at runtime
+ */
+export declare function isValidInputFormat(value: unknown): value is InputFormat;
+/**
+ * Type guard to validate output format strings at runtime
+ */
+export declare function isValidOutputFormat(value: unknown): value is OutputFormat;
+export interface FormatOptions {
+    /** Input format (default: yaml) */
+    inputFormat: InputFormat;
+    /** Output format (default: yaml) */
+    outputFormat: OutputFormat;
+    /** Output raw strings without quotes (json only) */
+    raw: boolean;
+    /** Compact output (json only) */
+    compact: boolean;
+    /** Pretty print output */
+    prettyPrint: boolean;
+    /** Indentation level */
+    indent: number;
+    /** XML attribute prefix (default: +@) */
+    xmlAttributePrefix: string;
+    /** XML text content name (default: +content) */
+    xmlContentName: string;
+    /** CSV delimiter (empty = auto-detect) */
+    csvDelimiter: string;
+    /** CSV has header row */
+    csvHeader: boolean;
+}
+export declare const defaultFormatOptions: FormatOptions;
+/**
+ * Detect input format from file extension
+ */
+export declare function detectFormatFromExtension(filename: string): InputFormat | null;
+/**
+ * Parse input data from the given format into a QueryValue
+ */
+export declare function parseInput(input: string, options: FormatOptions): QueryValue;
+/**
+ * Parse all YAML documents from input (for slurp mode)
+ */
+export declare function parseAllYamlDocuments(input: string): QueryValue[];
+/**
+ * Extract front-matter from content
+ * Front-matter is YAML/TOML/JSON at the start of a file between --- or +++ delimiters
+ * Returns { frontMatter: parsed data, content: remaining content } or null if no front-matter
+ */
+export declare function extractFrontMatter(input: string): {
+    frontMatter: QueryValue;
+    content: string;
+} | null;
+/**
+ * Format a QueryValue for output in the given format
+ */
+export declare function formatOutput(value: QueryValue, options: FormatOptions): string;

package/dist/commands/yq/yq.d.ts

@@ -0,0 +1,13 @@
+/**
+ * yq - Command-line YAML/XML/INI/CSV/TOML processor
+ *
+ * Uses jq-style query expressions to process YAML, XML, INI, CSV, and TOML files.
+ * Shares the query engine with jq for consistent filtering behavior.
+ *
+ * Inspired by mikefarah/yq (https://github.com/mikefarah/yq)
+ * This is a reimplementation for the just-bash sandboxed environment.
+ */
+import type { Command } from "../../types.js";
+export declare const yqCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/custom-commands.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Custom Commands API
+ *
+ * Provides types and utilities for registering user-provided TypeScript commands.
+ */
+import type { Command, CommandContext, ExecResult } from "./types.js";
+/**
+ * An ExecResult with string stdout/stderr, for ergonomic custom commands.
+ */
+export interface StringExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Return type for custom commands — either binary ExecResult or string-based.
+ */
+export type CustomExecResult = ExecResult | StringExecResult;
+/**
+ * User-facing CommandContext with string-typed env for ergonomics.
+ * Internal commands use Map<string, Uint8Array>, but custom commands get Map<string, string>.
+ */
+export interface CustomCommandContext extends Omit<CommandContext, "env"> {
+    env: Map<string, string>;
+}
+/**
+ * A custom command - either a Command object or a lazy loader.
+ */
+export type CustomCommand = Command | LazyCommand;
+/**
+ * Lazy-loaded custom command (for code-splitting).
+ */
+export interface LazyCommand {
+    name: string;
+    load: () => Promise<Command>;
+}
+/**
+ * Type guard to check if a custom command is lazy-loaded.
+ */
+export declare function isLazyCommand(cmd: CustomCommand): cmd is LazyCommand;
+/**
+ * Define a TypeScript command with type inference.
+ * Convenience wrapper - you can also just use the Command interface directly.
+ *
+ * @example
+ * ```ts
+ * const hello = defineCommand("hello", async (args, ctx) => {
+ *   const name = args[0] || "world";
+ *   return { stdout: `Hello, ${name}!\n`, stderr: "", exitCode: 0 };
+ * });
+ *
+ * const bash = new Bash({ customCommands: [hello] });
+ * await bash.exec("hello Alice"); // "Hello, Alice!\n"
+ * ```
+ */
+export declare function defineCommand(name: string, execute: (args: string[], ctx: CustomCommandContext) => Promise<CustomExecResult>): Command;
+/**
+ * Create a lazy-loaded wrapper for a custom command.
+ * The command is only loaded when first executed.
+ */
+export declare function createLazyCustomCommand(lazy: LazyCommand): Command;

package/dist/fs/encoding.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared utilities for filesystem implementations
+ */
+import type { BufferEncoding, ReadFileOptions, WriteFileOptions } from "./interface.js";
+export type FileContent = string | Uint8Array;
+/**
+ * Helper to convert content to Uint8Array
+ */
+export declare function toBuffer(content: FileContent, encoding?: BufferEncoding): Uint8Array;
+/**
+ * Helper to convert Uint8Array to string with encoding
+ */
+export declare function fromBuffer(buffer: Uint8Array, encoding?: BufferEncoding | null): string;
+/**
+ * Helper to get encoding from options
+ */
+export declare function getEncoding(options?: ReadFileOptions | WriteFileOptions | BufferEncoding | string | null): BufferEncoding | undefined;

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

@@ -0,0 +1,63 @@
+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>;
+    /**
+     * Resolve all symlinks in a path to get the canonical physical path.
+     * This is equivalent to POSIX realpath().
+     */
+    realpath(path: string): Promise<string>;
+    /**
+     * Set access and modification times of a file
+     * @param path - The file path
+     * @param _atime - Access time (ignored, kept for API compatibility)
+     * @param mtime - Modification time
+     */
+    utimes(path: string, _atime: Date, mtime: Date): Promise<void>;
+}

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,219 @@
+/**
+ * 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>;
+    /**
+     * Resolve all symlinks in a path to get the canonical physical path.
+     * This is equivalent to POSIX realpath() - it resolves all symlinks
+     * in the path and returns the absolute physical path.
+     * Used by pwd -P and cd -P for symlink resolution.
+     * @throws Error if path doesn't exist or contains a broken symlink
+     */
+    realpath(path: string): Promise<string>;
+    /**
+     * Set access and modification times of a file
+     * @param path - The file path
+     * @param atime - Access time (currently ignored, kept for API compatibility)
+     * @param mtime - Modification time
+     * @throws Error if path doesn't exist
+     */
+    utimes(path: string, atime: Date, mtime: Date): Promise<void>;
+}
+/**
+ * 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";