@orkestrel/process 0.0.4 → 0.0.6

package/dist/src/server/index.cjs

@@ -593,17 +593,41 @@ function waitForExit(child, timeout) {
 	return settled.promise.finally(() => clearTimeout(timer));
 }
 /**
+* Waits for one child process's streams to close, bounded by a deadline.
+*
+* @param child - The child boundary
+* @param timeout - The milliseconds to wait before giving up
+* @returns True when the host close arrived inside the deadline; false otherwise
+*
+* @example
+* ```ts
+* const closed = await waitForClose(child, 5_000)
+* ```
+*/
+function waitForClose(child, timeout) {
+	const closed = Promise.withResolvers();
+	const expired = Promise.withResolvers();
+	const timer = setTimeout(() => expired.resolve(false), timeout);
+	child.once("close", closed.resolve);
+	return Promise.race([closed.promise.then(() => true), expired.promise]).finally(() => {
+		clearTimeout(timer);
+		child.off("close", closed.resolve);
+	});
+}
+/**
 * Terminates one child process tree and reports whether its native exit was observed.
 *
 * @remarks
-* Windows ends the whole tree at once through {@link killTree}, falling back to a direct kill after
-* the utility fails, because the host has no cooperative termination to offer. A POSIX host signals
-* the process group `SIGTERM`, falls back to the direct child when no group owns its pid, waits
-* `grace`, then sends `SIGKILL` through the same route. No signal is initiated after the native exit
-* is observed; the window between initiating a signal and the host delivering it belongs to the
-* operating system. `confirm` bounds each awaited step rather than the call as a whole: on Windows
-* it bounds the `taskkill` call and then the final wait, and on a POSIX host `grace` bounds the
-* cooperative wait and `confirm` the final one. Never rejects.
+* An already-exited child is returned on before any route to its pid runs, because the host has
+* reaped that number and may have handed it to another process. Windows ends the whole tree at once
+* through {@link killTree}, falling back to a direct kill after the utility fails, because the host
+* has no cooperative termination to offer. A POSIX host signals the process group `SIGTERM`, falls
+* back to the direct child when no group owns its pid, waits `grace`, then sends `SIGKILL` through
+* the same route. No signal is initiated after the native exit is observed; the window between
+* initiating a signal and the host delivering it belongs to the operating system. `confirm` bounds
+* each awaited step rather than the call as a whole: on Windows it bounds the `taskkill` call and
+* then the final wait, and on a POSIX host `grace` bounds the cooperative wait and `confirm` the
+* final one. Never rejects.
 *
 * @param child - The child boundary
 * @param grace - The cooperative POSIX window in milliseconds between `SIGTERM` and `SIGKILL`
@@ -671,26 +695,23 @@ function buildExecuteResult(input) {
 //#endregion
 //#region src/server/Process.ts
 /**
-* One supervised child process with framed output, a bounded backlog, and bounded termination.
+* Supervises one child while keeping every observation channel aligned at termination.
 *
 * @remarks
-* Standard output is framed through `readline` into a single-consumer stream: each line goes to
-* exactly one waiting iterator, so concurrent iterators split the output rather than each receiving
-* all of it. While no consumer has ever requested an iterator, stdout keeps draining so `exit` still
-* resolves, and retention stops at the `backlog` mark: a
-* consumer attaching later receives the retained head, a gap, then the live stream. After an iterator
-* has been requested, stdout pauses at the mark and resumes at half of it, so that consumer loses
-* nothing before termination and the child feels real backpressure. The mark is soft — the ordinary backlog can
-* overshoot it by the line that crossed it plus the rest of its delivered chunk. Termination never
-* reapplies backpressure, and retained lines are capped at twice `backlog`; later lines are dropped
-* and `truncated` reports the omission. Standard error is decoded and forwarded live as the `stderr`
-* event while a byte-bounded raw tail is retained as `evidence`. The typed `emitter` also carries the
-* child `error` cause on a spawn fault and the terminal `exit`, alongside the `exit` promise. `pid`,
-* `code`, and `signal` read the spawned child directly, so the native exit is readable before the
-* `exit` promise settles on stdio close. `stop` ends the whole tree and reports whether the native
-* exit was observed; `destroy` stops the child, destroys stdin so every pending `send` settles, and
-* destroys the emitter last. `destroy` resolving does not imply the child's stdio has closed, so
-* `exit` and `lines` can still be outstanding when a descendant holds an inherited pipe.
+* The child's ending and the supervision's ending are distinct. `pid`, `code`, and `signal` read
+* the host child directly, so they expose native exit as soon as the host records it. `settled`,
+* `exit`, `evidence`, and `lines` reach one terminal moment after the read channels close or the
+* bounded `drain` window cuts them off. That window is armed by the child's native exit and by a
+* termination this package initiated, so every way a child can end reaches the moment. The terminal
+* routine freezes `evidence` and ends `lines` before it destroys stdout, stderr, or the emitter, so
+* the push channel never disappears while a pull channel can still change or wait indefinitely.
+*
+* Standard output is framed through `readline` into a single-consumer stream. Lines already framed
+* and queued remain available through the terminal moment, while bytes arriving after a requested
+* termination may be cut off. Standard error is forwarded through the live `stderr` event and
+* retained as a byte-bounded raw tail until that same moment. `stop` ends the child tree and the
+* observation surfaces. `destroy` performs that stop and then destroys the emitter after the
+* frozen terminal state exists.
 *
 * @example
 * ```ts
@@ -709,8 +730,10 @@ var Process = class {
 	#child;
 	#reader;
 	#grace;
+	#drain;
 	#evidence;
 	#backlog;
+	#delivery;
 	#decoder = new node_string_decoder.StringDecoder("utf8");
 	#exit = Promise.withResolvers();
 	#lines;
@@ -718,16 +741,20 @@ var Process = class {
 	#waiters = [];
 	#signal;
 	#abort;
+	#writes = /* @__PURE__ */ new Map();
 	#tail = node_buffer.Buffer.alloc(0);
 	#head = 0;
 	#pending = 0;
 	#requested = false;
 	#paused = false;
 	#truncated = false;
-	#terminating = false;
-	#closed = false;
+	#stopping = false;
+	#settled = false;
 	#ended = false;
-	#stopping;
+	#input = 0;
+	#failure;
+	#waiting;
+	#termination;
 	#ending;
 	/**
 	* Spawn one child process and begin stream capture.
@@ -739,8 +766,10 @@ var Process = class {
 		const source = options.command;
 		const workspace = options.workspace;
 		const grace = options.grace;
+		const drain = options.drain;
 		const evidence = options.evidence;
 		const backlog = options.backlog;
+		const delivery = options.delivery;
 		const writable = options.writable;
 		const signal = options.signal;
 		const on = options.on;
@@ -750,6 +779,8 @@ var Process = class {
 		validateCommand(command);
 		validateWorkspace(workspace);
 		validateTimer(grace, "option 'grace'");
+		validateTimer(drain, "option 'drain'");
+		validateTimer(delivery, "option 'delivery'");
 		validateBytes(evidence, "option 'evidence'", 0);
 		validateBytes(backlog, "option 'backlog'", 1);
 		this.#emitter = new _orkestrel_emitter.Emitter({
@@ -757,8 +788,10 @@ var Process = class {
 			...error === void 0 ? {} : { error }
 		});
 		this.#grace = grace ?? _src_core.PROCESS_GRACE;
+		this.#drain = drain ?? _src_core.PROCESS_DRAIN;
 		this.#evidence = evidence ?? _src_core.PROCESS_EVIDENCE;
 		this.#backlog = backlog ?? _src_core.PROCESS_BACKLOG;
+		this.#delivery = delivery ?? 0;
 		this.#signal = signal;
 		this.#lines = Object.freeze({ [Symbol.asyncIterator]: this.#iterate.bind(this) });
 		const childEnvironment = mergeEnvironment(command.isolated === true, command.environment);
@@ -785,11 +818,18 @@ var Process = class {
 		this.#reader.on("line", this.#push.bind(this));
 		this.#reader.once("close", this.#finish.bind(this));
 		this.#child.once("error", (cause) => this.#emitter.emit("error", cause));
+		this.#child.once("exit", this.#expire.bind(this));
 		this.#child.once("close", this.#close.bind(this));
-		this.#child.stdin.on("error", () => void 0);
+		this.#child.stdin.on("error", (cause) => this.#failInputStream(cause));
 		this.#child.stderr.on("data", this.#retain.bind(this));
-		if (input !== void 0) this.#child.stdin.write(input);
-		if (writable !== true) this.#child.stdin.end();
+		if (input !== void 0) {
+			this.#input += 1;
+			this.#child.stdin.write(input, this.#completeInput.bind(this));
+		}
+		if (writable !== true) {
+			this.#input += 1;
+			this.#child.stdin.end(this.#completeInput.bind(this));
+		}
 		if (signal !== void 0) {
 			this.#abort = this.#terminate.bind(this);
 			signal.addEventListener("abort", this.#abort, { once: true });
@@ -812,11 +852,11 @@ var Process = class {
 	get emitter() {
 		return this.#emitter;
 	}
-	/** The captured stdout lines, in arrival order, ending when the child's stdout closes. */
+	/** The captured stdout lines, in arrival order, ending after queued lines at the terminal moment. */
 	get lines() {
 		return this.#lines;
 	}
-	/** The decoded byte-bounded stderr tail. */
+	/** The decoded byte-bounded stderr tail, frozen at the terminal moment. */
 	get evidence() {
 		return this.#tail.toString("utf8");
 	}
@@ -824,7 +864,15 @@ var Process = class {
 	get truncated() {
 		return this.#truncated;
 	}
-	/** The terminal child state, observed once from the close event. */
+	/** True after the terminal moment arrived and `exit` settled. */
+	get settled() {
+		return this.#settled;
+	}
+	/** True after termination began, including after the terminal moment. */
+	get stopping() {
+		return this.#stopping;
+	}
+	/** The terminal child state, observed once after stream close or the drain cutoff. */
 	get exit() {
 		return this.#exit.promise;
 	}
@@ -832,51 +880,64 @@ var Process = class {
 	* Write one line to the open standard-input channel.
 	*
 	* @remarks
-	* Never rejects. The promise settles when the host reports the line handled, so a line written to
-	* a child that is not reading stays pending until the child drains it or the channel closes. Every
-	* terminal teardown path destroys stdin, so a pending write always settles by teardown; a caller
-	* that needs its own deadline arms a timer and calls `stop`.
+	* Never rejects. `true` means the host accepted the bytes without reporting a fault; it does not
+	* prove that the child read them. An ordinary write settles when the kernel accepts it. Only a
+	* full pipe can hold the write unconfirmed. The `delivery` option can bound that wait, and every
+	* terminal teardown path settles pending writes. On Windows 11 with Node v24.18.1, measured on
+	* 2026-08-21, a child that closes its own file descriptor 0 can leave the parent pipe writable:
+	* the write can settle `true` without a callback error or a stream error while the child remains
+	* alive. After `stop` or `destroy` begins, a later call settles `false`. Version 0.0.4 could settle
+	* that call `true` before teardown destroyed the pipe; returning `false` avoids claiming delivery
+	* for bytes the package is about to discard.
 	*
 	* @param text - The line text without its trailing newline
-	* @returns True when the line reached the host without error; false when the channel was closed, destroyed, ended, or the write failed
+	* @returns True when the host accepted the bytes without reporting a fault; false when the channel was closed, destroyed, ended, failed, or remained unconfirmed through `delivery`
 	*/
 	send(text) {
 		const stdin = this.#child.stdin;
-		if (this.#closed || !stdin.writable) return Promise.resolve(false);
+		if (this.#settled || this.#stopping || this.#failure !== void 0 || !stdin.writable) return Promise.resolve(false);
 		const settled = Promise.withResolvers();
+		this.#writes.set(settled, void 0);
 		try {
-			stdin.write(`${text}\n`, (error) => {
-				settled.resolve(error === void 0 || error === null);
-			});
+			stdin.write(`${text}\n`, this.#confirmWrite.bind(this, settled));
 		} catch {
-			return Promise.resolve(false);
+			this.#settleWrite(settled, false);
+			return settled.promise;
+		}
+		if (this.#delivery > 0 && this.#writes.has(settled)) {
+			const timer = setTimeout(() => this.#settleWrite(settled, false), this.#delivery);
+			timer.unref();
+			this.#writes.set(settled, timer);
 		}
 		return settled.promise;
 	}
 	/**
-	* Terminate the child process tree and await its observed exit.
+	* Terminates the child process tree and reaches the terminal observation moment.
 	*
 	* @remarks
-	* Never rejects, and every call shares one termination.
+	* Never rejects, and every call shares one termination. After the termination sequence returns,
+	* confirmed or not, it waits at most `drain` for the read channels to close, then cuts them off
+	* and settles `exit` when they remain open. A cutoff reached before the native exit reports the
+	* `code` and `signal` the host had recorded by then, which is `null` for a child still running.
 	*
 	* @returns True when the child's native exit was observed; false when the confirmation deadline elapsed without it
 	*/
 	stop() {
-		if (this.#stopping !== void 0) return this.#stopping;
-		this.#stopping = this.#kill();
-		return this.#stopping;
+		if (this.#termination !== void 0) return this.#termination;
+		this.#termination = this.#kill();
+		return this.#termination;
 	}
 	/**
-	* Stop the child, close its standard-input channel, and destroy the observation emitter.
+	* Stops the child and destroys the observation emitter after the terminal state freezes.
 	*
 	* @remarks
-	* Always resolves, including when termination was never confirmed.
+	* Always resolves, including when termination was never confirmed. Every call shares one barrier.
 	*
 	* @returns The stable barrier shared by every call
 	*/
 	destroy() {
 		if (this.#ending !== void 0) return this.#ending;
-		this.#ending = this.#teardown();
+		this.#ending = this.#end();
 		return this.#ending;
 	}
 	#iterate() {
@@ -922,8 +983,8 @@ var Process = class {
 			return;
 		}
 		const bytes = node_buffer.Buffer.byteLength(line) + 1;
-		const limit = this.#terminating ? this.#backlog * 2 : this.#backlog;
-		if ((!this.#requested || this.#terminating) && this.#pending + bytes > limit) {
+		const limit = this.#stopping ? this.#backlog * 2 : this.#backlog;
+		if ((!this.#requested || this.#stopping) && this.#pending + bytes > limit) {
 			this.#truncated = true;
 			return;
 		}
@@ -932,14 +993,14 @@ var Process = class {
 		this.#restrain();
 	}
 	#restrain() {
-		if (this.#paused || this.#terminating || !this.#requested) return;
+		if (this.#paused || this.#stopping || !this.#requested) return;
 		if (this.#pending < this.#backlog) return;
 		this.#paused = true;
 		this.#reader.pause();
 	}
 	#relieve() {
 		if (!this.#paused || this.#ended) return;
-		if (!this.#terminating && this.#pending > this.#backlog / 2) return;
+		if (!this.#stopping && this.#pending > this.#backlog / 2) return;
 		this.#paused = false;
 		this.#reader.resume();
 	}
@@ -954,24 +1015,40 @@ var Process = class {
 		this.#waiters.length = 0;
 	}
 	#retain(chunk) {
-		if (!node_buffer.Buffer.isBuffer(chunk) || this.#closed) return;
+		if (!node_buffer.Buffer.isBuffer(chunk) || this.#settled) return;
 		this.#tail = trimTail(node_buffer.Buffer.concat([this.#tail, chunk]), this.#evidence);
 		const text = this.#decoder.write(chunk);
 		if (text.length > 0) this.#emitter.emit("stderr", text);
 	}
-	#close(code, signal) {
-		if (this.#closed) return;
+	#close() {
+		if (this.#settled) return;
+		this.#settle(true);
+	}
+	#expire() {
+		if (this.#settled) return;
+		this.#wait();
+	}
+	#wait() {
+		this.#waiting ??= waitForClose(this.#child, this.#drain).then(() => {
+			if (!this.#settled) this.#settle(false);
+		});
+		return this.#waiting;
+	}
+	#settle(drained) {
 		const suffix = this.#decoder.end();
 		if (suffix.length > 0) this.#emitter.emit("stderr", suffix);
-		this.#closed = true;
+		this.#settled = true;
 		this.#removeAbortListener();
 		this.#reader.close();
 		const exit = Object.freeze({
-			code,
-			signal
+			code: this.code,
+			signal: this.signal,
+			drained
 		});
 		this.#exit.resolve(exit);
 		this.#emitter.emit("exit", exit);
+		this.#child.stdout.destroy();
+		this.#child.stderr.destroy();
 	}
 	#terminate() {
 		this.stop();
@@ -980,6 +1057,42 @@ var Process = class {
 		if (this.#signal === void 0 || this.#abort === void 0) return;
 		this.#signal.removeEventListener("abort", this.#abort);
 	}
+	#confirmWrite(settled, error) {
+		if (error === void 0 || error === null) {
+			this.#settleWrite(settled, true);
+			return;
+		}
+		this.#failInputCallback(error);
+	}
+	#completeInput() {
+		this.#input -= 1;
+	}
+	#settleWrite(settled, accepted) {
+		if (!this.#writes.has(settled)) return;
+		const timer = this.#writes.get(settled);
+		this.#writes.delete(settled);
+		clearTimeout(timer);
+		settled.resolve(accepted);
+	}
+	#settleWrites() {
+		for (const settled of this.#writes.keys()) this.#settleWrite(settled, false);
+	}
+	#failInputStream(cause) {
+		if (this.#child.stdin.writableEnded || this.#input > 0) {
+			this.#settleWrites();
+			return;
+		}
+		this.#failInputCallback(cause);
+	}
+	#failInputCallback(cause) {
+		if (this.#failure !== void 0 || this.#stopping) return;
+		this.#failure = cause;
+		this.#settleWrites();
+		this.#emitter.emit("error", new _src_core.ProcessError("The standard-input channel failed", {
+			code: "protocol",
+			cause
+		}));
+	}
 	#capBacklog() {
 		const limit = this.#backlog * 2;
 		while (this.#pending > limit && this.#queue.length > this.#head) {
@@ -990,15 +1103,17 @@ var Process = class {
 		}
 	}
 	async #kill() {
-		this.#terminating = true;
+		this.#stopping = true;
 		this.#capBacklog();
 		this.#relieve();
 		const confirmed = await stopChild(this.#child, this.#grace, _src_core.PROCESS_CONFIRMATION);
+		this.#settleWrites();
 		this.#child.stdin.destroy();
+		if (!this.#settled) await this.#wait();
+		if (!this.#settled) this.#settle(false);
 		return confirmed;
 	}
-	async #teardown() {
-		this.#removeAbortListener();
+	async #end() {
 		await this.stop();
 		this.#emitter.destroy();
 	}
@@ -1017,9 +1132,9 @@ var Process = class {
 * the child registered. `launch` throws a {@link createDuplicateError} when the id is already live
 * and a {@link createProtocolError} after `destroy` has begun, including when the caller's own option
 * getter begins that teardown mid-construction — a spawn fault surfaces through the returned child's
-* `exit`, never from `launch`. `destroy` awaits every child's own teardown, which destroys each
-* child's observation emitter and leaves every subscription on it silently inert, then destroys the
-* registry emitter last.
+* `exit`, never from `launch`. `destroy` awaits every child's own teardown, including the teardown
+* of a child a lost race refused, which destroys each child's observation emitter and leaves every
+* subscription on it silently inert, then destroys the registry emitter last.
 *
 * @example
 * ```ts
@@ -1038,6 +1153,7 @@ var ProcessManager = class {
 	#emitter;
 	#children = /* @__PURE__ */ new Map();
 	#ids = /* @__PURE__ */ new Set();
+	#orphans = /* @__PURE__ */ new Set();
 	#destroying = false;
 	#ending;
 	/**
@@ -1084,11 +1200,11 @@ var ProcessManager = class {
 	* @remarks
 	* {@link Process} reads every option before it spawns, so a caller's own option getter runs while
 	* nothing has started and a throw from one strands no process. A getter that begins `destroy`
-	* without throwing is the one remaining race, and it leaves a bounded residual: the child is
-	* already spawned, so the launch is refused with a {@link createProtocolError} and that child is
-	* torn down asynchronously, bounded by `grace` plus the confirmation window. The `protocol`
-	* refusal throws synchronously before the `destroy` barrier settles. The barrier does not cover
-	* that child's asynchronous teardown.
+	* without throwing is the one remaining race: the child is already spawned, so the launch is
+	* refused with a {@link createProtocolError} and that child is destroyed rather than adopted, its
+	* teardown bounded by `grace` plus the confirmation window. The `protocol` refusal throws
+	* synchronously, and the `destroy` barrier covers that teardown, so the refused child reaches its
+	* terminal moment before the barrier resolves.
 	*
 	* @param id - The registry key, unique among live children
 	* @param options - The child construction options
@@ -1102,6 +1218,7 @@ var ProcessManager = class {
 		const child = this.#construct(id, options);
 		if (this.#destroying) {
 			this.#ids.delete(id);
+			this.#orphans.add(child);
 			child.destroy();
 			throw (0, _src_core.createProtocolError)(id);
 		}
@@ -1158,6 +1275,11 @@ var ProcessManager = class {
 	}
 	async #teardown() {
 		await Promise.allSettled([...this.#children.values()].map((child) => child.destroy()));
+		while (this.#orphans.size > 0) {
+			const orphans = [...this.#orphans];
+			this.#orphans.clear();
+			await Promise.allSettled(orphans.map((child) => child.destroy()));
+		}
 		this.#children.clear();
 		this.#ids.clear();
 		this.#emitter.destroy();
@@ -1258,9 +1380,13 @@ var Retention = class {
 * rather than on process exit, so a descendant that inherited the child's stdio holds the run open
 * after the child itself has gone. Give such a run a `timeout`. The child's `environment` merges over
 * the parent unless the command is `isolated`, then `options.environment` on top, and `options.input`
-* overrides `command.input`. Unless `strict` is `false`, a failed run rejects with a
-* {@link createExecuteError} carrying the {@link ExecuteResult}. An invalid option or command string rejects
-* before the child is spawned, because an async function cannot throw synchronously.
+* overrides `command.input`. A host fault while writing that input terminates the run by design and
+* marks its result failed; a strict rejection carries the host fault as its cause. This differs
+* from `Process` constructor input, whose package-initiated input phase stays quiet. Unless `strict`
+* is `false`, a failed run rejects with a {@link ProcessError} carrying the {@link ExecuteResult};
+* {@link createExecuteError} constructs every rejection outside the input-fault door. An invalid
+* option or command string rejects before the child is spawned, because an async function cannot
+* throw synchronously.
 *
 * @param command - The executable, arguments, and optional environment and input
 * @param options - Working directory, timeout, grace, signal, capture limit, and failure delivery
@@ -1304,6 +1430,7 @@ async function execute(command, options) {
 	const terminate = new AbortController();
 	const cleanup = new AbortController();
 	const finish = new AbortController();
+	const inputFailure = new AbortController();
 	const outChunks = [];
 	const errChunks = [];
 	const outRetention = new Retention();
@@ -1344,6 +1471,7 @@ async function execute(command, options) {
 		}));
 	}, { once: true });
 	terminate.signal.addEventListener("abort", () => {
+		if (finish.signal.aborted) return;
 		clearTimeout(timeoutTimer);
 		cleanup.abort();
 		stopChild(child, grace, _src_core.PROCESS_CONFIRMATION).then(() => {
@@ -1351,7 +1479,12 @@ async function execute(command, options) {
 			confirmTimer = setTimeout(() => finish.abort(), _src_core.PROCESS_CONFIRMATION);
 		});
 	}, { once: true });
-	child.stdin.on("error", () => void 0);
+	inputFailure.signal.addEventListener("abort", () => {
+		if (finish.signal.aborted) return;
+		cause = inputFailure.signal.reason;
+		terminate.abort();
+	}, { once: true });
+	child.stdin.on("error", (error) => inputFailure.abort(error));
 	child.stdout.on("data", (chunk) => {
 		const retained = outRetention.retain(chunk, limit);
 		if (retained !== void 0) outChunks.push(retained);
@@ -1369,7 +1502,9 @@ async function execute(command, options) {
 		finish.abort();
 	});
 	child.once("close", () => finish.abort());
-	if (text !== void 0) child.stdin.write(text);
+	if (text !== void 0) child.stdin.write(text, (error) => {
+		if (error !== void 0 && error !== null) inputFailure.abort(error);
+	});
 	child.stdin.end();
 	if (timeout > 0) timeoutTimer = setTimeout(() => {
 		expired = true;
@@ -1389,7 +1524,19 @@ async function execute(command, options) {
 		}
 	}
 	const result = await settled.promise;
-	if (result.failed && strict) throw (0, _src_core.createExecuteError)(result, cause);
+	if (result.failed && strict) {
+		if (cause !== void 0 && cause === inputFailure.signal.reason) throw new _src_core.ProcessError(`Command '${result.command}' failed while writing standard input`, {
+			code: "input",
+			context: {
+				command: result.command,
+				code: result.code,
+				signal: result.signal
+			},
+			cause: inputFailure.signal.reason,
+			result
+		});
+		throw (0, _src_core.createExecuteError)(result, cause);
+	}
 	return result;
 }
 //#endregion
@@ -1547,6 +1694,7 @@ exports.validateEnvironment = validateEnvironment;
 exports.validateText = validateText;
 exports.validateTimer = validateTimer;
 exports.validateWorkspace = validateWorkspace;
+exports.waitForClose = waitForClose;
 exports.waitForExit = waitForExit;
 
 //# sourceMappingURL=index.cjs.map