just-binary 2.9.8

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

@@ -0,0 +1,120 @@
+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>;
+    /**
+     * Resolve all symlinks in a path to get the canonical physical path.
+     * This is equivalent to POSIX realpath().
+     */
+    realpath(path: string): Promise<string>;
+    /**
+     * Perform a cross-mount copy operation.
+     */
+    private crossMountCopy;
+    /**
+     * Set access and modification times of a file
+     * @param path - The file path
+     * @param atime - Access time
+     * @param mtime - Modification time
+     */
+    utimes(path: string, atime: Date, mtime: Date): Promise<void>;
+}

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,126 @@
+/**
+ * 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 FileContent } from "../encoding.js";
+import type { CpOptions, DirentEntry, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.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;
+    /**
+     * Maximum file size in bytes that can be read from the real filesystem.
+     * Files larger than this will throw an EFBIG error.
+     * Defaults to 10MB (10485760).
+     */
+    maxFileReadSize?: number;
+}
+export declare class OverlayFs implements IFileSystem {
+    private readonly root;
+    private readonly mountPoint;
+    private readonly readOnly;
+    private readonly maxFileReadSize;
+    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>;
+    /**
+     * 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/read-write-fs/index.d.ts

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

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

@@ -0,0 +1,69 @@
+/**
+ * ReadWriteFs - Direct wrapper around the real filesystem
+ *
+ * All operations go directly to the underlying Node.js filesystem.
+ * Paths are relative to the configured root directory.
+ *
+ * Security: Symlink targets are validated and transformed to stay within root,
+ * preventing symlink-based sandbox escape attacks.
+ */
+import { type FileContent } from "../encoding.js";
+import type { CpOptions, DirentEntry, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
+export interface ReadWriteFsOptions {
+    /**
+     * The root directory on the real filesystem.
+     * All paths are relative to this root.
+     */
+    root: string;
+    /**
+     * Maximum file size in bytes that can be read.
+     * Files larger than this will throw an EFBIG error.
+     * Defaults to 10MB (10485760).
+     */
+    maxFileReadSize?: number;
+}
+export declare class ReadWriteFs implements IFileSystem {
+    private readonly root;
+    private readonly maxFileReadSize;
+    constructor(options: ReadWriteFsOptions);
+    /**
+     * Convert a virtual path to a real filesystem path.
+     */
+    private toRealPath;
+    /**
+     * Normalize a virtual path (resolve . and .., ensure starts with /)
+     */
+    private normalizePath;
+    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[]>;
+    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 scanDir;
+    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
+     * @param mtime - Modification time
+     */
+    utimes(path: string, atime: Date, mtime: Date): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export type { BashLogger, BashOptions, ExecOptions } from "./Bash.js";
+export { Bash } from "./Bash.js";
+export type { AllCommandName, CommandName, NetworkCommandName, PythonCommandName, } from "./commands/registry.js";
+export { getCommandNames, getNetworkCommandNames, getPythonCommandNames, } from "./commands/registry.js";
+export type { CustomCommand, CustomExecResult, LazyCommand, StringExecResult, } from "./custom-commands.js";
+export { defineCommand } from "./custom-commands.js";
+export { InMemoryFs } from "./fs/in-memory-fs/index.js";
+export type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry, FileInit, FileSystemFactory, FsEntry, FsStat, InitialFiles, MkdirOptions, RmOptions, SymlinkEntry, } from "./fs/interface.js";
+export { MountableFs, type MountableFsOptions, type MountConfig, } from "./fs/mountable-fs/index.js";
+export { OverlayFs, type OverlayFsOptions } from "./fs/overlay-fs/index.js";
+export { ReadWriteFs, type ReadWriteFsOptions, } from "./fs/read-write-fs/index.js";
+export type { NetworkConfig } from "./network/index.js";
+export { NetworkAccessDeniedError, RedirectNotAllowedError, TooManyRedirectsError, } from "./network/index.js";
+export type { CommandFinished as SandboxCommandFinished, OutputMessage, SandboxOptions, WriteFilesInput, } from "./sandbox/index.js";
+export { Command as SandboxCommand, Sandbox } from "./sandbox/index.js";
+export type { DefenseInDepthConfig, DefenseInDepthHandle, DefenseInDepthStats, SecurityViolation, SecurityViolationType, } from "./security/index.js";
+export { createConsoleViolationCallback, DefenseInDepthBox, SecurityViolationError, SecurityViolationLogger, } from "./security/index.js";
+export type { BashExecResult, Command, CommandContext, ExecResult, IFileSystem, } from "./types.js";
+export { decode, EMPTY, encode } from "./utils/bytes.js";

package/dist/interpreter/alias-expansion.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Alias Expansion
+ *
+ * Handles bash alias expansion for SimpleCommandNodes.
+ *
+ * Alias expansion rules:
+ * 1. Only expands if command name is a literal unquoted word
+ * 2. Alias value is substituted for the command name
+ * 3. If alias value ends with a space, the next word is also checked for alias expansion
+ * 4. Recursive expansion is allowed but limited to prevent infinite loops
+ */
+import type { SimpleCommandNode } from "../ast/types.js";
+/**
+ * Context needed for alias expansion operations
+ */
+export interface AliasExpansionContext {
+    env: Map<string, Uint8Array>;
+}
+/**
+ * Expand alias in a SimpleCommandNode if applicable.
+ * Returns a new node with the alias expanded, or the original node if no expansion.
+ */
+export declare function expandAlias(ctx: AliasExpansionContext, node: SimpleCommandNode, aliasExpansionStack: Set<string>): SimpleCommandNode;

package/dist/interpreter/arithmetic.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Arithmetic Evaluation
+ *
+ * Evaluates bash arithmetic expressions including:
+ * - Basic operators (+, -, *, /, %)
+ * - Comparison operators (<, <=, >, >=, ==, !=)
+ * - Bitwise operators (&, |, ^, ~, <<, >>)
+ * - Logical operators (&&, ||, !)
+ * - Assignment operators (=, +=, -=, etc.)
+ * - Ternary operator (? :)
+ * - Pre/post increment/decrement (++, --)
+ * - Nested arithmetic: $((expr))
+ * - Command substitution: $(cmd) or `cmd`
+ *
+ * Known limitations:
+ * - Bitwise operations use JavaScript's 32-bit signed integers, not 64-bit.
+ *   This means values like (1 << 31) will be negative (-2147483648) instead
+ *   of the bash 64-bit result (2147483648).
+ * - Dynamic arithmetic expressions (e.g., ${base}#a where base=16) are not
+ *   fully supported - variable expansion happens at parse time, not runtime.
+ */
+import type { ArithExpr } from "../ast/types.js";
+import type { InterpreterContext } from "./types.js";
+export declare function evaluateArithmetic(ctx: InterpreterContext, expr: ArithExpr, isExpansionContext?: boolean): Promise<number>;

package/dist/interpreter/assignment-expansion.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Assignment Expansion Helpers
+ *
+ * Handles expansion of assignment arguments for local/declare/typeset builtins.
+ * - Array assignments: name=(elem1 elem2 ...)
+ * - Scalar assignments: name=value, name+=value, name[index]=value
+ */
+import type { WordNode } from "../ast/types.js";
+import type { InterpreterContext } from "./types.js";
+/**
+ * Check if a Word represents an array assignment (name=(...)) and expand it
+ * while preserving quote structure for elements.
+ * Returns the expanded string like "name=(elem1 elem2 ...)" or null if not an array assignment.
+ */
+export declare function expandLocalArrayAssignment(ctx: InterpreterContext, word: WordNode): Promise<string | null>;
+/**
+ * Check if a Word represents a scalar assignment (name=value, name+=value, or name[index]=value)
+ * and expand it WITHOUT glob expansion on the value part.
+ * Returns the expanded string like "name=expanded_value" or null if not a scalar assignment.
+ *
+ * This is important for bash compatibility: `local var=$x` where x='a b' should
+ * set var to "a b", not try to glob-expand it.
+ */
+export declare function expandScalarAssignmentArg(ctx: InterpreterContext, word: WordNode): Promise<string | null>;

package/dist/interpreter/builtin-dispatch.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Builtin Command Dispatch
+ *
+ * Handles dispatch of built-in shell commands like export, unset, cd, etc.
+ * Separated from interpreter.ts for modularity.
+ */
+import type { ExecResult } from "../types.js";
+import type { InterpreterContext } from "./types.js";
+/**
+ * Type for the function that runs a command recursively
+ */
+export type RunCommandFn = (commandName: string, args: Uint8Array[], quotedArgs: boolean[], stdin: Uint8Array, skipFunctions?: boolean, useDefaultPath?: boolean, stdinSourceFd?: number) => Promise<ExecResult>;
+/**
+ * Type for the function that builds exported environment
+ */
+export type BuildExportedEnvFn = () => Record<string, string>;
+/**
+ * Type for the function that executes user scripts
+ */
+export type ExecuteUserScriptFn = (scriptPath: string, args: Uint8Array[], stdin?: Uint8Array) => Promise<ExecResult>;
+/**
+ * Dispatch context containing dependencies needed for builtin dispatch
+ */
+export interface BuiltinDispatchContext {
+    ctx: InterpreterContext;
+    runCommand: RunCommandFn;
+    buildExportedEnv: BuildExportedEnvFn;
+    executeUserScript: ExecuteUserScriptFn;
+}
+/**
+ * Dispatch a command to the appropriate builtin handler or external command.
+ * Returns null if the command should be handled by external command resolution.
+ */
+export declare function dispatchBuiltin(dispatchCtx: BuiltinDispatchContext, commandName: string, args: Uint8Array[], _quotedArgs: boolean[], stdin: Uint8Array, skipFunctions: boolean, _useDefaultPath: boolean, stdinSourceFd: number): Promise<ExecResult | null>;
+/**
+ * Handle external command resolution and execution.
+ * Called when dispatchBuiltin returns null.
+ */
+export declare function executeExternalCommand(dispatchCtx: BuiltinDispatchContext, commandName: string, args: Uint8Array[], stdin: Uint8Array, useDefaultPath: boolean): Promise<ExecResult>;

package/dist/interpreter/builtins/break.d.ts

@@ -0,0 +1,6 @@
+/**
+ * break - Exit from loops builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleBreak(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/cd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * cd - Change directory builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleCd(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/compgen.d.ts

@@ -0,0 +1,26 @@
+/**
+ * compgen - Generate completion matches
+ *
+ * Usage:
+ *   compgen -v [prefix]         - List variable names (optionally starting with prefix)
+ *   compgen -A variable [prefix] - Same as -v
+ *   compgen -A function [prefix] - List function names
+ *   compgen -e [prefix]          - List exported variable names
+ *   compgen -A builtin [prefix]  - List builtin command names
+ *   compgen -A keyword [prefix]  - List shell keywords (alias: -k)
+ *   compgen -A alias [prefix]    - List alias names
+ *   compgen -A shopt [prefix]    - List shopt options
+ *   compgen -A helptopic [prefix] - List help topics
+ *   compgen -A directory [prefix] - List directory names
+ *   compgen -A file [prefix]      - List file names
+ *   compgen -f [prefix]           - List file names (alias for -A file)
+ *   compgen -A user               - List user names
+ *   compgen -A command [prefix]   - List commands (builtins, functions, aliases, external)
+ *   compgen -W wordlist [prefix]  - Generate from wordlist
+ *   compgen -P prefix             - Prefix to add to completions
+ *   compgen -S suffix             - Suffix to add to completions
+ *   compgen -o option             - Completion option (plusdirs, dirnames, default, etc.)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleCompgen(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/complete.d.ts

@@ -0,0 +1,17 @@
+/**
+ * complete - Set and display programmable completion specifications
+ *
+ * Usage:
+ *   complete                        - List all completion specs
+ *   complete -p                     - Print all completion specs in reusable format
+ *   complete -p cmd                 - Print completion spec for specific command
+ *   complete -W 'word1 word2' cmd   - Set word list completion for cmd
+ *   complete -F func cmd            - Set function completion for cmd
+ *   complete -r cmd                 - Remove completion spec for cmd
+ *   complete -r                     - Remove all completion specs
+ *   complete -D ...                 - Set default completion (for commands with no specific spec)
+ *   complete -o opt cmd             - Set completion options (nospace, filenames, default, etc.)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleComplete(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/compopt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * compopt - Modify completion options
+ *
+ * Usage:
+ *   compopt [-o option] [+o option] [name ...]
+ *   compopt -D [-o option] [+o option]
+ *   compopt -E [-o option] [+o option]
+ *
+ * Modifies completion options for the specified commands (names) or the
+ * currently executing completion when no names are provided.
+ *
+ * Options:
+ *   -o option  Enable completion option
+ *   +o option  Disable completion option
+ *   -D         Apply to default completion
+ *   -E         Apply to empty-line completion
+ *
+ * Valid completion options:
+ *   bashdefault, default, dirnames, filenames, noquote, nosort, nospace, plusdirs
+ *
+ * Returns:
+ *   0 on success
+ *   1 if not in a completion function and no command name is given
+ *   2 if an invalid option is specified
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleCompopt(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/continue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * continue - Skip to next loop iteration builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleContinue(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/declare-array-parsing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Array Parsing Functions for declare/typeset
+ *
+ * Handles parsing of array literal syntax for the declare builtin.
+ */
+/**
+ * Parse array elements from content like "1 2 3" or "'a b' c d"
+ */
+export declare function parseArrayElements(content: string): string[];
+/**
+ * Parse associative array literal content like "['foo']=bar ['spam']=42"
+ * Returns array of [key, value] pairs
+ */
+export declare function parseAssocArrayLiteral(content: string): [string, string][];

package/dist/interpreter/builtins/declare-print.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Declare Print Mode Functions
+ *
+ * Handles printing and listing variables for the declare/typeset builtin.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Print specific variables with their declarations.
+ * Handles: declare -p varname1 varname2 ...
+ */
+export declare function printSpecificVariables(ctx: InterpreterContext, names: string[]): ExecResult;
+export interface PrintAllFilters {
+    filterExport: boolean;
+    filterReadonly: boolean;
+    filterNameref: boolean;
+    filterIndexedArray: boolean;
+    filterAssocArray: boolean;
+}
+/**
+ * Print all variables with their declarations and attributes.
+ * Handles: declare -p (with optional filters like -x, -r, -n, -a, -A)
+ */
+export declare function printAllVariables(ctx: InterpreterContext, filters: PrintAllFilters): ExecResult;
+/**
+ * List all associative arrays.
+ * Handles: declare -A (without arguments)
+ */
+export declare function listAssociativeArrays(ctx: InterpreterContext): ExecResult;
+/**
+ * List all indexed arrays.
+ * Handles: declare -a (without arguments)
+ */
+export declare function listIndexedArrays(ctx: InterpreterContext): ExecResult;
+/**
+ * List all variables without print mode (no attributes shown).
+ * Handles: declare (without -p and without arguments)
+ */
+export declare function listAllVariables(ctx: InterpreterContext): ExecResult;

package/dist/interpreter/builtins/declare.d.ts

@@ -0,0 +1,35 @@
+/**
+ * declare/typeset - Declare variables and give them attributes
+ *
+ * Usage:
+ *   declare              - List all variables
+ *   declare -p           - List all variables (same as no args)
+ *   declare NAME=value   - Declare variable with value
+ *   declare -a NAME      - Declare indexed array
+ *   declare -A NAME      - Declare associative array
+ *   declare -r NAME      - Declare readonly variable
+ *   declare -x NAME      - Export variable
+ *   declare -g NAME      - Declare global variable (inside functions)
+ *
+ * Also aliased as 'typeset'
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Check if a variable has the integer attribute.
+ */
+export declare function isInteger(ctx: InterpreterContext, name: string): boolean;
+/**
+ * Apply case transformation based on variable attributes.
+ * Returns the transformed value.
+ */
+export declare function applyCaseTransform(ctx: InterpreterContext, name: string, value: string): string;
+export declare function handleDeclare(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+/**
+ * readonly - Declare readonly variables
+ *
+ * Usage:
+ *   readonly NAME=value   - Declare readonly variable
+ *   readonly NAME         - Mark existing variable as readonly
+ */
+export declare function handleReadonly(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;