just-binary 2.9.8 → 3.0.0

package/dist/commands/head/head-tail-shared.d.ts

@@ -24,10 +24,11 @@ export type HeadTailParseResult = {
  */
 export declare function parseHeadTailArgs(args: string[], cmdName: "head" | "tail"): HeadTailParseResult;
 /**
- * Process files for head/tail commands.
- * Handles stdin, multiple files, headers, and error handling.
+ * Process files for head/tail commands. Stream-based to handle files larger
+ * than the V8 string cap. Head exits early once N bytes/lines are emitted;
+ * tail uses a ring-buffer of bytes/lines.
  */
-export declare function processHeadTailFiles(ctx: CommandContext, options: HeadTailOptions, cmdName: "head" | "tail", contentProcessor: (content: string) => string): Promise<ExecResult>;
+export declare function processHeadTailFiles(ctx: CommandContext, options: HeadTailOptions, cmdName: "head" | "tail", _contentProcessor: (content: string) => string): Promise<ExecResult>;
 /**
  * Get the first N lines or bytes from content.
  */

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

@@ -8,3 +8,4 @@
  */
 export { type SearchOptions, type SearchResult, searchContent, } from "./matcher.js";
 export { buildRegex, convertReplacement, type RegexMode, type RegexOptions, type RegexResult, } from "./regex.js";
+export { canStream, type StreamSearchResult, searchStream, } from "./stream-matcher.js";

package/dist/commands/search-engine/stream-matcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Streaming variant of searchContent.
+ *
+ * Reads a ByteStream line-by-line, matches each line against the regex, and
+ * builds the formatted output as chunks of text. Memory usage is bounded by
+ * the size of the output plus the before-context ring buffer — never by the
+ * input size — so commands using this can grep over arbitrary-size files.
+ *
+ * Supports the common options: invertMatch, showLineNumbers, onlyMatching,
+ * filename, beforeContext/afterContext, maxCount, countOnly, passthru,
+ * replace. Multiline, vimgrep, and showByteOffset are NOT supported here —
+ * use searchContent for those (they require full-content semantics anyway).
+ */
+import type { UserRegex } from "../../regex/index.js";
+import { type ByteStream } from "../../utils/stream.js";
+import type { SearchOptions } from "./matcher.js";
+export interface StreamSearchResult {
+    /** Stream of formatted output (matched lines, contexts, count) */
+    output: ByteStream;
+    /** Whether any line matched (resolved after the stream is drained) */
+    matched: Promise<boolean>;
+    /** Total match count (lines or individual matches depending on opts) */
+    matchCount: Promise<number>;
+}
+/**
+ * Subset of options that the streaming searcher can handle natively.
+ * Callers should fall back to searchContent if their options need
+ * full-content semantics.
+ */
+export declare function canStream(options: SearchOptions): boolean;
+export declare function searchStream(input: ByteStream, regex: UserRegex, options?: SearchOptions): StreamSearchResult;

package/dist/fs/encoding.d.ts

@@ -1,16 +1,32 @@
 /**
- * Shared utilities for filesystem implementations
+ * Shared utilities for filesystem implementations.
+ *
+ * Provides encoding helpers for translating between the FileContent union
+ * type (string | Uint8Array | ByteStream) and the internal chunked storage
+ * format used by in-memory filesystems.
  */
-import type { BufferEncoding, ReadFileOptions, WriteFileOptions } from "./interface.js";
-export type FileContent = string | Uint8Array;
+import type { BufferEncoding, FileContent, ReadFileOptions, WriteFileOptions } from "./interface.js";
 /**
- * Helper to convert content to Uint8Array
+ * Normalize a FileContent (sync only — no streams) to chunked storage.
+ * Encoding is applied to string content. Used by sync init paths.
  */
-export declare function toBuffer(content: FileContent, encoding?: BufferEncoding): Uint8Array;
+export declare function contentToChunksSync(content: string | Uint8Array, encoding?: BufferEncoding): {
+    chunks: Uint8Array[];
+    size: number;
+};
 /**
- * Helper to convert Uint8Array to string with encoding
+ * Normalize any FileContent (including streams) to chunked storage.
+ * Streams are collected; chunks are re-split to enforce CHUNK_SIZE.
  */
-export declare function fromBuffer(buffer: Uint8Array, encoding?: BufferEncoding | null): string;
+export declare function contentToChunks(content: FileContent, encoding?: BufferEncoding): Promise<{
+    chunks: Uint8Array[];
+    size: number;
+}>;
+/**
+ * Decode a sequence of chunks to a string using the given encoding.
+ * Uses TextDecoder with stream:true for UTF-8 across chunks.
+ */
+export declare function decodeChunks(chunks: readonly Uint8Array[], encoding?: BufferEncoding | null): string;
 /**
  * Helper to get encoding from options
  */

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

@@ -1,3 +1,4 @@
+import { type ByteStream } from "../../utils/stream.js";
 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 {
@@ -9,33 +10,26 @@ export declare class InMemoryFs implements IFileSystem {
     private normalizePath;
     private dirname;
     private ensureParentDirs;
-    writeFileSync(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding, metadata?: {
+    /**
+     * Synchronous file write. Accepts string or Uint8Array only (no streams).
+     * Used during construction and by init.ts for seeding /dev, /proc, /bin
+     * stubs. Internally stored chunked.
+     */
+    writeFileSync(path: string, content: string | Uint8Array, options?: WriteFileOptions | BufferEncoding, metadata?: {
         mode?: number;
         mtime?: Date;
     }): void;
-    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
-    readFileBuffer(path: string): Promise<Uint8Array>;
+    readFile(path: string): Promise<ByteStream>;
+    readFileText(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
     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[]>;
@@ -48,16 +42,6 @@ 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

@@ -1,29 +1,29 @@
+import type { ByteStream } from "../utils/stream.js";
 /**
  * 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
+ * Content that can be written to a file. Streams remove the per-allocation
+ * size cap; strings and Uint8Arrays are conveniences for small payloads.
  */
+export type FileContent = string | Uint8Array | ByteStream;
 export interface ReadFileOptions {
     encoding?: BufferEncoding | null;
 }
-/**
- * Options for writing files
- */
 export interface WriteFileOptions {
     encoding?: BufferEncoding;
 }
 /**
- * File system entry types
+ * In-memory file content is stored as an array of chunks so a single
+ * physical Uint8Array allocation never exceeds CHUNK_SIZE.
  */
 export interface FileEntry {
     type: "file";
-    content: string | Uint8Array;
+    /** Chunked content. Each chunk is a Uint8Array of up to CHUNK_SIZE bytes. */
+    chunks: Uint8Array[];
+    /** Total byte length across all chunks. Cached to avoid re-summing. */
+    size: number;
     mode: number;
     mtime: Date;
 }
@@ -39,19 +39,12 @@ export interface SymlinkEntry {
     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;
@@ -60,145 +53,59 @@ export interface FsStat {
     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)
+ * Abstract filesystem interface.
+ *
+ * All I/O is stream-based to remove the per-Uint8Array size cap. Convenience
+ * helpers (readFileText/writeFileText) exist for small/text payloads.
  */
 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
+     * Open a file for reading. Returns a stream of byte chunks.
+     * @throws if path does not exist or is a directory
      */
-    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFile(path: string): Promise<ByteStream>;
     /**
-     * Read the contents of a file as a Uint8Array (binary)
-     * @throws Error if file doesn't exist or is a directory
+     * Read a file fully as decoded text (default encoding: utf8).
+     * Convenience for small/text files.
+     * @throws if path does not exist or is a directory
      */
-    readFileBuffer(path: string): Promise<Uint8Array>;
+    readFileText(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
     /**
-     * Write content to a file, creating it if it doesn't exist
+     * Write content to a file, creating it if it doesn't exist.
+     * Accepts a stream (preferred for large content), Uint8Array, or string.
      */
     writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
     /**
-     * Append content to a file, creating it if it doesn't exist
+     * 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>;
 }
 /**

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

@@ -1,3 +1,4 @@
+import type { ByteStream } from "../../utils/stream.js";
 import type { BufferEncoding, CpOptions, FileContent, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
 /**
  * Configuration for a mount point
@@ -83,8 +84,8 @@ export declare class MountableFs implements IFileSystem {
      * 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>;
+    readFile(path: string): Promise<ByteStream>;
+    readFileText(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
     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>;

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 ByteStream } from "../../utils/stream.js";
+import type { BufferEncoding, CpOptions, DirentEntry, FileContent, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
 export interface OverlayFsOptions {
     /**
      * The root directory on the real filesystem.
@@ -79,8 +79,14 @@ export declare class OverlayFs implements IFileSystem {
      * 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>;
+    readFile(path: string): Promise<ByteStream>;
+    readFileText(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    /**
+     * Internal: resolve symlinks and produce raw chunks. Memory hits return
+     * the chunk array directly (zero copy); real-fs hits stream the file
+     * from disk in CHUNK_SIZE pieces.
+     */
+    private readFileChunks;
     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>;

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

@@ -7,8 +7,8 @@
  * 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";
+import { type ByteStream } from "../../utils/stream.js";
+import type { BufferEncoding, CpOptions, DirentEntry, FileContent, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
 export interface ReadWriteFsOptions {
     /**
      * The root directory on the real filesystem.
@@ -34,8 +34,8 @@ export declare class ReadWriteFs implements IFileSystem {
      * Normalize a virtual path (resolve . and .., ensure starts with /)
      */
     private normalizePath;
-    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
-    readFileBuffer(path: string): Promise<Uint8Array>;
+    readFile(path: string): Promise<ByteStream>;
+    readFileText(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
     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>;

package/dist/index.d.ts

@@ -17,3 +17,5 @@ export type { DefenseInDepthConfig, DefenseInDepthHandle, DefenseInDepthStats, S
 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";
+export type { ByteStream } from "./utils/stream.js";
+export { CHUNK_SIZE, collectBytes, collectText, concatStreams, drain, emptyStream, fromBytes, fromChunks, fromString, mapChunks, streamChunks, streamLines, teeStream, } from "./utils/stream.js";

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

@@ -5,11 +5,12 @@
  * Separated from interpreter.ts for modularity.
  */
 import type { ExecResult } from "../types.js";
+import { type ByteStream } from "../utils/stream.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>;
+export type RunCommandFn = (commandName: string, args: Uint8Array[], quotedArgs: boolean[], stdin: ByteStream, skipFunctions?: boolean, useDefaultPath?: boolean, stdinSourceFd?: number) => Promise<ExecResult>;
 /**
  * Type for the function that builds exported environment
  */
@@ -17,7 +18,7 @@ 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>;
+export type ExecuteUserScriptFn = (scriptPath: string, args: Uint8Array[], stdin?: ByteStream) => Promise<ExecResult>;
 /**
  * Dispatch context containing dependencies needed for builtin dispatch
  */
@@ -31,9 +32,9 @@ export interface BuiltinDispatchContext {
  * 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>;
+export declare function dispatchBuiltin(dispatchCtx: BuiltinDispatchContext, commandName: string, args: Uint8Array[], _quotedArgs: boolean[], stdin: ByteStream, 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>;
+export declare function executeExternalCommand(dispatchCtx: BuiltinDispatchContext, commandName: string, args: Uint8Array[], stdin: ByteStream, useDefaultPath: boolean): Promise<ExecResult>;

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

@@ -5,5 +5,6 @@
  * in the current environment (variables persist after eval).
  */
 import type { ExecResult } from "../../types.js";
+import type { ByteStream } from "../../utils/stream.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleEval(ctx: InterpreterContext, args: string[], stdin?: Uint8Array): Promise<ExecResult>;
+export declare function handleEval(ctx: InterpreterContext, args: string[], stdin?: ByteStream): Promise<ExecResult>;

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

@@ -14,4 +14,4 @@
  */
 import type { ExecResult } from "../../types.js";
 import type { InterpreterContext } from "../types.js";
-export declare function handleMapfile(ctx: InterpreterContext, args: string[], stdinBytes: Uint8Array): ExecResult;
+export declare function handleMapfile(ctx: InterpreterContext, args: string[], stdinBytes: Uint8Array): 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[], stdinBytes: Uint8Array, stdinSourceFd?: number): ExecResult;
+export declare function handleRead(ctx: InterpreterContext, args: string[], stdinBytes: Uint8Array, stdinSourceFd?: number): Promise<ExecResult>;

package/dist/interpreter/control-flow.d.ts

@@ -12,10 +12,11 @@
  */
 import type { CaseNode, CStyleForNode, ForNode, IfNode, UntilNode, WhileNode } 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 executeIf(ctx: InterpreterContext, node: IfNode): Promise<ExecResult>;
 export declare function executeFor(ctx: InterpreterContext, node: ForNode): Promise<ExecResult>;
 export declare function executeCStyleFor(ctx: InterpreterContext, node: CStyleForNode): Promise<ExecResult>;
-export declare function executeWhile(ctx: InterpreterContext, node: WhileNode, stdin?: Uint8Array): Promise<ExecResult>;
+export declare function executeWhile(ctx: InterpreterContext, node: WhileNode, stdin?: ByteStream): Promise<ExecResult>;
 export declare function executeUntil(ctx: InterpreterContext, node: UntilNode): Promise<ExecResult>;
 export declare function executeCase(ctx: InterpreterContext, node: CaseNode): Promise<ExecResult>;