just-bash 2.5.5 → 2.7.0

package/dist/commands/time/time.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from "../../types.js";
+/**
+ * time - time command execution
+ *
+ * Usage: time [-f FORMAT] [-o FILE] [-a] [-v] [-p] command [arguments...]
+ *
+ * Times the execution of a command and outputs timing statistics.
+ *
+ * Options:
+ *   -f FORMAT    Use FORMAT for output (GNU time format specifiers)
+ *   -o FILE      Write timing output to FILE
+ *   -a           Append to output file (with -o)
+ *   -v           Verbose output
+ *   -p           POSIX portable output format
+ *
+ * Format specifiers:
+ *   %e    Elapsed real time in seconds
+ *   %M    Maximum resident set size (KB)
+ *   %S    System CPU time (seconds)
+ *   %U    User CPU time (seconds)
+ *
+ * Note: In this JavaScript implementation, user/system CPU time and memory
+ * metrics are not available, so %M, %S, %U output 0.
+ */
+export declare const timeCommand: Command;

package/dist/commands/whoami/whoami.d.ts

@@ -0,0 +1,9 @@
+/**
+ * whoami - print effective user name
+ *
+ * Usage: whoami
+ *
+ * In sandboxed environment, always returns "user".
+ */
+import type { Command } from "../../types.js";
+export declare const whoami: Command;

package/dist/commands/xan/moonblade-tokenizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Moonblade expression tokenizer
+ */
+export type TokenType = "int" | "float" | "string" | "regex" | "ident" | "true" | "false" | "null" | "(" | ")" | "[" | "]" | "{" | "}" | "," | ":" | ";" | "=>" | "+" | "-" | "*" | "/" | "//" | "%" | "**" | "++" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "&&" | "||" | "and" | "or" | "!" | "." | "|" | "in" | "not in" | "as" | "=" | "_" | "eof";
+export interface Token {
+    type: TokenType;
+    value: string;
+    pos: number;
+}
+export declare class Tokenizer {
+    private input;
+    private pos;
+    private tokens;
+    constructor(input: string);
+    tokenize(): Token[];
+    private skipWhitespace;
+    private nextToken;
+    private match;
+    private isIdentStart;
+    private isIdentChar;
+    private readNumber;
+    private readString;
+    private readRegex;
+    private readIdentifier;
+}

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

@@ -48,4 +48,16 @@ export declare class InMemoryFs implements IFileSystem {
     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/interface.d.ts

@@ -184,6 +184,22 @@ export interface IFileSystem {
      * @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

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

@@ -101,8 +101,20 @@ export declare class MountableFs implements IFileSystem {
     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/overlay-fs.d.ts

@@ -4,8 +4,8 @@
  * 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";
-import { type FileContent } from "../utils.js";
 export interface OverlayFsOptions {
     /**
      * The root directory on the real filesystem.
@@ -104,4 +104,16 @@ export declare class OverlayFs implements IFileSystem {
     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/read-write-fs.d.ts

@@ -4,8 +4,8 @@
  * All operations go directly to the underlying Node.js filesystem.
  * This is a true read-write filesystem with no overlay or sandboxing.
  */
+import { type FileContent } from "../encoding.js";
 import type { CpOptions, DirentEntry, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
-import { type FileContent } from "../utils.js";
 export interface ReadWriteFsOptions {
     /**
      * The root directory on the real filesystem.
@@ -44,4 +44,16 @@ export declare class ReadWriteFs implements IFileSystem {
     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/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: Record<string, string | undefined>;
+}
+/**
+ * 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

@@ -21,9 +21,4 @@
  */
 import type { ArithExpr } from "../ast/types.js";
 import type { InterpreterContext } from "./types.js";
-/**
- * Synchronous version of evaluateArithmetic for simple expressions.
- * Does not support command substitution - those will return 0.
- */
-export declare function evaluateArithmeticSync(ctx: InterpreterContext, expr: ArithExpr): number;
-export declare function evaluateArithmetic(ctx: InterpreterContext, expr: ArithExpr): Promise<number>;
+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: string[], quotedArgs: boolean[], stdin: string, 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: string[], stdin?: string) => 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: string[], _quotedArgs: boolean[], stdin: string, 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: string[], stdin: string, useDefaultPath: boolean): 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/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

@@ -9,16 +9,22 @@
  *   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";
-export declare function handleDeclare(ctx: InterpreterContext, args: string[]): ExecResult;
 /**
- * Parse array elements from content like "1 2 3" or "'a b' c d"
+ * Check if a variable has the integer attribute.
  */
-export declare function parseArrayElements(content: string): string[];
+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
  *
@@ -26,4 +32,4 @@ export declare function parseArrayElements(content: string): string[];
  *   readonly NAME=value   - Declare readonly variable
  *   readonly NAME         - Mark existing variable as readonly
  */
-export declare function handleReadonly(ctx: InterpreterContext, args: string[]): ExecResult;
+export declare function handleReadonly(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

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

@@ -0,0 +1,29 @@
+/**
+ * Directory Stack Builtins: pushd, popd, dirs
+ *
+ * pushd [dir] - Push directory onto stack and cd to it
+ * popd - Pop directory from stack and cd to previous
+ * dirs [-clpv] - Display directory stack
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * pushd - Push directory onto stack and cd to it
+ *
+ * pushd [dir] - Push current dir, cd to dir
+ */
+export declare function handlePushd(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+/**
+ * popd - Pop directory from stack and cd to it
+ */
+export declare function handlePopd(ctx: InterpreterContext, args: string[]): ExecResult;
+/**
+ * dirs - Display directory stack
+ *
+ * dirs [-clpv]
+ *   -c: Clear the stack
+ *   -l: Long format (no tilde substitution)
+ *   -p: One entry per line
+ *   -v: One entry per line with index numbers
+ */
+export declare function handleDirs(ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -6,4 +6,4 @@
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleEval(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+export declare function handleEval(ctx: InterpreterContext, args: string[], stdin?: string): Promise<ExecResult>;

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

@@ -5,6 +5,7 @@
  *   export              - List all exported variables
  *   export -p           - List all exported variables (same as no args)
  *   export NAME=value   - Set and export variable
+ *   export NAME+=value  - Append value and export variable
  *   export NAME         - Export existing variable (or create empty)
  *   export -n NAME      - Un-export variable (remove from env)
  */

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

@@ -0,0 +1,18 @@
+/**
+ * getopts - Parse positional parameters as options
+ *
+ * getopts optstring name [arg...]
+ *
+ * Parses options from positional parameters (or provided args).
+ * - optstring: string of valid option characters
+ * - If a character is followed by ':', it requires an argument
+ * - If optstring starts with ':', silent error reporting mode
+ * - name: variable to store the current option
+ * - OPTARG: set to the option argument (if any)
+ * - OPTIND: index of next argument to process (starts at 1)
+ *
+ * Returns 0 if option found, 1 if end of options or error.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleGetopts(ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -0,0 +1,19 @@
+/**
+ * hash - Manage the hash table of remembered command locations
+ *
+ * hash [-lr] [-p pathname] [-dt] [name ...]
+ *
+ * Hash maintains a hash table of recently executed commands for faster lookup.
+ *
+ * Options:
+ *   (no args)  Display the hash table
+ *   name       Add name to the hash table (look up in PATH)
+ *   -r         Clear the hash table
+ *   -d name    Remove name from the hash table
+ *   -l         Display in a format that can be reused as input
+ *   -p path    Use path as the full pathname for name (hash -p /path name)
+ *   -t name    Print the remembered location of name
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHash(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

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

@@ -0,0 +1,12 @@
+/**
+ * help - Display helpful information about builtin commands
+ *
+ * Usage: help [-s] [pattern ...]
+ *
+ * If PATTERN is specified, gives detailed help on all commands matching PATTERN,
+ * otherwise a list of the builtins is printed. The -s option restricts the output
+ * for each builtin command matching PATTERN to a short usage synopsis.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHelp(_ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -21,11 +21,18 @@
  */
 export { handleBreak } from "./break.js";
 export { handleCd } from "./cd.js";
+export { handleCompgen } from "./compgen.js";
+export { handleComplete } from "./complete.js";
+export { handleCompopt } from "./compopt.js";
 export { handleContinue } from "./continue.js";
-export { handleDeclare, handleReadonly } from "./declare.js";
+export { applyCaseTransform, handleDeclare, handleReadonly, isInteger, } from "./declare.js";
+export { handleDirs, handlePopd, handlePushd } from "./dirs.js";
 export { handleEval } from "./eval.js";
 export { handleExit } from "./exit.js";
 export { handleExport } from "./export.js";
+export { handleGetopts } from "./getopts.js";
+export { handleHash } from "./hash.js";
+export { handleHelp } from "./help.js";
 export { handleLet } from "./let.js";
 export { handleLocal } from "./local.js";
 export { handleMapfile } from "./mapfile.js";
@@ -35,3 +42,4 @@ export { handleSet } from "./set.js";
 export { handleShift } from "./shift.js";
 export { handleSource } from "./source.js";
 export { handleUnset } from "./unset.js";
+export { getLocalVarDepth } from "./variable-assignment.js";

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

@@ -3,4 +3,4 @@
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleLocal(ctx: InterpreterContext, args: string[]): ExecResult;
+export declare function handleLocal(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

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

@@ -3,4 +3,4 @@
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleRead(ctx: InterpreterContext, args: string[], stdin: string): ExecResult;
+export declare function handleRead(ctx: InterpreterContext, args: string[], stdin: string, stdinSourceFd?: number): ExecResult;

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

@@ -1,5 +1,8 @@
 /**
  * set - Set/unset shell options builtin
+ *
+ * In POSIX mode (set -o posix), errors from set (like invalid options)
+ * cause the script to exit immediately.
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";

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

@@ -6,6 +6,9 @@
  * Shifts positional parameters to the left by n (default 1).
  * $n+1 becomes $1, $n+2 becomes $2, etc.
  * $# is decremented by n.
+ *
+ * In POSIX mode (set -o posix), errors from shift (like shift count
+ * exceeding available parameters) cause the script to exit immediately.
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";

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

@@ -0,0 +1,7 @@
+/**
+ * shopt builtin - Shell options
+ * Implements bash's shopt builtin for managing shell-specific options
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleShopt(ctx: InterpreterContext, args: string[]): ExecResult;

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

@@ -6,7 +6,11 @@
  * - unset -v VAR - remove variable (explicit)
  * - unset -f FUNC - remove function
  * - unset 'a[i]' - remove array element (with arithmetic index support)
+ *
+ * Bash-specific unset scoping:
+ * - local-unset (same scope): value-unset - clears value but keeps local cell
+ * - dynamic-unset (different scope): cell-unset - removes local cell, exposes outer value
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleUnset(ctx: InterpreterContext, args: string[]): ExecResult;
+export declare function handleUnset(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;