just-binary 3.3.0 → 3.3.1

package/dist/interpreter/redirections.d.ts

@@ -33,6 +33,17 @@ export declare function expandRedirectionTarget(ctx: InterpreterContext, redir:
  */
 export declare function getInvalidRedirectTargetError(target: string): string | null;
 export declare function getBadFileDescriptorError(fd: number): string;
+/**
+ * Diagnostic for an input redirection whose target could not be read.
+ *
+ * bash distinguishes the reasons: `cat < missing` reports "No such file or
+ * directory" from the shell, while `cat < some-dir` opens the directory fine and
+ * the reader fails with "cat: stdin: Is a directory". Attributing it to the
+ * command needs provenance carried across lazy streams, which we do not have, so
+ * report the accurate reason under the shell's name rather than claiming a
+ * directory is missing.
+ */
+export declare function getInputRedirectionError(ctx: InterpreterContext, target: string): Promise<string>;
 /**
  * Allocate the next available file descriptor (starting at 10).
  * Returns the allocated FD number.

package/dist/process/process-table.d.ts

@@ -35,6 +35,14 @@ export declare class ProcessTable {
     private readonly jobs;
     private readonly reapedWaitStatuses;
     private readonly reapedWaitLineages;
+    /**
+     * Job numbers of reaped jobs, so `%n` still resolves right after the job dies.
+     * Real bash reaps asynchronously, so `kill %1; wait %1` resolves `%1` while
+     * `kill %1; sleep 0.3; wait %1` reports "no such job". We reap the instant the
+     * runner settles, which would lose that idiom; keeping the number mapping
+     * preserves it. Shares the wait-status lifecycle, so it is bounded the same way.
+     */
+    private readonly reapedJobNumbers;
     private readonly options;
     private nextPid;
     private nextLineageId;
@@ -52,8 +60,9 @@ export declare class ProcessTable {
     start(command: string, runner: JobRunner, lineageId?: number): number;
     list(): JobInfo[];
     /**
-     * Snapshot jobs for the `jobs` builtin and reap every completed job included
-     * in the snapshot. Markers are computed once for the complete table.
+     * Snapshot jobs for the `jobs` builtin. Only live jobs are ever listed, since
+     * completed ones are reaped as they settle — a non-interactive bash likewise
+     * never lists a finished job. Markers are computed once for the whole table.
      */
     listJobs(selectedPids?: ReadonlySet<number>, options?: ListJobsOptions): ListedJob[];
     get(pid: number): JobInfo | undefined;
@@ -68,9 +77,9 @@ export declare class ProcessTable {
      * every job in the table; shell builtins must use waitForLineage instead.
      */
     wait(pid?: number): Promise<number>;
-    /** Wait for and reap only jobs launched by one top-level shell execution. */
+    /** Wait for and reap only jobs launched by one shell's own execution. */
     waitForLineage(lineageId: number): Promise<number>;
-    /** Allocate an identity inherited by nested interpreters in one root exec. */
+    /** Allocate an identity shared by one shell's own in-process execution. */
     createLineageId(): number;
     abortAll(reason?: JobSignal): void;
     dispose(): Promise<void>;
@@ -87,6 +96,7 @@ export declare class ProcessTable {
     /** Report one output chunk. The table deliberately never retains it. */
     observeOutput(pid: number, fd: number, chunk: Uint8Array): void;
     private rememberWaitStatus;
+    private forgetWaitStatus;
     private deleteJobs;
 }
 export {};

package/dist/sandbox/Command.d.ts

@@ -21,12 +21,19 @@ export declare class Command {
     private processes;
     private shellProcesses;
     private logMessages;
+    private retainedLogBytes;
+    private droppedLogMessages;
     private logReaders;
     private logsComplete;
     private stdoutDecoder;
     private stderrDecoder;
     private resultPromise;
     constructor(bashEnv: Bash, cmdLine: string, cwd: string, env?: Record<string, string>, explicitCwd?: boolean, processes?: ProcessTable, shellProcesses?: ProcessTable);
+    /**
+     * Resolve with the signal's exit status once cancellation is requested, using
+     * the output collected so far. Never rejects, so it can lose a race safely.
+     */
+    private resultOnAbort;
     private appendLog;
     private execute;
     logs(): AsyncGenerator<OutputMessage, void, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-binary",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "A simulated bash environment with virtual filesystem",
   "repository": {
     "type": "git",