@jerryan/just-bash 3.6.1 → 3.8.0

package/dist/commands/diff/format.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Output formatters for diff.
+ *
+ * The three formats GNU diff can produce: POSIX normal format (the default),
+ * unified format (-u) and context format (-c). Layout was derived by running
+ * GNU diffutils 3.12 and matching the bytes it emits.
+ *
+ * Two intentional deviations from GNU:
+ *
+ * - The -u/-c file header carries no timestamp. GNU appends a tab and the
+ *   file's mtime; inside a virtual filesystem that is often synthetic or
+ *   absent, and it would make output non-reproducible. Patch consumers ignore
+ *   the field.
+ * - When several minimal edit scripts exist for the same pair of files, which
+ *   one comes out is arbitrary, and this picks a different one than GNU on
+ *   some inputs. Hunks are still minimal and the formats are exact; only the
+ *   grouping of ambiguous changes can differ.
+ */
+/** Number of context lines GNU shows around a change for -u and -c. */
+export declare const DEFAULT_CONTEXT = 3;
+export interface FileLines {
+    /** Lines with their trailing newline stripped. */
+    lines: string[];
+    /** True when the last line is not newline-terminated. */
+    noEol: boolean;
+}
+/**
+ * A run of adjacent deleted and/or inserted lines. Starts are 0-based indices
+ * into the corresponding `FileLines.lines`.
+ */
+export interface Change {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+}
+/** Splits file content into lines, remembering a missing final newline. */
+export declare function splitLines(content: string): FileLines;
+/** Computes the runs of deleted and/or inserted lines between two files. */
+export declare function computeChanges(oldFile: FileLines, newFile: FileLines, ignoreCase: boolean): Change[];
+/** POSIX normal format: `2c2` / `< old` / `---` / `> new`. */
+export declare function formatNormal(oldFile: FileLines, newFile: FileLines, changes: Change[]): string;
+/** Unified format (-u): `--- old`, `+++ new`, `@@` hunks. */
+export declare function formatUnified(oldName: string, newName: string, oldFile: FileLines, newFile: FileLines, changes: Change[], context: number): string;
+/** Context format (-c): `*** old`, `--- new`, `***************` hunks. */
+export declare function formatContext(oldName: string, newName: string, oldFile: FileLines, newFile: FileLines, changes: Change[], context: number): string;

package/dist/commands/js-exec/js-exec.d.ts

@@ -1,17 +1,4 @@
-/**
- * js-exec - Execute JavaScript code via QuickJS (WASM)
- *
- * Runs JavaScript code in an isolated worker thread with access to the
- * virtual filesystem, HTTP, and sub-shell execution via SharedArrayBuffer bridge.
- *
- * This command is Node.js only (uses worker_threads).
- */
+/** js-exec - Execute JavaScript code via the run package. */
 import type { RuntimeCommand } from "../../types.js";
-/** @internal Set the idle-teardown delay — for focused lifecycle tests only. */
-export declare function _setJsExecWorkerIdleTimeoutMsForTests(ms: number): void;
-/** @internal Whether the shared worker is currently alive — for tests only. */
-export declare function _hasSharedJsExecWorkerForTests(): boolean;
-/** @internal Reset singleton worker state — for focused protocol tests only. */
-export declare function _resetJsExecWorkerForTests(): void;
 export declare const jsExecCommand: RuntimeCommand;
 export declare const nodeStubCommand: RuntimeCommand;

package/dist/commands/js-exec/run-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { ExecResult, RuntimeCommandContext } from "../../types.js";
+interface RunJsOptions {
+    source: string;
+    scriptPath: string;
+    scriptArgs: string[];
+    bootstrapCode?: string;
+    isModule: boolean;
+}
+export declare function executeWithRun(options: RunJsOptions, ctx: RuntimeCommandContext): Promise<ExecResult>;
+export {};

package/dist/commands/worker-bridge/bridge-handler.d.ts

@@ -12,9 +12,6 @@ export interface BridgeOutput {
     stderr: string;
     exitCode: number;
 }
-/**
- * Handles requests from a worker thread.
- */
 export declare class BridgeHandler {
     private fs;
     private cwd;

package/dist/commands/worker-bridge/protocol.d.ts

@@ -43,14 +43,34 @@ export declare const OpCode: {
     readonly INVOKE_TOOL: 400;
 };
 export type OpCodeType = (typeof OpCode)[keyof typeof OpCode];
-/** Status codes for synchronization */
-export declare const Status: {
-    readonly PENDING: 0;
-    readonly READY: 1;
-    readonly SUCCESS: 2;
-    readonly ERROR: 3;
+/**
+ * Two-word request/result state. The previous single STATUS word was
+ * written by THREE actors with TWO meanings (worker READY = "request
+ * published", host SUCCESS/ERROR = "result published", stop() READY =
+ * "wake for cancel") — a worker waiting for a result could observe a
+ * request-channel value and read a torn buffer (the CI flake class).
+ * Splitting the channels makes the torn state unrepresentable: a
+ * result wait is only ever woken by a result write. A state outside
+ * the tables on wake is a genuine protocol bug and fails loudly.
+ */
+/** Worker + stop() write; the host waits on this word. */
+export declare const RequestState: {
+    readonly IDLE: 0;
+    /** Worker has published an op. */
+    readonly REQUEST: 1;
+    /** stop() cancellation wake. The host treats any non-REQUEST wake as
+     * loop-abort (stop() also flips its `running` flag). */
+    readonly CANCELLED: 2;
+};
+type RequestStateType = (typeof RequestState)[keyof typeof RequestState];
+/** Host writes; the worker waits on this word. stop() never touches
+ * it, so a result wait cannot be torn by cancellation. */
+export declare const ResultState: {
+    readonly NONE: 0;
+    readonly SUCCESS: 1;
+    readonly ERROR: 2;
 };
-export type StatusType = (typeof Status)[keyof typeof Status];
+type ResultStateType = (typeof ResultState)[keyof typeof ResultState];
 /** Error codes */
 export declare const ErrorCode: {
     readonly NONE: 0;
@@ -61,18 +81,34 @@ export declare const ErrorCode: {
     readonly PERMISSION_DENIED: 5;
     readonly INVALID_PATH: 6;
     readonly IO_ERROR: 7;
-    readonly TIMEOUT: 8;
     readonly NETWORK_ERROR: 9;
     readonly NETWORK_NOT_CONFIGURED: 10;
     readonly NOT_EMPTY: 11;
+    readonly LOOP: 12;
+    readonly FILE_TOO_LARGE: 13;
+    readonly NO_SPACE: 14;
+    readonly BUSY: 15;
+    readonly READ_ONLY: 16;
+    readonly CROSS_DEVICE: 17;
 };
 export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * The canonical errno-name <-> wire-code table. Both bridge sides ship
+ * together, so the table lives here (not per-side copies): the host
+ * maps thrown errnos to wire codes with it, and workers derive guest-
+ * facing codes from its inverse via wireToErrnoName(). EPERM precedes
+ * EACCES so the inverse prefers the common node spelling.
+ */
+export declare const ERRNO_TO_WIRE: Record<string, ErrorCodeType>;
+/** Errno name for a wire code, or undefined for non-errno wire codes
+ * (NONE, IO_ERROR, network conditions). PERMISSION_DENIED inverts to
+ * EACCES (the more common spelling in node guests). */
+export declare function wireToErrnoName(code: number): string | undefined;
 /** Buffer sizes */
 export declare const Size: {
-    readonly CONTROL_REGION: 32;
     readonly PATH_BUFFER: 4096;
     readonly DATA_BUFFER: 8388608;
-    readonly TOTAL: 8392736;
+    readonly TOTAL: 8392740;
 };
 /** Flags for operations */
 export declare const Flags: {
@@ -92,8 +128,10 @@ export declare class ProtocolBuffer {
     constructor(buffer: SharedArrayBuffer);
     getOpCode(): OpCodeType;
     setOpCode(code: OpCodeType): void;
-    getStatus(): StatusType;
-    setStatus(status: StatusType): void;
+    getRequest(): RequestStateType;
+    setRequest(request: RequestStateType): void;
+    getResultState(): ResultStateType;
+    setResultState(state: ResultStateType): void;
     getPathLength(): number;
     setPathLength(length: number): void;
     getDataLength(): number;
@@ -139,20 +177,16 @@ export declare class ProtocolBuffer {
         size: number;
         mtime: Date;
     };
-    waitForReady(timeout?: number): "ok" | "timed-out" | "not-equal";
-    waitForReadyAsync(timeout?: number): {
-        async: false;
-        value: "not-equal" | "timed-out";
-    } | {
-        async: true;
-        value: Promise<"ok" | "timed-out">;
-    };
     /**
-     * Wait for status to become READY.
-     * Returns immediately if status is already READY, or waits until it changes.
+     * Wait for the request word to become REQUEST.
+     * Returns immediately if already REQUEST; CANCELLED or any unexpected
+     * state returns false (the caller's running-flag check aborts the loop).
      */
     waitUntilReady(timeout: number): Promise<boolean>;
+    /** Worker-side blocking wait on the RESULT word (host writes). */
     waitForResult(timeout?: number): "ok" | "timed-out" | "not-equal";
-    notify(): number;
+    notifyRequest(): number;
+    notifyResult(): number;
     reset(): void;
 }
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Filesystem error carrying its errno as a STRUCTURED field.
+ *
+ * The contract: the errno is chosen at the throw site and carried on
+ * `.code`; consumers read `.code` and never re-derive it from message
+ * prose. There is deliberately NO message-parsing fallback here —
+ * parsing "CODE:" prefixes back out of strings is the legacy path this
+ * module replaces, and keeping it would leave two sources of truth
+ * (the field and the phrasing) with an illusion of robustness.
+ *
+ * Message format is preserved as a DISPLAY convention only: FsError
+ * renders `${code}: ${message}` so existing user-facing text and
+ * message-asserting tests are unchanged. The prefix is produced FROM
+ * the code, never parsed back INTO one.
+ *
+ * Contract for IFileSystem implementations (documented on the
+ * interface): throw FsError, or any node-style error with a string
+ * `.code`. Errors without a structured code are coerced to EIO at
+ * classification boundaries (toFsError) — an honest unknown, never a
+ * fabricated specific errno.
+ */
+export declare class FsError extends Error {
+    readonly code: string;
+    /** The message WITHOUT the "CODE: " transport prefix — what
+     * user-facing display paths should render. */
+    readonly bareMessage: string;
+    constructor(code: string, message: string);
+}
+/** Extract a structured errno from any thrown value, or undefined when
+ * the value carries none (bare Errors, strings, foreign objects). */
+export declare function fsErrorCode(err: unknown): string | undefined;
+/** True when the error carries the given structured errno. */
+export declare function isFsErrorCode(err: unknown, code: string): boolean;
+/**
+ * Classify any thrown value at a boundary: structured codes pass
+ * through unchanged; everything else becomes the fallback (EIO by
+ * default) with the original message preserved. Provided as PUBLIC API
+ * for custom IFileSystem implementations and host-side adapters that
+ * need to normalize third-party errors before handing them to
+ * just-bash internals. Internally, boundaries that only need the code
+ * (e.g. the worker bridge) read fsErrorCode directly instead.
+ */
+export declare function toFsError(err: unknown, fallbackCode?: string): FsError;

package/dist/fs/interface.d.ts

@@ -96,6 +96,19 @@ export interface CpOptions {
  * - InMemoryFs (in-memory, default)
  * - Real filesystem (via node:fs)
  * - Custom implementations (e.g., remote storage, browser IndexedDB)
+ *
+ * ERROR CONTRACT: implementations signal failure kind by throwing
+ * {@link FsError} (or any node-style error with a string `.code`
+ * property) using POSIX errno names — `"ENOENT"`, `"EACCES"`,
+ * `"EEXIST"`, `"ENOTDIR"`, `"EISDIR"`, `"ENOTEMPTY"`, `"EPERM"`,
+ * `"EINVAL"`, `"EBUSY"`, `"ELOOP"`, `"EFBIG"`, `"EXDEV"`, `"ENOSPC"`,
+ * `"EROFS"`, `"EIO"`. Consumers
+ * (commands, bridged runtimes like python3, and error mappings) read
+ * the code from `.code`; they never parse it out of message prose.
+ * Errors with no structured code are classified at the boundary as
+ * EIO — an honest unknown, never a fabricated specific errno.
+ * Message text is free-form; by convention FsError renders
+ * `"ECODE: message"` for display.
  */
 export interface IFileSystem {
     /**

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

@@ -1,5 +1,6 @@
 import { type ByteString } from "../../encoding.js";
 import type { BufferEncoding, CpOptions, FileContent, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
+import type { OverlayDiff } from "../overlay-fs/overlay-fs.js";
 /**
  * Configuration for a mount point
  */
@@ -58,6 +59,25 @@ export declare class MountableFs implements IFileSystem {
         mountPoint: string;
         filesystem: IFileSystem;
     }>;
+    /**
+     * Combined change set across all diff-capable mounts. `space` selects
+     * the path form: "vfs" (default) keeps full virtual paths (mount
+     * prefix retained — directly replayable by a template merge);
+     * "host" maps each entry to its real-absolute host path (for
+     * template.apply / applyDiffToRealFs). The base fs is shared scratch
+     * and is not diffed. Mounts without a diff() method fail loudly —
+     * a merged view cannot silently omit a mount's changes.
+     */
+    diff(options?: {
+        space?: "vfs" | "host";
+    }): OverlayDiff;
+    /**
+     * Reconciliation support (template merge replay): set the changedAt
+     * ordering stamp of the node at `path` and its ancestors, routing to
+     * the owning mount. Paths outside every mount (shared scratch) have
+     * no stampable overlay and are ignored.
+     */
+    restamp(path: string, changedAt: number, scope?: "full" | "ancestors"): void;
     /**
      * Check if a path is exactly a mount point.
      */

package/dist/fs/overlay-fs/apply.d.ts

@@ -17,7 +17,8 @@ export declare function removeFromRealFs(path: string): void;
  * symlinks are recreated with the recorded target; files get the recorded
  * content (unless metadataOnly — a chmod/utimes copy-up), the recorded
  * mode (POSIX only — mode bits are advisory on Windows), and the recorded
- * mtime restored after the content write.
+ * mtime restored after the content write. A type-conflicting on-disk
+ * target is replaced (the change-set supersedes the base).
  */
 export declare function applyWriteToRealFs(path: string, write: Omit<OverlayWrite, "path">): void;
 /**

package/dist/fs/overlay-fs/index.d.ts

@@ -1,3 +1,2 @@
 export { applyDiffToRealFs } from "./apply.js";
-export { mergeDiffs } from "./merge.js";
 export { type OverlayDiff, OverlayFs, type OverlayFsOptions, type OverlayNodeType, type OverlayWrite, } from "./overlay-fs.js";

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

@@ -130,6 +130,20 @@ export declare class OverlayFs implements IFileSystem {
     private readonly allowSymlinks;
     private readonly tree;
     private nextMemoryIdentity;
+    /** The real directory this overlay reads through and diffs against. */
+    get rootDir(): string;
+    /**
+     * Reconciliation support (template merge replay, host-side change-set
+     * application): stamp the node at `path` with `changedAt` (the
+     * replayed entry's own stamp), and correct any NEWER stamps among its
+     * ancestors and descendants. Post-sort, a newer stamp can only be a
+     * fresh wall-clock stamp minted by the replay op itself (ensured
+     * parents, resurrection whiteouts) — those belong to the replayed
+     * entry and take its stamp; earlier replayed entries (older stamps)
+     * are never touched. This is a host-side reconciliation API, not a
+     * guest operation: changedAt is the ordering key merges rely on.
+     */
+    restamp(path: string, changedAt: number, scope?: "full" | "ancestors"): void;
     private identityFor;
     constructor(options: OverlayFsOptions);
     /**

package/dist/fs/path-utils.d.ts

@@ -39,6 +39,11 @@ export declare function resolvePath(base: string, path: string): string;
  * Join a parent path with a child name.
  * Handles the root-path edge case (`"/" + "child"` → `"/child"`).
  */
+/** Convert an OS-form path fragment to VFS slash form (win32
+ * backslashes become slashes; on POSIX this is a no-op). VFS paths are
+ * always slash-form — use when reconstructing a virtual path from a
+ * real-OS path (e.g. slicing off a real root). */
+export declare function toVirtualSlashes(path: string): string;
 export declare function joinPath(parent: string, child: string): string;
 /**
  * Resolve a symlink target relative to the symlink's location.

package/dist/fs/traversal.d.ts

@@ -67,6 +67,15 @@ export declare class FileTraversalBudget {
     constructor(options: TraversalBudgetOptions);
     checkpoint(work?: number): void;
     visit(depth: number): void;
+    /**
+     * Reserve directory children against the entry ceiling without charging for
+     * work not yet done. A single readdir can return far more entries than the
+     * traversal is allowed to retain, so the collection has to be admitted
+     * before it is held, but reading a directory is one filesystem operation
+     * however many names come back. Callers that go on to touch each child
+     * should use `discover` instead, which also charges the work.
+     */
+    reserve(count: number): void;
     /**
      * Reserve directory children before retaining work items for them. A single
      * readdir can return far more entries than the traversal is allowed to

package/dist/fs/vfs-template.d.ts

@@ -10,41 +10,64 @@ export interface VfsTemplateMount {
 export interface VfsTemplateOptions {
     /**
      * Subtrees privatized per fork. Everything else (/, /tmp, ...) lives
-     * in the template's shared in-memory scratch fs and behaves like
-     * shared memory: visible to every fork immediately.
+     * in the template's shared scratch memory fs: writes there are
+     * visible to every fork immediately and never appear in diffs.
      */
     mounts: VfsTemplateMount[];
+    /**
+     * Per-overlay content-byte budget (OverlayFs maxMemoryBytes),
+     * bounding each fork's copy-up memory. Default: the OverlayFs
+     * default.
+     */
+    maxMemoryBytes?: number;
 }
 /**
- * A process image for parallel agent tool calls (see
+ * Template for cheap parallel forks (see
  * docs/design/vfs-template-fork-model.md). The template owns the shared
  * scratch fs and the mount configuration; each fork() stamps out a
  * ready MountableFs with fresh copy-on-write overlays over every
- * mounted real root. Forks are single-use: run, diff via merge(),
- * discard.
+ * mounted real root. Forks are unmanaged: the template keeps no
+ * registry, consumes nothing, and never tracks lifecycles.
+ *
+ * MERGE IS A REPLAY. `merge` combines the given change sets (fork
+ * instances are diffed in vfs space; plain diffs pass through), orders
+ * every entry by (changedAt, input order), and applies the entries to a
+ * fresh fork with the stock filesystem operations — the same codepath
+ * the forks themselves used, over the same lower. Anything the
+ * filesystem refuses (write under a file, chmod of a deleted path, ...)
+ * is skipped, which keeps conflicting (racy) input deterministic and
+ * contained to the conflicted path. After each replayed operation the
+ * touched node's changedAt is rewritten from the replay position, so
+ * merged output is byte-deterministic and wall-clock-free. The merged
+ * fork is returned: diff it and discard it, or keep working on it.
  *
  * ```ts
  * const tpl = createVfsTemplate({ mounts: [{ at: "/project", root: projDir }] });
  * const a = tpl.fork();
  * const b = tpl.fork();
- * await Promise.all([runA(a), runB(b)]);
- * const merged = tpl.merge([a, b]);  // completion order = tiebreak
- * tpl.apply(merged);
+ * await Promise.all([runAgent(a), runAgent(b)]);
+ * const merged = await tpl.merge([a, b]);
+ * tpl.apply(merged.diff({ space: "host" }));
  * ```
  */
 export interface VfsTemplate {
     /** A fresh per-call filesystem: shared scratch + fresh overlays. */
     fork(): MountableFs;
     /**
-     * Merge the change sets of the given forks (in completion order —
-     * the tiebreak under changedAt) into one diff with real absolute
-     * paths. Forks not listed are merged after, in registration order.
+     * Replay the given sources' change sets onto a fresh fork and return
+     * it. Sources may be fork instances (diffed in vfs space) or plain
+     * diffs (e.g. serialized across a process boundary). Array order is
+     * the tie-break for equal changedAt stamps. Entries outside every
+     * mount point replay into the shared scratch (ordinary fork
+     * semantics, never reported in diff()) — merge expects diffs in
+     * this template's vfs space.
      */
-    merge(forksInCompletionOrder?: MountableFs[]): OverlayDiff;
+    merge(sources: Array<MountableFs | OverlayDiff>): Promise<MountableFs>;
     /**
-     * Validate a merged diff against the mount map (an entry outside
-     * every registered root fails loudly) and apply it to the real
-     * roots. Consumes all registered forks.
+     * Validate a merged host-space diff against the mount map (every
+     * entry inside a registered root, no symlink writes, no root-self
+     * deletion) and apply it to the real filesystem. Type-conflicting
+     * on-disk targets are replaced (the change-set supersedes the base).
      */
     apply(merged: OverlayDiff): void;
 }

package/dist/index.d.cts

@@ -8,10 +8,11 @@ export type { CommandContextOptions, CustomCommand, LazyCommand, } from "./custo
 export { createCommandContext, defineCommand, } from "./custom-commands.js";
 export type { ByteString, OutputKind } from "./encoding.js";
 export { bytesOutput, decodeBytesToUtf8, EMPTY_BYTES, encodeUtf8ToBytes, latin1FromBytes, stdoutAsBytes, stdoutKind, textOutput, unsafeBytesFromLatin1, } from "./encoding.js";
+export { FsError, fsErrorCode, isFsErrorCode, toFsError, } from "./fs/fs-error.js";
 export { InMemoryFs } from "./fs/in-memory-fs/index.js";
 export type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry, FileInit, FileSystemFactory, FsEntry, FsStat, InitialFiles, LazyFileEntry, LazyFileProvider, MkdirOptions, RmOptions, SymlinkEntry, } from "./fs/interface.js";
 export { MountableFs, type MountableFsOptions, type MountConfig, } from "./fs/mountable-fs/index.js";
-export { applyDiffToRealFs, mergeDiffs, type OverlayDiff, OverlayFs, type OverlayFsOptions, type OverlayNodeType, type OverlayWrite, } from "./fs/overlay-fs/index.js";
+export { applyDiffToRealFs, type OverlayDiff, OverlayFs, type OverlayFsOptions, type OverlayNodeType, type OverlayWrite, } from "./fs/overlay-fs/index.js";
 export { ReadWriteFs, type ReadWriteFsOptions, } from "./fs/read-write-fs/index.js";
 export { createVfsTemplate, type VfsTemplate, type VfsTemplateMount, type VfsTemplateOptions, } from "./fs/vfs-template.js";
 export type { AllowedUrl, AllowedUrlEntry, NetworkConfig, RequestTransform, SecureFetch, } from "./network/index.js";

package/dist/index.d.ts

@@ -8,10 +8,11 @@ export type { CommandContextOptions, CustomCommand, LazyCommand, } from "./custo
 export { createCommandContext, defineCommand, } from "./custom-commands.js";
 export type { ByteString, OutputKind } from "./encoding.js";
 export { bytesOutput, decodeBytesToUtf8, EMPTY_BYTES, encodeUtf8ToBytes, latin1FromBytes, stdoutAsBytes, stdoutKind, textOutput, unsafeBytesFromLatin1, } from "./encoding.js";
+export { FsError, fsErrorCode, isFsErrorCode, toFsError, } from "./fs/fs-error.js";
 export { InMemoryFs } from "./fs/in-memory-fs/index.js";
 export type { BufferEncoding, CpOptions, DirectoryEntry, FileContent, FileEntry, FileInit, FileSystemFactory, FsEntry, FsStat, InitialFiles, LazyFileEntry, LazyFileProvider, MkdirOptions, RmOptions, SymlinkEntry, } from "./fs/interface.js";
 export { MountableFs, type MountableFsOptions, type MountConfig, } from "./fs/mountable-fs/index.js";
-export { applyDiffToRealFs, mergeDiffs, type OverlayDiff, OverlayFs, type OverlayFsOptions, type OverlayNodeType, type OverlayWrite, } from "./fs/overlay-fs/index.js";
+export { applyDiffToRealFs, type OverlayDiff, OverlayFs, type OverlayFsOptions, type OverlayNodeType, type OverlayWrite, } from "./fs/overlay-fs/index.js";
 export { ReadWriteFs, type ReadWriteFsOptions, } from "./fs/read-write-fs/index.js";
 export { createVfsTemplate, type VfsTemplate, type VfsTemplateMount, type VfsTemplateOptions, } from "./fs/vfs-template.js";
 export type { AllowedUrl, AllowedUrlEntry, NetworkConfig, RequestTransform, SecureFetch, } from "./network/index.js";

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

@@ -21,6 +21,16 @@ export type ExecuteUserScriptFn = (scriptPath: string, args: string[], stdin?: s
 /**
  * Dispatch context containing dependencies needed for builtin dispatch
  */
+/** Stdio contract passed to builtin handlers. */
+export interface BuiltinIo {
+    stdin: string;
+    /** True when a redirection gave this command its own fd 0. `stdin`
+     * alone cannot express it: `cmd < empty-file` and an unredirected
+     * command both arrive as `""`, but only the first means EOF rather
+     * than "inherit the shell's stdin". */
+    stdinRedirected: boolean;
+    stdinSourceFd: number;
+}
 export interface BuiltinDispatchContext {
     ctx: InterpreterContext;
     runCommand: RunCommandFn;