rea-agents 6.4.0 → 6.7.0

package/dist/mcp/OwnedCommand-BW1jBSt9.js

@@ -0,0 +1,1241 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { D as init_DarwinProcessRunTokenReader, S as prepareProcessOwnershipInspection, T as DarwinProcessOwnershipInspectionError, d as cleanupOwnedProcessGroup, g as init_ProcessOwnershipObservation, p as init_ProcessOwnership, w as systemProcessOwnershipHost } from "./ArtifactFileOperation-64cQKI7B.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { PACKAGE_METADATA } from "../generatedPackageMetadata.js";
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+//#region dist/process/snapshotEnvironment.js
+var snapshotEnvironment;
+function init_snapshotEnvironment() {
+	return (init_snapshotEnvironment = __esmMin((() => {
+		snapshotEnvironment = (environment, platform = process.platform) => {
+			if (platform !== "win32") return Object.freeze({ ...environment });
+			const selected = new Map();
+			for (const [key, value] of Object.entries(environment)) selected.set(key.toUpperCase(), value);
+			const snapshot = {};
+			for (const key of [...selected.keys()].sort()) snapshot[key] = selected.get(key);
+			return Object.freeze(snapshot);
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/windows/WindowsNativeLoader.js
+var windowsHandleSchema, windowsFileIdentitySchema, windowsNativeManifestSchema, inspectionSchema, bindingSchema, missingWindowsNativeFileReason, readPackagedWindowsNativeFile, loadWindowsNativeAuthority, assertWindowsX64Artifact, cached, systemWindowsNativeAuthority, requireWindowsNativeAuthority;
+function init_WindowsNativeLoader() {
+	return (init_WindowsNativeLoader = __esmMin((() => {
+		windowsHandleSchema = z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+		windowsFileIdentitySchema = z.strictObject({
+			requestedPath: z.string(),
+			finalPath: z.string(),
+			filesystem: z.literal("NTFS"),
+			volumeSerial: z.string().regex(/^[a-f0-9]{16}$/u),
+			fileId: z.string().regex(/^[a-f0-9]{32}$/u),
+			size: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+			directory: z.boolean()
+		});
+		windowsNativeManifestSchema = z.strictObject({
+			packageVersion: z.string(),
+			platform: z.literal("win32"),
+			architecture: z.literal("x64"),
+			abiVersion: z.literal(1),
+			nodeApiVersion: z.literal(8),
+			artifact: z.literal("rea-windows-x64.node"),
+			artifactSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+		});
+		inspectionSchema = z.strictObject({
+			abiVersion: z.literal(1),
+			nodeApiVersion: z.literal(8),
+			architecture: z.literal("x64"),
+			filesystem: windowsFileIdentitySchema,
+			privateDacl: z.literal(true),
+			privateBridgeDescriptorAccess: z.literal(true),
+			atomicJobAssignment: z.literal(true),
+			killOnOwnerClose: z.literal(true),
+			protocolStdin: z.boolean().optional(),
+			/** Absent from artifacts built before owned Job Object commit limits. */
+			jobMemoryLimit: z.literal(true).optional()
+		});
+		bindingSchema = z.strictObject({ call: z.custom((value) => typeof value === "function") });
+		missingWindowsNativeFileReason = (file) => `Missing packaged Windows native file native/windows/build/${file} (ENOENT). Restore both native/windows/build/manifest.json and native/windows/build/rea-windows-x64.node from the rea-agents@${PACKAGE_METADATA.version} tarball or build them with native/windows/README.md; no native artifact was loaded.`;
+		readPackagedWindowsNativeFile = (file, read) => {
+			try {
+				return read();
+			} catch (cause) {
+				if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT") throw new Error(missingWindowsNativeFileReason(file), { cause });
+				throw cause;
+			}
+		};
+		loadWindowsNativeAuthority = (host) => {
+			if (host.platform !== "win32" || host.architecture !== "x64") return {
+				available: false,
+				failureStage: "host",
+				reason: "REA Windows native controls require a Windows x64 host."
+			};
+			const nodeApiVersion = Number(host.nodeApiVersion);
+			if (!Number.isSafeInteger(nodeApiVersion) || nodeApiVersion < 8) return {
+				available: false,
+				failureStage: "host",
+				reason: "REA Windows native controls require Node-API 8 or newer."
+			};
+			try {
+				const manifest = windowsNativeManifestSchema.parse(readPackagedWindowsNativeFile("manifest.json", () => host.readManifest()));
+				if (manifest.packageVersion !== host.packageVersion) throw new Error("Windows native artifact belongs to another REA version");
+				const artifact = readPackagedWindowsNativeFile("rea-windows-x64.node", () => host.readArtifact());
+				if (createHash("sha256").update(artifact).digest("hex") !== manifest.artifactSha256) throw new Error("Windows native artifact SHA-256 does not match package metadata");
+				assertWindowsX64Artifact(artifact);
+				const binding = bindingSchema.parse(host.loadArtifact());
+				let observed;
+				try {
+					observed = binding.call("inspect", []);
+				} catch (cause) {
+					return {
+						available: false,
+						failureStage: "self-test",
+						retryable: true,
+						reason: `REA Windows native self-test failed: ${cause instanceof Error ? cause.message : String(cause)}`
+					};
+				}
+				const parsed = inspectionSchema.safeParse(observed);
+				if (!parsed.success) return {
+					available: false,
+					failureStage: "inspection",
+					reason: `REA Windows native inspection is invalid: ${parsed.error.message}`
+				};
+				const inspection = parsed.data;
+				return {
+					available: true,
+					authority: {
+						call: binding.call,
+						inspection
+					}
+				};
+			} catch (cause) {
+				return {
+					available: false,
+					failureStage: "artifact",
+					reason: `REA Windows native controls are unavailable: ${cause instanceof Error ? cause.message : String(cause)}`
+				};
+			}
+		};
+		assertWindowsX64Artifact = (bytes) => {
+			if (bytes.length < 64 || bytes.toString("latin1", 0, 2) !== "MZ") throw new Error("Windows native artifact is not a PE image");
+			const offset = bytes.readUInt32LE(60);
+			if (offset > bytes.length - 26 || bytes.toString("latin1", offset, offset + 4) !== "PE\0\0" || bytes.readUInt16LE(offset + 4) !== 34404 || bytes.readUInt16LE(offset + 24) !== 523) throw new Error("Windows native artifact is not a Windows x64 PE32+ image");
+		};
+		;
+		systemWindowsNativeAuthority = () => {
+			if (cached?.available === false && cached.retryable === true) cached = undefined;
+			cached ??= loadWindowsNativeAuthority({
+				platform: process.platform,
+				architecture: process.arch,
+				nodeApiVersion: process.versions.napi,
+				packageVersion: PACKAGE_METADATA.version,
+				readManifest: () => {
+					const encoded = readFileSync(new URL("../../native/windows/build/manifest.json", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href), "utf8");
+					const value = JSON.parse(encoded);
+					return value;
+				},
+				readArtifact: () => readFileSync(new URL("../../native/windows/build/rea-windows-x64.node", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)),
+				loadArtifact: () => {
+					const value = createRequire(new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)(fileURLToPath(new URL("../../native/windows/build/rea-windows-x64.node", new URL("../windows/WindowsNativeLoader.js", import.meta.url).href)));
+					return value;
+				}
+			});
+			return cached;
+		};
+		requireWindowsNativeAuthority = () => {
+			const loaded = systemWindowsNativeAuthority();
+			if (!loaded.available) throw new Error(loaded.reason);
+			return loaded.authority;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/ProviderDeadline.js
+var waitForAbortableDelay, ProviderStartupDeadline;
+function init_ProviderDeadline() {
+	return (init_ProviderDeadline = __esmMin((() => {
+		waitForAbortableDelay = (milliseconds, signal) => {
+			if (signal?.aborted === true) return Promise.resolve("aborted");
+			return new Promise((resolve) => {
+				const settle = (result) => {
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", onAbort);
+					resolve(result);
+				};
+				const onAbort = () => settle("aborted");
+				const timer = setTimeout(() => settle("elapsed"), Math.max(0, milliseconds));
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		};
+		ProviderStartupDeadline = class {
+			timeoutMs;
+			#controller = new AbortController();
+			#deadlineAt;
+			#externalSignal;
+			#onExternalAbort;
+			#timer;
+			#interruption;
+			constructor(timeoutMs, signal) {
+				this.timeoutMs = timeoutMs;
+				if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new RangeError("Provider startup timeout must be positive");
+				this.#deadlineAt = performance.now() + timeoutMs;
+				this.#externalSignal = signal;
+				this.#onExternalAbort = () => {
+					if (this.#controller.signal.aborted) return;
+					if (performance.now() >= this.#deadlineAt) {
+						this.#interruption = "timeout";
+						this.#abort(new DOMException("Provider startup deadline elapsed", "TimeoutError"));
+						return;
+					}
+					this.#interruption = "cancelled";
+					this.#abort(signal?.reason);
+				};
+				if (signal?.aborted === true) {
+					this.#onExternalAbort();
+					return;
+				}
+				signal?.addEventListener("abort", this.#onExternalAbort, { once: true });
+				this.#armDeadlineTimer(timeoutMs);
+			}
+			/** Composite signal aborted by either the caller or the absolute deadline. */
+			get signal() {
+				return this.#controller.signal;
+			}
+			/** First control path that interrupted startup, if any. */
+			get interruption() {
+				return this.#interruption ?? (performance.now() >= this.#deadlineAt ? "timeout" : undefined);
+			}
+			/** Milliseconds still available to the next startup phase. */
+			remainingMs() {
+				if (this.#interruption === "timeout") return 0;
+				return Math.max(0, Math.ceil(this.#deadlineAt - performance.now()));
+			}
+			/**
+			* Wait for at most one polling interval under the shared deadline signal.
+			*
+			* Both timers may fire before their monotonic targets. Retain the earlier
+			* of the polling target and deadline, and wait again for any residual time.
+			*/
+			wait(milliseconds) {
+				const startedAt = performance.now();
+				const targetAt = Math.min(startedAt + milliseconds, this.#deadlineAt);
+				const poll = () => {
+					const budget = this.remainingMs();
+					const residual = Math.max(0, targetAt - performance.now());
+					return waitForAbortableDelay(Math.min(residual, budget), this.signal).then((result) => {
+						if (result === "aborted") return "aborted";
+						const now = performance.now();
+						if (now >= this.#deadlineAt) return "aborted";
+						if (now >= targetAt) return "elapsed";
+						return poll();
+					});
+				};
+				return poll();
+			}
+			/** Release the deadline timer and external abort listener. */
+			dispose() {
+				this.#clearTimer();
+				this.#externalSignal?.removeEventListener("abort", this.#onExternalAbort);
+			}
+			#abort(reason) {
+				this.#clearTimer();
+				this.#externalSignal?.removeEventListener("abort", this.#onExternalAbort);
+				this.#controller.abort(reason);
+			}
+			#clearTimer() {
+				if (this.#timer !== undefined) clearTimeout(this.#timer);
+				this.#timer = undefined;
+			}
+			/**
+			* Arm (or re-arm) the timer that expires the absolute monotonic deadline.
+			*
+			* Re-check the clock before classifying expiry, and retain the residual
+			* budget when the timer arrives early.
+			*/
+			#armDeadlineTimer(milliseconds) {
+				this.#timer = setTimeout(() => {
+					this.#timer = undefined;
+					if (this.#controller.signal.aborted) return;
+					if (performance.now() >= this.#deadlineAt) {
+						this.#interruption = "timeout";
+						this.#abort(new DOMException("Provider startup deadline elapsed", "TimeoutError"));
+						return;
+					}
+					this.#armDeadlineTimer(this.remainingMs());
+				}, milliseconds);
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/windows/WindowsOwnedProcess.js
+var launchSchema, pollSchema, limitedPollSchema, quoteWindowsProcessArgument, WindowsOwnedProcess;
+function init_WindowsOwnedProcess() {
+	return (init_WindowsOwnedProcess = __esmMin((() => {
+		init_WindowsNativeLoader();
+		launchSchema = z.strictObject({
+			pid: z.number().int().positive().max(4294967295),
+			handle: windowsHandleSchema,
+			jobAssigned: z.literal(true),
+			killOnOwnerClose: z.literal(true)
+		});
+		pollSchema = z.strictObject({
+			stdout: z.instanceof(Buffer),
+			stderr: z.instanceof(Buffer),
+			stdoutEnded: z.boolean(),
+			stderrEnded: z.boolean(),
+			exitCode: z.number().int().nonnegative().max(4294967295).nullable(),
+			activeProcesses: z.number().int().nonnegative()
+		});
+		limitedPollSchema = pollSchema.extend({
+			memoryLimitReached: z.boolean(),
+			peakJobMemoryBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+		});
+		quoteWindowsProcessArgument = (value) => {
+			if (value.includes("\0")) throw new TypeError("Windows process argument contains NUL");
+			return `"${value.replace(/(\\*)"/gu, "$1$1\\\"").replace(/(\\+)$/u, "$1$1")}"`;
+		};
+		WindowsOwnedProcess = class extends EventEmitter {
+			stdout = new PassThrough();
+			stderr = new PassThrough();
+			stdin;
+			signalCode = null;
+			exitCode = null;
+			pid;
+			#handle;
+			#authority;
+			#settled;
+			#settle;
+			#closed = false;
+			#failure;
+			#timer;
+			#blockedWake;
+			#blockedOutput = new Set();
+			#unreferenced = false;
+			#cleanup;
+			#memoryLimitBytes;
+			#memoryLimitReached = false;
+			#peakJobMemoryBytes;
+			#outputIncomplete = false;
+			constructor(command, arguments_, cwd, environment, verbatim, options = {}) {
+				super();
+				const protocolStdin = options.protocolStdin === true;
+				this.#memoryLimitBytes = options.memoryLimitBytes;
+				this.#authority = options.authority ?? requireWindowsNativeAuthority();
+				if (protocolStdin && this.#authority.inspection.protocolStdin !== true) throw new Error("The bundled Windows native artifact does not support owned protocol stdin; use a matching current Windows x64 REA package.");
+				if (this.#memoryLimitBytes !== undefined && this.#authority.inspection.jobMemoryLimit !== true) throw new Error("The bundled Windows native artifact does not support Job Object memory limits; use a matching current Windows x64 REA package.");
+				const entries = Object.entries(environment).filter((entry) => entry[1] !== undefined).map(([key, value]) => `${key}=${value}`);
+				const line = [quoteWindowsProcessArgument(command.replaceAll("/", "\\")), ...arguments_.map((value) => verbatim ? value : quoteWindowsProcessArgument(value))].join(" ");
+				let controls = protocolStdin ? [true] : [];
+				if (this.#memoryLimitBytes !== undefined) controls = [protocolStdin, this.#memoryLimitBytes];
+				const spawned = this.#authority.call("process_spawn", [
+					command,
+					line,
+					cwd ?? "",
+					entries,
+					...controls
+				]);
+				const launched = this.#memoryLimitBytes === undefined ? launchSchema.parse(spawned) : launchSchema.extend({ jobMemoryLimitBytes: z.literal(this.#memoryLimitBytes) }).parse(spawned);
+				this.pid = launched.pid;
+				this.#handle = launched.handle;
+				this.stdin = protocolStdin ? new Writable({
+					write: (chunk, _encoding, callback) => {
+						void this.#writeInput(chunk).then(() => callback(), (cause) => callback(cause instanceof Error ? cause : new Error(String(cause))));
+					},
+					final: (callback) => {
+						try {
+							this.#authority.call("process_stdin_close", [this.#handle]);
+							callback();
+						} catch (cause) {
+							callback(cause instanceof Error ? cause : new Error(String(cause)));
+						}
+					},
+					destroy: (cause, callback) => {
+						try {
+							if (!this.#closed) this.#authority.call("process_stdin_close", [this.#handle]);
+							callback(cause);
+						} catch (failure) {
+							callback(failure instanceof Error ? failure : new Error(String(failure)));
+						}
+					}
+				}) : null;
+				this.#settled = new Promise((resolve) => {
+					this.#settle = resolve;
+				});
+				this.#schedule();
+			}
+			/** Whether the job reported reaching its commit limit; sticky once observed. */
+			get memoryLimitReached() {
+				return this.#memoryLimitReached;
+			}
+			/** Latest observed peak job commit; undefined for an unlimited job. */
+			get peakJobMemoryBytes() {
+				return this.#peakJobMemoryBytes;
+			}
+			/** True when cleanup destroyed a backpressured stream before all output was observed. */
+			get outputIncomplete() {
+				return this.#outputIncomplete;
+			}
+			async #writeInput(chunk) {
+				const bytes = z.instanceof(Buffer).parse(chunk);
+				const written = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).parse(await this.#authority.call("process_stdin_write", [this.#handle, bytes]));
+				if (written !== bytes.length) throw new Error("Owned Windows input write did not preserve all requested bytes");
+			}
+			/** Terminate the retained job, never a PID supplied by another caller. */
+			kill(signal) {
+				if (signal === 0) return !this.#closed && z.number().parse(this.#authority.call("process_alive", [this.#handle])) > 0;
+				return this.#closed ? false : z.boolean().parse(this.#authority.call("process_terminate", [this.#handle]));
+			}
+			/** Terminate and verify that the entire job has settled before releasing it. */
+			cleanup() {
+				this.#cleanup ??= this.#stop().then((result) => {
+					if (!result.cleaned) this.#cleanup = undefined;
+					return result;
+				});
+				return this.#cleanup;
+			}
+			/** Release event-loop references so unsettled jobs do not prevent host exit. */
+			unref() {
+				this.#unreferenced = true;
+				this.#timer?.unref();
+				this.#blockedWake?.unref();
+			}
+			/** Restore event-loop references when retrying process lifecycle observation. */
+			ref() {
+				this.#unreferenced = false;
+				this.#timer?.ref();
+				this.#blockedWake?.ref();
+			}
+			async #stop() {
+				if (this.#closed) return {
+					cleaned: true,
+					signaled: false
+				};
+				let timer;
+				try {
+					const signaled = this.kill();
+					this.#discardBlockedOutput();
+					this.#schedule();
+					const settled = await Promise.race([this.#settled.then(() => true), new Promise((resolve) => {
+						timer = setTimeout(() => resolve(false), 5e3);
+					})]);
+					return settled ? {
+						cleaned: true,
+						signaled
+					} : {
+						cleaned: false,
+						reason: this.#failure ?? "Windows Job Object did not settle within the cleanup deadline"
+					};
+				} catch (cause) {
+					return {
+						cleaned: false,
+						reason: cause instanceof Error ? cause.message : String(cause)
+					};
+				} finally {
+					if (timer !== undefined) clearTimeout(timer);
+				}
+			}
+			#schedule(delay = 25) {
+				if (this.#closed || this.#timer !== undefined || this.#blockedOutput.size > 0) return;
+				this.#timer = setTimeout(() => this.#poll(), delay);
+				if (this.#unreferenced) this.#timer.unref();
+			}
+			#scheduleBlockedWake() {
+				if (this.#closed || this.#blockedOutput.size === 0 || this.#blockedWake !== undefined) return;
+				this.#blockedWake = setTimeout(() => {
+					this.#blockedWake = undefined;
+					this.#scheduleBlockedWake();
+				}, 1e3);
+				if (this.#unreferenced) this.#blockedWake.unref();
+			}
+			#clearBlockedWake() {
+				if (this.#blockedWake !== undefined) clearTimeout(this.#blockedWake);
+				this.#blockedWake = undefined;
+			}
+			#unblockOutput(stream) {
+				if (stream.destroyed) this.#outputIncomplete = true;
+				this.#blockedOutput.delete(stream);
+				if (this.#blockedOutput.size === 0) this.#clearBlockedWake();
+				this.#schedule(0);
+			}
+			#discardBlockedOutput() {
+				if (this.#blockedOutput.size > 0) this.#outputIncomplete = true;
+				for (const stream of this.#blockedOutput) stream.destroy();
+				this.#blockedOutput.clear();
+				this.#clearBlockedWake();
+			}
+			#poll() {
+				this.#timer = undefined;
+				if (this.#closed) return;
+				try {
+					const observed = this.#authority.call("process_poll", [this.#handle]);
+					let state;
+					if (this.#memoryLimitBytes === undefined) state = pollSchema.parse(observed);
+					else {
+						const limited = limitedPollSchema.parse(observed);
+						this.#memoryLimitReached ||= limited.memoryLimitReached;
+						this.#peakJobMemoryBytes = limited.peakJobMemoryBytes;
+						state = limited;
+					}
+					this.#failure = undefined;
+					const idle = state.stdout.length === 0 && state.stderr.length === 0;
+					this.#writeOutput(this.stdout, state.stdout);
+					this.#writeOutput(this.stderr, state.stderr);
+					if (state.exitCode !== null && this.exitCode === null) {
+						this.exitCode = state.exitCode;
+						this.emit("exit", state.exitCode, null);
+					}
+					if (state.exitCode !== null && state.stdoutEnded && state.stderrEnded && state.activeProcesses === 0) {
+						this.#release();
+					} else this.#schedule(idle ? 25 : 0);
+				} catch (cause) {
+					const failure = cause instanceof Error ? cause : new Error(String(cause));
+					this.#failure = failure.message;
+					if (this.listenerCount("error") > 0) this.emit("error", failure);
+				}
+			}
+			#writeOutput(stream, bytes) {
+				if (bytes.length === 0 || stream.writableEnded) return;
+				if (stream.destroyed) {
+					this.#outputIncomplete = true;
+					return;
+				}
+				if (stream.write(bytes)) return;
+				this.#blockedOutput.add(stream);
+				const unblock = () => {
+					stream.off("drain", unblock);
+					stream.off("close", unblock);
+					this.#unblockOutput(stream);
+				};
+				stream.once("drain", unblock);
+				stream.once("close", unblock);
+				this.#scheduleBlockedWake();
+			}
+			#release() {
+				if (this.#closed) return;
+				if (this.#timer !== undefined) clearTimeout(this.#timer);
+				this.#clearBlockedWake();
+				this.stdin?.destroy();
+				if (!this.stdout.destroyed) this.stdout.end();
+				if (!this.stderr.destroyed) this.stderr.end();
+				this.#authority.call("process_close", [this.#handle]);
+				this.#closed = true;
+				this.#settle?.();
+				this.emit("close", this.exitCode, null);
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/ProviderProcess.js
+var DEFAULT_TERMINATION_GRACE_MS, DEFAULT_KILL_GRACE_MS, OUTPUT_CLOSE_GRACE_MS, MAX_LATE_OUTPUT_BYTES, outputCheckpoints, spawnOwnedProviderProcess, ProviderProcessSupervisor, ProcessOutputCapture, deferred, waitForSpawn, waitForProcessEvent;
+function init_ProviderProcess() {
+	return (init_ProviderProcess = __esmMin((() => {
+		init_WindowsOwnedProcess();
+		init_ProcessOwnershipObservation();
+		DEFAULT_TERMINATION_GRACE_MS = 250;
+		DEFAULT_KILL_GRACE_MS = 1e3;
+		OUTPUT_CLOSE_GRACE_MS = 1e3;
+		MAX_LATE_OUTPUT_BYTES = 64 * 1024;
+		outputCheckpoints = new WeakMap();
+		spawnOwnedProviderProcess = async (options) => {
+			options.signal?.throwIfAborted();
+			await prepareProcessOwnershipInspection(options.signal);
+			options.signal?.throwIfAborted();
+			const platform = options.platform ?? process.platform;
+			const sweepTokenOwnedProcesses = options.sweepTokenOwnedProcesses === true && platform !== "win32";
+			let captureBaseline;
+			if (sweepTokenOwnedProcesses) {
+				const capture = systemProcessOwnershipHost.captureBaseline;
+				if (capture === undefined) throw new Error("Process ownership baseline is unavailable on this host");
+				captureBaseline = await capture(options.signal);
+				options.signal?.throwIfAborted();
+			}
+			const hostEnvironment = options.hostEnvironment ?? process.env;
+			const environment = {
+				...hostEnvironment,
+				...options.env,
+				REA_PROCESS_RUN_ID: options.runId
+			};
+			if (platform === "win32" && process.platform === "win32") {
+				const child = new WindowsOwnedProcess(options.command, options.arguments, options.cwd, environment, options.windowsVerbatimArguments ?? false, {
+					protocolStdin: options.stdin === "pipe",
+					...options.memoryLimitBytes === undefined ? {} : { memoryLimitBytes: options.memoryLimitBytes }
+				});
+				return {
+					process: child,
+					ownership: {
+						runId: options.runId,
+						leaderPid: child.pid,
+						processGroupId: child.pid,
+						expectedParentPid: process.pid
+					},
+					cleanup: () => child.cleanup()
+				};
+			}
+			if (options.memoryLimitBytes !== undefined) throw new Error("Owned process memory limits require the Windows Job Object launcher; no limit can be enforced on this host.");
+			const child = spawn(options.command, [...options.arguments], {
+				shell: false,
+				windowsHide: true,
+				stdio: [
+					options.stdin ?? "ignore",
+					"pipe",
+					"pipe"
+				],
+				detached: platform !== "win32",
+				windowsVerbatimArguments: options.windowsVerbatimArguments ?? false,
+				env: environment,
+				...options.cwd === undefined ? {} : { cwd: options.cwd }
+			});
+			await waitForSpawn(child);
+			const pid = child.pid;
+			if (pid === undefined) throw new Error("Provider launcher has no process ID");
+			const ownership = {
+				runId: options.runId,
+				leaderPid: pid,
+				processGroupId: pid,
+				expectedParentPid: process.pid,
+				...sweepTokenOwnedProcesses ? {
+					sweepTokenOwnedProcesses: true,
+					captureBaseline
+				} : {},
+				...options.expectedCommand === null ? {} : { expectedCommand: options.expectedCommand ?? options.command }
+			};
+			return {
+				process: child,
+				ownership
+			};
+		};
+		ProviderProcessSupervisor = class {
+			launch;
+			#options;
+			#stdout = new ProcessOutputCapture();
+			#stderr = new ProcessOutputCapture();
+			#exit = deferred();
+			#outputClose = deferred();
+			#outputClosed = false;
+			#outputIncomplete = false;
+			#stdoutObservedBytes = 0;
+			#stderrObservedBytes = 0;
+			#diagnosticTruncated = false;
+			#onStdout = (chunk) => {
+				this.#capture("stdout", this.#stdout, chunk);
+			};
+			#onStderr = (chunk) => {
+				this.#capture("stderr", this.#stderr, chunk);
+			};
+			#onStdoutError = (cause) => {
+				this.#recordStreamError("stdout", cause);
+			};
+			#onStderrError = (cause) => {
+				this.#recordStreamError("stderr", cause);
+			};
+			#onExit = (code, signal) => {
+				this.#recordExit(code, signal);
+			};
+			#onClose = (code, signal) => {
+				this.#recordExit(code, signal);
+				this.#outputClosed = true;
+				this.#outputClose.resolve(undefined);
+			};
+			#onError = (cause) => {
+				this.#options.onDiagnostic?.({
+					type: "error",
+					message: cause.message,
+					cause
+				});
+			};
+			#exitObservation;
+			#stopPromise;
+			#disposed = false;
+			#maxDiagnosticBytes;
+			#outputEpoch = 0;
+			constructor(launch, options = {}) {
+				this.launch = launch;
+				this.#options = options;
+				this.#maxDiagnosticBytes = options.maxDiagnosticBytes;
+				if (options.captureStdout !== false) this.#attach(launch.process.stdout, "stdout");
+				this.#attach(launch.process.stderr, "stderr");
+				launch.process.once("exit", this.#onExit);
+				launch.process.once("close", this.#onClose);
+				launch.process.on("error", this.#onError);
+				if (launch.process.exitCode !== null || launch.process.signalCode !== null) this.#recordExit(launch.process.exitCode, launch.process.signalCode);
+			}
+			/**
+			* Recorded process exit without concatenating retained stream diagnostics.
+			* Undefined until exit or close is observed.
+			*/
+			observedExit() {
+				const exit = this.#exitObservation;
+				if (exit === undefined) return undefined;
+				return {
+					code: exit.code,
+					signal: exit.signal
+				};
+			}
+			/** Whether the process owner acknowledged output closure, separately from exit. */
+			observedOutputClose() {
+				return this.#outputClosed;
+			}
+			/** Latest retained output and exit observation, with explicit configured truncation. */
+			snapshot() {
+				const outputIncomplete = this.#outputIncomplete || this.launch.process.outputIncomplete === true;
+				return {
+					...this.#diagnosticTruncated || outputIncomplete ? { diagnosticTruncated: true } : {},
+					stdout: this.#stdout.snapshot(this.#stdoutObservedBytes),
+					stderr: this.#stderr.snapshot(this.#stderrObservedBytes),
+					exitCode: this.#exitObservation?.code,
+					signal: this.#exitObservation?.signal,
+					...this.launch.process.memoryLimitReached === true ? { memoryLimitReached: true } : {},
+					...outputIncomplete ? { outputIncomplete: true } : {}
+				};
+			}
+			/** Mark the current raw-byte position without copying or retaining output. */
+			checkpointOutput() {
+				const checkpoint = Object.freeze({});
+				outputCheckpoints.set(checkpoint, {
+					owner: this,
+					epoch: this.#outputEpoch,
+					stdout: this.#stdoutObservedBytes,
+					stderr: this.#stderrObservedBytes
+				});
+				return checkpoint;
+			}
+			/** Snapshot only bytes produced after a valid checkpoint on this supervisor. */
+			snapshotOutputSince(checkpoint) {
+				const position = typeof checkpoint === "object" && checkpoint !== null ? outputCheckpoints.get(checkpoint) : undefined;
+				if (position === undefined || position.owner !== this || position.epoch !== this.#outputEpoch) return {
+					snapshot: {
+						stdout: {
+							text: "",
+							bytes: 0,
+							observedBytes: 0
+						},
+						stderr: {
+							text: "",
+							bytes: 0,
+							observedBytes: 0
+						},
+						exitCode: this.#exitObservation?.code,
+						signal: this.#exitObservation?.signal,
+						outputIncomplete: true,
+						diagnosticTruncated: true
+					},
+					complete: false
+				};
+				const stdout = this.#stdout.snapshotRange(position.stdout, this.#stdoutObservedBytes);
+				const stderr = this.#stderr.snapshotRange(position.stderr, this.#stderrObservedBytes);
+				const incomplete = stdout.complete === false || stderr.complete === false || this.#outputIncomplete || this.launch.process.outputIncomplete === true;
+				return {
+					snapshot: {
+						...incomplete || this.#diagnosticTruncated ? { diagnosticTruncated: true } : {},
+						stdout: stdout.stream,
+						stderr: stderr.stream,
+						exitCode: this.#exitObservation?.code,
+						signal: this.#exitObservation?.signal,
+						...this.launch.process.memoryLimitReached === true ? { memoryLimitReached: true } : {},
+						...incomplete ? { outputIncomplete: true } : {}
+					},
+					complete: !incomplete && !this.#diagnosticTruncated
+				};
+			}
+			/** Begin a new observation on a retained process without retaining earlier output. */
+			resetOutput() {
+				this.#outputEpoch += 1;
+				this.#stdout.reset();
+				this.#stderr.reset();
+				this.#stdoutObservedBytes = 0;
+				this.#stderrObservedBytes = 0;
+				this.#diagnosticTruncated = false;
+			}
+			/** Wait for process exit up to a caller-owned bounded interval. */
+			async waitForExit(timeoutMs) {
+				return waitForProcessEvent(this.#exitObservation !== undefined, this.#exit.promise, timeoutMs);
+			}
+			/** Wait until output streams close; omit the timeout to await physical completion.
+			* WindowsOwnedProcess closes only after its whole Job Object settles.
+			*/
+			async waitForOutputClose(timeoutMs, signal) {
+				return waitForProcessEvent(this.#outputClosed, this.#outputClose.promise, timeoutMs, signal);
+			}
+			/** Bound additional retained bytes while still draining all later output. */
+			limitAdditionalOutputBytes(maxBytes) {
+				if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("Additional output limit must be a non-negative safe integer.");
+				const retained = this.#stdout.bytes + this.#stderr.bytes;
+				const requestedLimit = Math.min(Number.MAX_SAFE_INTEGER, retained + maxBytes);
+				this.#maxDiagnosticBytes = this.#maxDiagnosticBytes === undefined ? requestedLimit : Math.min(this.#maxDiagnosticBytes, requestedLimit);
+			}
+			/** Unreference inherited output pipes without closing streams shared with descendants. */
+			unrefOutputStreams() {
+				for (const stream of [this.launch.process.stdout, this.launch.process.stderr]) {
+					const unref = stream?.unref;
+					unref?.call(stream);
+				}
+			}
+			/** Share each stop attempt; incomplete cleanup retains ownership and permits retry. */
+			stop(options = {}) {
+				this.#stopPromise ??= this.#stop(options).then((result) => {
+					if (result.status === "incomplete") this.#stopPromise = undefined;
+					return result;
+				});
+				return this.#stopPromise;
+			}
+			/** Detach capture and process listeners after an adapter releases ownership. */
+			dispose() {
+				if (this.#disposed) return;
+				if (!this.#outputClosed) this.#outputIncomplete = true;
+				this.#disposed = true;
+				this.launch.process.stdout?.off("data", this.#onStdout);
+				this.launch.process.stdout?.off("error", this.#onStdoutError);
+				this.launch.process.stderr?.off("data", this.#onStderr);
+				this.launch.process.stderr?.off("error", this.#onStderrError);
+				this.launch.process.off("exit", this.#onExit);
+				this.launch.process.off("close", this.#onClose);
+				this.launch.process.off("error", this.#onError);
+			}
+			/** Release event-loop references so incomplete cleanup does not prevent host exit. */
+			unref() {
+				const process = this.launch.process;
+				process.unref?.();
+				process.stdin?.unref?.();
+				process.stdout?.unref?.();
+				process.stderr?.unref?.();
+			}
+			/** Restore event-loop references when retrying supervised process cleanup. */
+			ref() {
+				const process = this.launch.process;
+				process.ref?.();
+				process.stdin?.ref?.();
+				process.stdout?.ref?.();
+				process.stderr?.ref?.();
+			}
+			async #stop(options) {
+				if (this.launch.ownsProcessLifetime) {
+					this.ref();
+					this.limitAdditionalOutputBytes(MAX_LATE_OUTPUT_BYTES);
+				}
+				let completed = false;
+				try {
+					const result = await this.#stopWithin(options);
+					completed = result.status !== "incomplete";
+					if (completed && result.status !== "not-owned" && !this.#outputClosed) {
+						if (!await this.waitForOutputClose(OUTPUT_CLOSE_GRACE_MS)) {
+							this.#outputIncomplete = true;
+							this.unref();
+						}
+					}
+					if (!completed) this.unref();
+					return result;
+				} finally {
+					if (completed) this.dispose();
+				}
+			}
+			async #stopWithin(options) {
+				try {
+					if (!this.launch.ownsProcessLifetime) return { status: "not-owned" };
+					if (this.launch.cleanup !== undefined) {
+						const cleanup = await this.#ownedCleanup(options.cleanupResult);
+						if (!cleanup.cleaned) return {
+							status: "incomplete",
+							reason: cleanup.reason,
+							cleanupResult: cleanup
+						};
+						const graceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+						if (await this.waitForExit(graceMs)) return { status: "verified-cleanup" };
+						const retried = await this.launch.cleanup();
+						if (!retried.cleaned) return {
+							status: "incomplete",
+							reason: retried.reason,
+							cleanupResult: retried
+						};
+						if (await this.waitForExit(graceMs)) return { status: "verified-cleanup" };
+						return {
+							status: "incomplete",
+							reason: "verified process-group cleanup did not stop the launcher"
+						};
+					}
+					if (this.#exitObservation !== undefined) return { status: "already-exited" };
+					this.#signal("SIGTERM");
+					if (await this.waitForExit(options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS)) return { status: "terminated" };
+					this.#signal("SIGKILL");
+					if (await this.waitForExit(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS)) return { status: "killed" };
+					return {
+						status: "incomplete",
+						reason: "owned provider process did not exit after SIGKILL"
+					};
+				} catch (cause) {
+					return {
+						status: "incomplete",
+						reason: cause instanceof Error ? cause.message : "owned provider process cleanup failed"
+					};
+				}
+			}
+			#ownedCleanup(supplied) {
+				if (supplied !== undefined) return Promise.resolve(supplied);
+				const cleanup = this.launch.cleanup;
+				return cleanup === undefined ? Promise.resolve({
+					cleaned: false,
+					reason: "owned provider process has no cleanup capability"
+				}) : cleanup();
+			}
+			#signal(signal) {
+				if (this.#exitObservation !== undefined) return;
+				this.launch.process.kill(signal);
+			}
+			#attach(stream, name) {
+				if (name === "stdout") {
+					stream?.on("data", this.#onStdout);
+					stream?.on("error", this.#onStdoutError);
+				} else {
+					stream?.on("data", this.#onStderr);
+					stream?.on("error", this.#onStderrError);
+				}
+			}
+			#recordStreamError(stream, cause) {
+				this.#outputIncomplete = true;
+				this.#options.onDiagnostic?.({
+					type: "error",
+					message: `${stream} stream failed: ${cause.message}`,
+					cause
+				});
+			}
+			#capture(stream, capture, chunk) {
+				const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+				if (stream === "stdout") this.#stdoutObservedBytes += bytes.byteLength;
+				else this.#stderrObservedBytes += bytes.byteLength;
+				const remaining = this.#maxDiagnosticBytes === undefined ? bytes.byteLength : Math.max(0, this.#maxDiagnosticBytes - this.#stdout.bytes - this.#stderr.bytes);
+				const retained = Math.min(bytes.byteLength, remaining);
+				if (retained < bytes.byteLength) this.#diagnosticTruncated = true;
+				if (retained > 0) capture.append(bytes.subarray(0, retained));
+				this.#options.onDiagnostic?.({
+					type: "output",
+					stream,
+					bytes: bytes.byteLength,
+					totalBytes: stream === "stdout" ? this.#stdoutObservedBytes : this.#stderrObservedBytes,
+					...retained < bytes.byteLength ? { truncated: true } : {}
+				});
+			}
+			#recordExit(code, signal) {
+				if (this.#exitObservation !== undefined) return;
+				this.#exitObservation = {
+					code,
+					signal
+				};
+				this.#exit.resolve(this.#exitObservation);
+				this.#options.onDiagnostic?.({
+					type: "exit",
+					code,
+					signal,
+					snapshot: this.snapshot()
+				});
+			}
+		};
+		ProcessOutputCapture = class {
+			#chunks = [];
+			#bytes = 0;
+			get bytes() {
+				return this.#bytes;
+			}
+			reset() {
+				this.#chunks.length = 0;
+				this.#bytes = 0;
+			}
+			append(chunk) {
+				this.#bytes += chunk.byteLength;
+				this.#chunks.push(Buffer.from(chunk));
+			}
+			snapshot(observedBytes) {
+				return this.#snapshotBuffer(Buffer.concat(this.#chunks, this.#bytes), observedBytes);
+			}
+			snapshotRange(start, end) {
+				const availableEnd = Math.min(end, this.#bytes);
+				const availableStart = Math.min(start, availableEnd);
+				const chunks = [];
+				let offset = 0;
+				for (const chunk of this.#chunks) {
+					const chunkEnd = offset + chunk.byteLength;
+					const from = Math.max(availableStart, offset);
+					const to = Math.min(availableEnd, chunkEnd);
+					if (to > from) chunks.push(chunk.subarray(from - offset, to - offset));
+					offset = chunkEnd;
+					if (offset >= availableEnd) break;
+				}
+				const buffer = Buffer.concat(chunks, availableEnd - availableStart);
+				return {
+					stream: this.#snapshotBuffer(buffer, Math.max(0, end - start)),
+					complete: start <= this.#bytes && end <= this.#bytes
+				};
+			}
+			#snapshotBuffer(buffer, observedBytes) {
+				const text = buffer.toString("utf8");
+				let invalidUtf8 = false;
+				try {
+					new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+				} catch {
+					invalidUtf8 = true;
+				}
+				return {
+					text,
+					bytes: buffer.byteLength,
+					observedBytes,
+					...invalidUtf8 ? { invalidUtf8: true } : {}
+				};
+			}
+		};
+		deferred = () => {
+			let resolver;
+			const promise = new Promise((resolve) => {
+				resolver = resolve;
+			});
+			return {
+				promise,
+				resolve: (value) => {
+					resolver?.(value);
+				}
+			};
+		};
+		waitForSpawn = (child) => new Promise((resolve, reject) => {
+			const onSpawn = () => {
+				child.off("error", onError);
+				resolve();
+			};
+			const onError = (cause) => {
+				child.off("spawn", onSpawn);
+				reject(cause);
+			};
+			child.once("spawn", onSpawn);
+			child.once("error", onError);
+		});
+		waitForProcessEvent = async (observed, event, timeoutMs, signal) => {
+			if (observed) return true;
+			if (signal?.aborted === true) return false;
+			let timer;
+			let onAbort;
+			try {
+				return await Promise.race([event.then(() => true), new Promise((resolve) => {
+					if (timeoutMs !== undefined) timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+					if (signal !== undefined) {
+						onAbort = () => resolve(false);
+						signal.addEventListener("abort", onAbort, { once: true });
+					}
+				})]);
+			} finally {
+				if (timer !== undefined) clearTimeout(timer);
+				if (onAbort !== undefined) signal?.removeEventListener("abort", onAbort);
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/AbortablePromise.js
+var ABORTED, waitForAbortable;
+function init_AbortablePromise() {
+	return (init_AbortablePromise = __esmMin((() => {
+		ABORTED = Symbol("aborted");
+		waitForAbortable = async (pending, signal) => {
+			if (signal === undefined) return pending;
+			let onAbort;
+			const cancelled = new Promise((resolve) => {
+				if (signal.aborted) {
+					resolve(ABORTED);
+					return;
+				}
+				onAbort = () => resolve(ABORTED);
+				signal.addEventListener("abort", onAbort, { once: true });
+			});
+			try {
+				return await Promise.race([cancelled, pending]);
+			} finally {
+				if (onAbort !== undefined) signal.removeEventListener("abort", onAbort);
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/OwnedCommand.js
+/** Both preparation stages preserve physical failures, opaque cancellation and exact owners. */
+function throwCommandPreparationFailure(cause, signal, interruption) {
+	const preparationFailure = cause instanceof DarwinProcessOwnershipInspectionError && !(signal?.aborted === true && cause === signal.reason) ? cause : undefined;
+	if (preparationFailure !== undefined && preparationFailure.cancellation === undefined) throw preparationFailure;
+	if (interruption !== undefined) throw new OwnedCommandFailure(interruption, interruption === "cancelled" ? "Command cancelled during ownership preparation." : "Command deadline elapsed during ownership preparation.", null, null, {
+		cause,
+		...interruption === "cancelled" ? { cancellation: { reason: signal?.reason } } : {},
+		...preparationFailure === undefined ? {} : { preparationFailure }
+	});
+	throw cause;
+}
+var OwnedCommandFailure, ownedCommandResources, prepareOwnedCommand, runOwnedCommand, collectOwnedCommand, consumeStdout;
+function init_OwnedCommand() {
+	return (init_OwnedCommand = __esmMin((() => {
+		init_ProcessOwnershipObservation();
+		init_DarwinProcessRunTokenReader();
+		init_ProviderProcess();
+		init_ProcessOwnership();
+		init_AbortablePromise();
+		init_ProviderDeadline();
+		OwnedCommandFailure = class extends Error {
+			reason;
+			snapshot;
+			cleanupFailure;
+			resources;
+			cleanupOwner;
+			#cancellation;
+			/** Opaque caller reason observed by the owner, distinct from physical causes. */
+			get cancellation() {
+				return this.#cancellation;
+			}
+			processError;
+			cleanupResult;
+			collectionFailure;
+			preparationFailure;
+			constructor(reason, message, snapshot = null, cleanupFailure = null, options, resources = [], cleanupOwner) {
+				super(message, options);
+				this.reason = reason;
+				this.snapshot = snapshot;
+				this.cleanupFailure = cleanupFailure;
+				this.resources = resources;
+				this.cleanupOwner = cleanupOwner;
+				this.#cancellation = options?.cancellation === undefined ? undefined : { reason: options.cancellation.reason };
+				this.processError = options?.processError;
+				this.cleanupResult = options?.cleanupResult;
+				this.collectionFailure = options?.collectionFailure ?? false;
+				this.preparationFailure = options?.preparationFailure;
+			}
+		};
+		ownedCommandResources = (ownership, directory) => [
+			ownership.runId,
+			...directory === undefined ? [] : [directory],
+			`pid:${ownership.leaderPid}`,
+			`process-group:${ownership.processGroupId}`
+		];
+		prepareOwnedCommand = async (signal) => {
+			if (systemProcessOwnershipHost.platform !== "darwin") return;
+			try {
+				signal?.throwIfAborted();
+				await prepareProcessOwnershipInspection(signal);
+			} catch (cause) {
+				throwCommandPreparationFailure(cause, signal, signal?.aborted === true ? "cancelled" : undefined);
+			}
+		};
+		runOwnedCommand = async (spawn, limits, options = {}) => {
+			const callerSignal = options.signal ?? spawn.signal;
+			if (callerSignal?.aborted) throw new OwnedCommandFailure("cancelled", "Command cancelled before launch.", null, null, { cancellation: { reason: callerSignal.reason } });
+			const deadline = new ProviderStartupDeadline(limits.timeoutMs, callerSignal);
+			try {
+				return await collectOwnedCommand(spawn, limits, options.launcher ?? spawnOwnedProviderProcess, deadline, callerSignal, options.retainCleanup);
+			} finally {
+				deadline.dispose();
+			}
+		};
+		collectOwnedCommand = async (spawn, limits, launcher, deadline, callerSignal, retainCleanup) => {
+			const signal = deadline.signal;
+			let launched;
+			try {
+				launched = await launcher({
+					...spawn,
+					signal
+				});
+			} catch (cause) {
+				throwCommandPreparationFailure(cause, signal, deadline.interruption);
+			}
+			let exceeded = false;
+			let processFailure;
+			let processError;
+			const supervisor = new ProviderProcessSupervisor({
+				...launched,
+				ownsProcessLifetime: true,
+				cleanup: launched.cleanup ?? (() => cleanupOwnedProcessGroup(launched.ownership))
+			}, {
+				captureStdout: limits.stdout === undefined,
+				maxDiagnosticBytes: limits.diagnosticBytes,
+				onDiagnostic: (event) => {
+					if (event.type === "output" && event.truncated === true) exceeded = true;
+					if (event.type === "error") {
+						processFailure ??= event.message;
+						processError ??= event.cause;
+					}
+				}
+			});
+			const abandoned = new AbortController();
+			const consumed = consumeStdout(launched.process.stdout, limits.stdout, AbortSignal.any([signal, abandoned.signal]));
+			void consumed.then((failed) => {
+				processFailure ??= failed;
+			});
+			let failure;
+			try {
+				while (!await supervisor.waitForOutputClose(10)) {
+					const interruption = deadline.interruption;
+					if (interruption !== undefined) throw new OwnedCommandFailure(interruption, interruption === "cancelled" ? "Command cancelled." : "Command deadline elapsed.", null, null, interruption === "cancelled" ? { cancellation: { reason: signal.reason } } : undefined);
+					if (exceeded) throw new OwnedCommandFailure("output-limit", "Command diagnostic output exceeded its complete-output budget.");
+					if (processFailure !== undefined) throw new OwnedCommandFailure("process", processFailure, null, null, {
+						processError,
+						collectionFailure: true
+					});
+					await waitForAbortableDelay(25, signal);
+				}
+				const sinkFailure = await waitForAbortable(consumed, signal);
+				if (sinkFailure !== ABORTED) processFailure ??= sinkFailure;
+				const snapshot = supervisor.snapshot();
+				const interruption = deadline.interruption;
+				if (interruption !== undefined) throw new OwnedCommandFailure(interruption, interruption === "cancelled" ? "Command cancelled." : "Command deadline elapsed.", snapshot, null, interruption === "cancelled" ? { cancellation: { reason: signal.reason } } : undefined);
+				if (exceeded) throw new OwnedCommandFailure("output-limit", "Command diagnostic output exceeded its complete-output budget.", snapshot);
+				const acceptedNonzeroExit = limits.acceptNonZeroExit === true && snapshot.exitCode !== null && snapshot.exitCode !== undefined && snapshot.exitCode !== 0 && snapshot.signal === null;
+				if (processFailure !== undefined || (snapshot.exitCode !== 0 || snapshot.signal !== null) && !acceptedNonzeroExit) throw new OwnedCommandFailure("process", processFailure ?? "Command failed; inspect its exit status and diagnostics.", snapshot, null, {
+					processError,
+					collectionFailure: processFailure !== undefined
+				});
+				limits.observeCompleted?.(snapshot);
+			} catch (cause) {
+				failure = cause instanceof OwnedCommandFailure ? cause : new OwnedCommandFailure("process", "Command collection failed.", null, null, { cause });
+			}
+			abandoned.abort();
+			const stopped = await supervisor.stop();
+			const snapshot = supervisor.snapshot();
+			const cancellation = failure?.cancellation ?? (callerSignal?.aborted ? { reason: callerSignal.reason } : undefined);
+			if (stopped.status === "incomplete" && retainCleanup !== undefined) retainCleanup(supervisor, stopped);
+			else if (stopped.status === "incomplete") throw new OwnedCommandFailure(failure?.reason ?? "process", failure?.message ?? "Command cleanup failed.", snapshot, stopped.reason, {
+				cancellation,
+				...failure === undefined ? {} : {
+					cause: failure,
+					processError: failure.processError
+				},
+				...stopped.cleanupResult === undefined ? {} : { cleanupResult: stopped.cleanupResult },
+				...failure?.collectionFailure === true ? { collectionFailure: true } : {}
+			}, ownedCommandResources(launched.ownership, spawn.cwd), supervisor);
+			if (failure !== undefined) throw new OwnedCommandFailure(failure.reason, failure.message, snapshot, failure.cleanupFailure, {
+				cause: failure,
+				cancellation,
+				processError: failure.processError,
+				...failure.cleanupResult === undefined ? {} : { cleanupResult: failure.cleanupResult },
+				...failure.collectionFailure ? { collectionFailure: true } : {}
+			}, failure.resources);
+			if (callerSignal?.aborted) throw new OwnedCommandFailure("cancelled", "Command cancelled.", snapshot, null, { cancellation: { reason: callerSignal.reason } });
+			return snapshot;
+		};
+		consumeStdout = (stdout, sink, signal) => {
+			if (sink === undefined) return Promise.resolve(undefined);
+			if (stdout === null) {
+				sink.destroy();
+				return Promise.resolve("stdout stream is unavailable");
+			}
+			return pipeline(stdout, sink, { signal }).then(() => undefined, (cause) => `stdout stream failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+		};
+	})))();
+}
+
+//#endregion
+export { systemWindowsNativeAuthority as _, runOwnedCommand as a, init_snapshotEnvironment as b, waitForAbortable as c, spawnOwnedProviderProcess as d, ProviderStartupDeadline as f, requireWindowsNativeAuthority as g, init_WindowsNativeLoader as h, prepareOwnedCommand as i, ProviderProcessSupervisor as l, waitForAbortableDelay as m, init_OwnedCommand as n, ABORTED as o, init_ProviderDeadline as p, ownedCommandResources as r, init_AbortablePromise as s, OwnedCommandFailure as t, init_ProviderProcess as u, windowsFileIdentitySchema as v, snapshotEnvironment as x, windowsHandleSchema as y };