just-binary 3.2.5 → 3.3.0

package/dist/index.d.ts

@@ -9,8 +9,12 @@ export type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry,
 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 { AbortExecutionError, checkAborted, } from "./interpreter/errors.js";
+export type { OutputSink } from "./interpreter/output-channels.js";
 export type { NetworkConfig } from "./network/index.js";
 export { NetworkAccessDeniedError, RedirectNotAllowedError, TooManyRedirectsError, } from "./network/index.js";
+export type { JobInfo, JobRunner, JobSignal, ListedJob, ProcessTableOptions, } from "./process/process-table.js";
+export { ProcessTable } from "./process/process-table.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";

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

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

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

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

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

@@ -2,4 +2,4 @@
  * exit - Exit shell builtin
  */
 import type { InterpreterContext } from "../types.js";
-export declare function handleExit(ctx: InterpreterContext, args: string[]): never;
+export declare function handleExit(ctx: InterpreterContext, args: string[]): Promise<never>;

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

@@ -33,6 +33,8 @@ export { handleExport } from "./export.js";
 export { handleGetopts } from "./getopts.js";
 export { handleHash } from "./hash.js";
 export { handleHelp } from "./help.js";
+export { handleJobs } from "./jobs.js";
+export { handleKill } from "./kill.js";
 export { handleLet } from "./let.js";
 export { handleLocal } from "./local.js";
 export { handleMapfile } from "./mapfile.js";
@@ -43,3 +45,4 @@ export { handleShift } from "./shift.js";
 export { handleSource } from "./source.js";
 export { handleUnset } from "./unset.js";
 export { getLocalVarDepth } from "./variable-assignment.js";
+export { handleWait } from "./wait.js";

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

@@ -0,0 +1,5 @@
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+type RunJobsCommand = (command: string, args: string[]) => Promise<ExecResult>;
+export declare function handleJobs(ctx: InterpreterContext, args: string[], runCommand?: RunJobsCommand): Promise<ExecResult>;
+export {};

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

@@ -0,0 +1,3 @@
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleKill(ctx: InterpreterContext, args: string[]): ExecResult;

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

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

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

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

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

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

package/dist/interpreter/errors.d.ts

@@ -8,22 +8,11 @@
  * - errexit: Exit on error (set -e)
  * - nounset: Error on unset variables (set -u)
  *
- * All control flow errors carry stdout/stderr ByteStreams to accumulate
- * output as they propagate through the execution stack.
  */
-import type { ByteStream } from "../utils/stream.js";
 /**
  * Base class for all control flow errors.
- * Carries stdout/stderr to preserve output during propagation.
  */
 declare abstract class ControlFlowError extends Error {
-    stdout: ByteStream;
-    stderr: ByteStream;
-    constructor(message: string, stdout?: ByteStream, stderr?: ByteStream);
-    /**
-     * Prepend output from the current context before re-throwing.
-     */
-    prependOutput(stdout: ByteStream, stderr: ByteStream): void;
 }
 /**
  * Error thrown when break is called to exit loops.
@@ -31,7 +20,7 @@ declare abstract class ControlFlowError extends Error {
 export declare class BreakError extends ControlFlowError {
     levels: number;
     readonly name = "BreakError";
-    constructor(levels?: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(levels?: number);
 }
 /**
  * Error thrown when continue is called to skip to next iteration.
@@ -39,7 +28,7 @@ export declare class BreakError extends ControlFlowError {
 export declare class ContinueError extends ControlFlowError {
     levels: number;
     readonly name = "ContinueError";
-    constructor(levels?: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(levels?: number);
 }
 /**
  * Error thrown when return is called to exit a function.
@@ -47,7 +36,7 @@ export declare class ContinueError extends ControlFlowError {
 export declare class ReturnError extends ControlFlowError {
     exitCode: number;
     readonly name = "ReturnError";
-    constructor(exitCode?: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(exitCode?: number);
 }
 /**
  * Error thrown when set -e (errexit) is enabled and a command fails.
@@ -55,7 +44,7 @@ export declare class ReturnError extends ControlFlowError {
 export declare class ErrexitError extends ControlFlowError {
     readonly exitCode: number;
     readonly name = "ErrexitError";
-    constructor(exitCode: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(exitCode: number);
 }
 /**
  * Error thrown when set -u (nounset) is enabled and an unset variable is referenced.
@@ -63,7 +52,7 @@ export declare class ErrexitError extends ControlFlowError {
 export declare class NounsetError extends ControlFlowError {
     varName: string;
     readonly name = "NounsetError";
-    constructor(varName: string, stdout?: ByteStream);
+    constructor(varName: string);
 }
 /**
  * Error thrown when exit builtin is called to terminate the script.
@@ -71,20 +60,21 @@ export declare class NounsetError extends ControlFlowError {
 export declare class ExitError extends ControlFlowError {
     readonly exitCode: number;
     readonly name = "ExitError";
-    constructor(exitCode: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(exitCode: number);
 }
 /**
  * Error thrown for arithmetic expression errors (e.g., floating point, invalid syntax).
  * Returns exit code 1 instead of 2 (syntax error).
  */
 export declare class ArithmeticError extends ControlFlowError {
+    readonly reportDiagnostic: boolean;
     readonly name = "ArithmeticError";
     /**
      * If true, this error should abort script execution (like missing operand after binary operator).
      * If false, the error is recoverable and execution can continue.
      */
     fatal: boolean;
-    constructor(message: string, stdout?: ByteStream, stderr?: ByteStream, fatal?: boolean);
+    constructor(message: string, fatal?: boolean, reportDiagnostic?: boolean);
 }
 /**
  * Error thrown for bad substitution errors (e.g., ${#var:1:3}).
@@ -92,15 +82,15 @@ export declare class ArithmeticError extends ControlFlowError {
  */
 export declare class BadSubstitutionError extends ControlFlowError {
     readonly name = "BadSubstitutionError";
-    constructor(message: string, stdout?: ByteStream, stderr?: ByteStream);
 }
 /**
  * Error thrown when failglob is enabled and a glob pattern has no matches.
  * Returns exit code 1.
  */
 export declare class GlobError extends ControlFlowError {
+    readonly pattern: string;
     readonly name = "GlobError";
-    constructor(pattern: string, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(pattern: string);
 }
 /**
  * Error thrown for invalid brace expansions (e.g., mixed case character ranges like {z..A}).
@@ -108,7 +98,6 @@ export declare class GlobError extends ControlFlowError {
  */
 export declare class BraceExpansionError extends ControlFlowError {
     readonly name = "BraceExpansionError";
-    constructor(message: string, stdout?: ByteStream, stderr?: ByteStream);
 }
 /**
  * Error thrown when execution limits are exceeded (recursion depth, command count, loop iterations).
@@ -116,18 +105,48 @@ export declare class BraceExpansionError extends ControlFlowError {
  * Exit code 126 indicates a limit was exceeded.
  */
 export declare class ExecutionLimitError extends ControlFlowError {
-    readonly limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth";
-    readonly name = "ExecutionLimitError";
+    readonly limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth" | "aborted";
+    readonly name: string;
     static readonly EXIT_CODE = 126;
-    constructor(message: string, limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth", stdout?: ByteStream, stderr?: ByteStream);
+    constructor(message: string, limitType: "recursion" | "commands" | "iterations" | "string_length" | "glob_operations" | "substitution_depth" | "aborted");
 }
+/**
+ * Map an AbortSignal reason to the exit code a killed process would have.
+ * Matches real shell conventions: 128 + signal number.
+ */
+export declare function abortExitCode(reason: unknown): number;
+/**
+ * Error thrown when execution is cancelled via ExecOptions.signal.
+ *
+ * Extends ExecutionLimitError so every existing "safety limits must always
+ * propagate" rethrow site treats cancellation the same way: it unwinds the
+ * whole execution instead of being converted to a local exit code.
+ *
+ * Unlike limit errors, aborted commands die silently (like a killed process).
+ *
+ * Numeric signal reasons map to 128 + signal. String reasons
+ * "SIGINT"/"SIGKILL"/"SIGTERM" map to 130/137/143,
+ * AbortSignal.timeout()'s TimeoutError maps to 124, and anything else defaults
+ * to 143 (killed by SIGTERM).
+ */
+export declare class AbortExecutionError extends ExecutionLimitError {
+    readonly name: string;
+    readonly exitCode: number;
+    constructor(reason: unknown);
+}
+/**
+ * Throw AbortExecutionError if the signal has been aborted.
+ * Cooperative cancellation check — called at statement dispatch and loop
+ * guards, and by leaf commands before/after long waits.
+ */
+export declare function checkAborted(signal: AbortSignal | undefined): void;
 /**
  * Error thrown when break/continue is called in a subshell that was
  * spawned from within a loop context. Causes the subshell to exit cleanly.
  */
 export declare class SubshellExitError extends ControlFlowError {
     readonly name = "SubshellExitError";
-    constructor(stdout?: ByteStream, stderr?: ByteStream);
+    constructor();
 }
 /**
  * Type guard for errors that exit the current scope (return, break, continue).
@@ -140,6 +159,6 @@ export declare function isScopeExitError(error: unknown): error is BreakError |
 export declare class PosixFatalError extends ControlFlowError {
     readonly exitCode: number;
     readonly name = "PosixFatalError";
-    constructor(exitCode: number, stdout?: ByteStream, stderr?: ByteStream);
+    constructor(exitCode: number);
 }
 export {};

package/dist/interpreter/functions.d.ts

@@ -9,5 +9,5 @@ import type { FunctionDefNode } from "../ast/types.js";
 import type { ExecResult } from "../types.js";
 import { type ByteStream } from "../utils/stream.js";
 import type { InterpreterContext } from "./types.js";
-export declare function executeFunctionDef(ctx: InterpreterContext, node: FunctionDefNode): ExecResult;
+export declare function executeFunctionDef(ctx: InterpreterContext, node: FunctionDefNode): Promise<ExecResult>;
 export declare function callFunction(ctx: InterpreterContext, func: FunctionDefNode, args: string[], stdin?: ByteStream, callLine?: number): Promise<ExecResult>;

package/dist/interpreter/helpers/condition.d.ts

@@ -13,6 +13,6 @@ import type { InterpreterContext } from "../types.js";
  *
  * @param ctx - Interpreter context
  * @param statements - Condition statements to execute
- * @returns Accumulated stdout, stderr, and final exit code
+ * @returns Empty streams and the final exit code
  */
 export declare function executeCondition(ctx: InterpreterContext, statements: StatementNode[]): Promise<ExecResult>;

package/dist/interpreter/helpers/loop.d.ts

@@ -4,12 +4,9 @@
  * Consolidates the repeated error handling logic used in all loop constructs
  * (for, c-style for, while, until).
  */
-import { type ByteStream } from "../../utils/stream.js";
 export type LoopAction = "break" | "continue" | "rethrow" | "error";
 export interface LoopErrorResult {
     action: LoopAction;
-    stdout: ByteStream;
-    stderr: ByteStream;
     exitCode?: number;
     error?: unknown;
 }
@@ -17,9 +14,7 @@ export interface LoopErrorResult {
  * Handle errors thrown during loop body execution.
  *
  * @param error - The caught error
- * @param stdout - Current accumulated stdout
- * @param stderr - Current accumulated stderr
  * @param loopDepth - Current loop nesting depth from ctx.state.loopDepth
  * @returns Result indicating what action the loop should take
  */
-export declare function handleLoopError(error: unknown, stdout: ByteStream, stderr: ByteStream, loopDepth: number): LoopErrorResult;
+export declare function handleLoopError(error: unknown, loopDepth: number): LoopErrorResult;

package/dist/interpreter/helpers/readonly.d.ts

@@ -28,7 +28,7 @@ export declare function isReadonly(ctx: InterpreterContext, name: string): boole
  * @returns null if variable is not readonly (can be modified)
  * @throws ExitError if variable is readonly
  */
-export declare function checkReadonlyError(ctx: InterpreterContext, name: string, command?: string): ExecResult | null;
+export declare function checkReadonlyError(ctx: InterpreterContext, name: string, command?: string): Promise<ExecResult | null>;
 /**
  * Mark a variable as exported.
  *

package/dist/interpreter/helpers/result.d.ts

@@ -45,4 +45,4 @@ export declare function testResult(passed: boolean): ExecResult;
 /**
  * Throw an ExecutionLimitError for execution limits (recursion, iterations, commands).
  */
-export declare function throwExecutionLimit(message: string, limitType: "recursion" | "iterations" | "commands", stdout?: Uint8Array | ByteStream, stderr?: Uint8Array | ByteStream): never;
+export declare function throwExecutionLimit(message: string, limitType: "recursion" | "iterations" | "commands"): never;

package/dist/interpreter/helpers/statements.d.ts

@@ -6,7 +6,6 @@
  */
 import type { StatementNode } from "../../ast/types.js";
 import type { ExecResult } from "../../types.js";
-import { type ByteStream } from "../../utils/stream.js";
 import type { InterpreterContext } from "../types.js";
 /**
  * Execute a list of statements and accumulate their output.
@@ -14,8 +13,6 @@ import type { InterpreterContext } from "../types.js";
  *
  * @param ctx - Interpreter context
  * @param statements - Statements to execute
- * @param initialStdout - Initial stdout to prepend (default empty)
- * @param initialStderr - Initial stderr to prepend (default empty)
- * @returns Accumulated stdout, stderr, and final exit code
+ * @returns Empty streams and the final exit code
  */
-export declare function executeStatements(ctx: InterpreterContext, statements: StatementNode[], initialStdout?: ByteStream, initialStderr?: ByteStream): Promise<ExecResult>;
+export declare function executeStatements(ctx: InterpreterContext, statements: StatementNode[]): Promise<ExecResult>;

package/dist/interpreter/index.d.ts

@@ -1,3 +1,3 @@
 export type { InterpreterOptions } from "./interpreter.js";
 export { Interpreter } from "./interpreter.js";
-export type { InterpreterContext, InterpreterState, ShellOptions, } from "./types.js";
+export type { InterpreterContext, InterpreterState, JobExecutionTracker, ShellOptions, } from "./types.js";

package/dist/interpreter/interpreter.d.ts

@@ -13,27 +13,36 @@ import type { ScriptNode } from "../ast/types.js";
 import type { IFileSystem } from "../fs/interface.js";
 import type { ExecutionLimits } from "../limits.js";
 import type { SecureFetch } from "../network/index.js";
+import type { ProcessTable } from "../process/process-table.js";
 import type { CommandRegistry, ExecResult, FeatureCoverageWriter, TraceCallback } from "../types.js";
 import { type ByteStream } from "../utils/stream.js";
-import type { InterpreterState } from "./types.js";
+import { type OutputChannels } from "./output-channels.js";
+import type { InterpreterState, JobExecutionTracker } from "./types.js";
 export type { InterpreterContext, InterpreterState } from "./types.js";
 export interface InterpreterOptions {
     fs: IFileSystem;
     commands: CommandRegistry;
+    processes: ProcessTable;
+    lineageId: number;
+    outputChannels: OutputChannels;
     limits: Required<ExecutionLimits>;
+    jobTracker: JobExecutionTracker;
     exec: (script: string, options?: {
         env?: Record<string, string>;
         cwd?: string;
         stdin?: ByteStream;
+        signal?: AbortSignal;
     }) => Promise<ExecResult>;
     /** Optional secure fetch function for network-enabled commands */
     fetch?: SecureFetch;
     /** Optional sleep function for testing with mock clocks */
-    sleep?: (ms: number) => Promise<void>;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     /** Optional trace callback for performance profiling */
     trace?: TraceCallback;
     /** Optional feature coverage writer for fuzzing instrumentation */
     coverage?: FeatureCoverageWriter;
+    /** Abort signal for this execution (from ExecOptions.signal) */
+    signal?: AbortSignal;
 }
 export declare class Interpreter {
     private ctx;
@@ -42,6 +51,7 @@ export declare class Interpreter {
      * Build environment record containing only exported variables.
      */
     private buildExportedEnv;
+    executeRootScript(node: ScriptNode): Promise<ExecResult>;
     executeScript(node: ScriptNode): Promise<ExecResult>;
     /**
      * Execute a user script file found in PATH.

package/dist/interpreter/output-channels.d.ts

@@ -0,0 +1,50 @@
+import type { ExecResult } from "../types.js";
+import { type ByteStream } from "../utils/stream.js";
+import type { InterpreterContext } from "./types.js";
+export interface OutputSink {
+    /** Implementations must serialize writes (fd 1 and fd 2 may alias one sink after 2>&1). */
+    write(chunk: Uint8Array): void | Promise<void>;
+}
+/** One fd's binding. An absent sink with a descriptor records a closed fd. */
+export interface ChannelBinding {
+    sink?: OutputSink;
+    descriptor?: string;
+}
+export interface OutputChannels {
+    bindings: Map<number, ChannelBinding>;
+    /** Enclosing table when this one is a temporary redirection scope. */
+    parent?: OutputChannels;
+    /** Fds whose bindings this temporary scope overrode. */
+    overrides?: Set<number>;
+}
+export interface OutputCollector extends OutputSink {
+    /** Decode the accumulated bytes without consuming the collector. */
+    text(): string;
+    /** Snapshot the accumulated bytes without consuming the collector. */
+    stream(): ByteStream;
+    /** Release retained bytes and forward future writes without buffering them. */
+    seal(): void;
+    /** Bytes currently retained for the next snapshot. */
+    readonly retainedByteLength: number;
+}
+export declare const CLOSED_CHANNEL_DESCRIPTOR = "__closed__";
+export declare function cloneOutputChannels(channels: OutputChannels, wrapSink?: (fd: number, sink: OutputSink) => OutputSink): OutputChannels;
+export declare function overrideChannelSink(channels: OutputChannels, fd: number, sink: OutputSink): void;
+export declare function hasChannelBinding(channels: OutputChannels, fd: number): boolean;
+export declare function isChannelClosed(channels: OutputChannels, fd: number): boolean;
+export declare function setPersistentChannel(channels: OutputChannels, fd: number, sink: OutputSink | undefined, descriptor: string): void;
+export declare function deletePersistentChannel(channels: OutputChannels, fd: number): boolean;
+export declare function writeToChannel(ctx: InterpreterContext, fd: number, chunk: Uint8Array | string, failClosed?: boolean): Promise<void>;
+export declare function createCollector(forward?: OutputSink, retain?: boolean): OutputCollector;
+export declare function withChannels<T>(ctx: InterpreterContext, channels: OutputChannels, fn: () => T | Promise<T>): Promise<T>;
+export declare function pumpStream(ctx: InterpreterContext, stream: ByteStream, sink: OutputSink, checkSignal?: boolean): Promise<void>;
+export declare function pumpResult(ctx: InterpreterContext, result: ExecResult, checkSignal?: boolean, outputFds?: readonly (1 | 2)[]): Promise<ExecResult>;
+/**
+ * Write a control-flow diagnostic to the active fd 2 exactly once.
+ */
+export declare function writeErrorDiagnostic(ctx: InterpreterContext, error: unknown, outputFds?: readonly (1 | 2)[]): Promise<boolean>;
+export declare function writeErrorDiagnosticWithWriteFailure(ctx: InterpreterContext, error: unknown, outputFds?: readonly (1 | 2)[]): Promise<{
+    writeFailure: ExecResult | null;
+    diagnosticWritten: boolean;
+}>;
+export declare function executeAndPumpResult(ctx: InterpreterContext, execute: () => Promise<ExecResult>, outputFds?: readonly (1 | 2)[]): Promise<ExecResult>;

package/dist/interpreter/redirect-channels.d.ts

@@ -0,0 +1,34 @@
+import type { RedirectionNode } from "../ast/types.js";
+import type { ExecResult } from "../types.js";
+import { type OutputChannels } from "./output-channels.js";
+import type { InterpreterContext } from "./types.js";
+export interface CompiledOutputRedirections {
+    channels: OutputChannels;
+    legacyRedirections: RedirectionNode[];
+    error?: ExecResult;
+}
+interface CompileOptions {
+    persistent?: boolean;
+    /** Bash fails to restore the moved source fd after running a builtin. */
+    persistMovedSource?: boolean;
+}
+/**
+ * Compile output redirections into a fresh channel table.
+ *
+ * Ordinary input redirections are opened in source order, then returned for
+ * the legacy caller to consume. Opening them here makes the first failure stop
+ * compilation before any later file sink is installed. FD-variable input
+ * redirections are processed inline so descriptor allocation also preserves
+ * source order.
+ */
+export declare function compileOutputRedirections(ctx: InterpreterContext, current: OutputChannels, redirections: RedirectionNode[], options?: CompileOptions): Promise<CompiledOutputRedirections>;
+/**
+ * Mutate the live channel table for a persistent `exec` output redirect.
+ *
+ * Each changed fd reaches through temporary tables until an enclosing scope
+ * explicitly overrides that fd. That lets `exec` persist through unredirected
+ * groups/functions while respecting subshell clones and redirection restore
+ * boundaries.
+ */
+export declare function applyPersistentOutputRedirections(ctx: InterpreterContext, redirections: RedirectionNode[]): Promise<CompiledOutputRedirections>;
+export {};

package/dist/interpreter/redirections.d.ts

@@ -13,39 +13,34 @@ import type { RedirectionNode } from "../ast/types.js";
 import type { ExecResult } from "../types.js";
 import type { InterpreterContext } from "./types.js";
 /**
- * Pre-expanded redirect targets, keyed by index into the redirections array.
- * This allows us to expand redirect targets (including side effects) before
- * executing a function body, then apply the redirections after.
+ * Check if a redirect target is valid for output (not a directory, respects noclobber).
+ * Returns an error message string if invalid, null if valid.
  */
-export type ExpandedRedirectTargets = Map<number, string>;
+export declare function checkOutputRedirectTarget(ctx: InterpreterContext, filePath: string, target: string, options: {
+    checkNoclobber?: boolean;
+    isClobber?: boolean;
+}): Promise<string | null>;
 /**
- * Pre-expand redirect targets for function definitions.
- * This is needed because redirections on function definitions are evaluated
- * each time the function is called, and any side effects (like $((i++)))
- * must occur BEFORE the function body executes.
+ * Expand one redirect target using the same rules as the legacy redirect path.
  */
-export declare function preExpandRedirectTargets(ctx: InterpreterContext, redirections: RedirectionNode[]): Promise<{
-    targets: ExpandedRedirectTargets;
-    error?: string;
+export declare function expandRedirectionTarget(ctx: InterpreterContext, redir: RedirectionNode): Promise<{
+    target: string;
+} | {
+    error: string;
 }>;
+/**
+ * Return the legacy diagnostic for a redirect target containing a null byte.
+ */
+export declare function getInvalidRedirectTargetError(target: string): string | null;
+export declare function getBadFileDescriptorError(fd: number): string;
+/**
+ * Allocate the next available file descriptor (starting at 10).
+ * Returns the allocated FD number.
+ */
+export declare function allocateFd(ctx: InterpreterContext, isUnavailable?: (fd: number) => boolean): number;
 /**
  * Process FD variable redirections ({varname}>file syntax).
  * This allocates FDs and sets variables before command execution.
  * Returns an error result if there's an issue, or null if successful.
  */
-export declare function processFdVariableRedirections(ctx: InterpreterContext, redirections: RedirectionNode[]): Promise<ExecResult | null>;
-/**
- * Pre-open (truncate) output redirect files before command execution.
- * This is needed for compound commands (subshell, for, case, [[) where
- * bash opens/truncates the redirect file BEFORE evaluating any words in
- * the command body (including command substitutions).
- *
- * Example: `(echo \`cat FILE\`) > FILE`
- * - Bash first truncates FILE (making it empty)
- * - Then executes the subshell, where `cat FILE` returns empty string
- *
- * Returns an error result if there's an issue (like directory or noclobber),
- * or null if pre-opening succeeded.
- */
-export declare function preOpenOutputRedirects(ctx: InterpreterContext, redirections: RedirectionNode[]): Promise<ExecResult | null>;
-export declare function applyRedirections(ctx: InterpreterContext, result: ExecResult, redirections: RedirectionNode[], preExpandedTargets?: ExpandedRedirectTargets): Promise<ExecResult>;
+export declare function processFdVariableRedirections(ctx: InterpreterContext, redirections: RedirectionNode[], isFdUnavailable?: (fd: number) => boolean): Promise<ExecResult | null>;

package/dist/interpreter/types.d.ts

@@ -5,8 +5,10 @@ import type { CommandNode, FunctionDefNode, ScriptNode, StatementNode } from "..
 import type { IFileSystem } from "../fs/interface.js";
 import type { ExecutionLimits } from "../limits.js";
 import type { SecureFetch } from "../network/index.js";
+import type { ProcessTable } from "../process/process-table.js";
 import type { CommandRegistry, ExecResult, FeatureCoverageWriter, TraceCallback } from "../types.js";
 import type { ByteStream } from "../utils/stream.js";
+import type { OutputChannels } from "./output-channels.js";
 /**
  * Completion specification for a command, set by the `complete` builtin.
  */
@@ -239,15 +241,11 @@ export interface IOState {
     nextFd?: number;
 }
 /**
- * Captures errors that occur during parameter expansion.
- * Some expansion errors need to be reported after expansion completes,
- * with their exit codes and stderr preserved.
+ * Tracks exit status changes caused by parameter expansion.
  */
 export interface ExpansionState {
     /** Exit code from expansion errors (arithmetic, etc.) - overrides command exit code */
     expansionExitCode?: number;
-    /** Stderr from expansion errors */
-    expansionStderr?: string;
 }
 /**
  * Complete interpreter state for bash script execution.
@@ -295,12 +293,22 @@ export interface InterpreterContext {
     state: InterpreterState;
     fs: IFileSystem;
     commands: CommandRegistry;
+    /** Kernel-like job state, shared independently from InterpreterState. */
+    processes: ProcessTable;
+    /** Identity shared by one root exec and all nested shell execution. */
+    lineageId: number;
+    outputChannels: OutputChannels;
+    /** Errors already diagnosed while the current command unwinds. */
+    reportedDiagnostics?: WeakSet<Error>;
     /** Execution limits configuration */
     limits: Required<ExecutionLimits>;
+    /** Lifecycle events attributable to this root exec and its descendants. */
+    jobTracker: JobExecutionTracker;
     execFn: (script: string, options?: {
         env?: Record<string, string>;
         cwd?: string;
         stdin?: ByteStream;
+        signal?: AbortSignal;
     }) => Promise<ExecResult>;
     executeScript: (node: ScriptNode) => Promise<ExecResult>;
     executeStatement: (node: StatementNode) => Promise<ExecResult>;
@@ -308,7 +316,9 @@ export interface InterpreterContext {
     /** Optional secure fetch function for network-enabled commands */
     fetch?: SecureFetch;
     /** Optional sleep function for testing with mock clocks */
-    sleep?: (ms: number) => Promise<void>;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** Abort signal for this execution (from ExecOptions.signal) */
+    signal?: AbortSignal;
     /** Optional trace callback for performance profiling */
     trace?: TraceCallback;
     /** Current command substitution nesting depth (for limit enforcement) */
@@ -316,3 +326,7 @@ export interface InterpreterContext {
     /** Optional feature coverage writer for fuzzing instrumentation */
     coverage?: FeatureCoverageWriter;
 }
+export interface JobExecutionTracker {
+    started: boolean;
+    limitExceeded: boolean;
+}

package/dist/limits.d.ts

@@ -35,6 +35,8 @@ export interface ExecutionLimits {
     maxHeredocSize?: number;
     /** Maximum command substitution nesting depth (default: 50) */
     maxSubstitutionDepth?: number;
+    /** Maximum number of concurrently running background jobs (default: 128) */
+    maxConcurrentJobs?: number;
 }
 /**
  * Resolve execution limits by merging user-provided limits with defaults.