@orkestrel/process 0.0.8 → 0.0.10

package/dist/src/server/index.cjs

@@ -9,6 +9,42 @@ let _src_core = require("../core/index.cjs");
 let node_readline = require("node:readline");
 let _orkestrel_emitter = require("@orkestrel/emitter");
 let node_string_decoder = require("node:string_decoder");
+//#region src/server/cloners.ts
+/**
+* Takes one owned frozen snapshot of a caller's command.
+*
+* @remarks
+* Every public entry point snapshots before it validates, so the object validated is the object
+* spawned. Each property is read exactly once, because reading one runs the caller's own getter: a
+* command whose `file` changes between reads would otherwise validate one executable and spawn
+* another. The argument vector and the environment record are copied and frozen, so a caller
+* mutating either after the call cannot reach the spawn. An absent optional stays absent rather than
+* becoming an explicit `undefined`.
+*
+* @param command - The caller's command, whose properties may be getters
+* @returns A frozen command carrying the values read at this instant
+*
+* @example
+* ```ts
+* snapshotCommand({ file: 'git', arguments: ['status'] }) // { file: 'git', arguments: ['status'] }
+* ```
+*/
+function snapshotCommand(command) {
+	const file = command.file;
+	const argumentsList = Object.freeze([...command.arguments]);
+	const sourceEnvironment = command.environment;
+	const environment = sourceEnvironment === void 0 ? void 0 : Object.freeze({ ...sourceEnvironment });
+	const input = command.input;
+	const isolated = command.isolated;
+	return Object.freeze({
+		file,
+		arguments: argumentsList,
+		...environment === void 0 ? {} : { environment },
+		...input === void 0 ? {} : { input },
+		...isolated === void 0 ? {} : { isolated }
+	});
+}
+//#endregion
 //#region src/server/helpers.ts
 /**
 * Trims a buffer to at most `limit` trailing bytes without splitting a UTF-8 sequence.
@@ -42,9 +78,12 @@ function trimTail(bytes, limit) {
 * Trims a buffer to at most `limit` leading bytes without splitting a UTF-8 sequence.
 *
 * @remarks
-* Keeps the head — the captured start of a one-shot run's output. When the cut point lands inside
-* a multibyte sequence, the end retreats to the sequence's start so the retained bytes always end
-* on a code-point boundary and decode without a replacement character.
+* Keeps the head — the captured start of a one-shot run's output. The end retreats only when a
+* sequence genuinely spans the cut: the byte at `limit` carries the continuation bit pattern, and a
+* lead byte within the preceding three bytes declares a length that reaches it. The retained bytes
+* then end on a code-point boundary and decode without a replacement character. A byte at `limit`
+* that carries the continuation pattern without such a lead byte is invalid UTF-8 rather than a
+* split sequence, so the full `limit` survives instead of a valid byte being dropped for it.
 *
 * @param bytes - The accumulated bytes
 * @param limit - The maximum retained byte count
@@ -58,47 +97,50 @@ function trimTail(bytes, limit) {
 function trimHead(bytes, limit) {
 	const buffer = node_buffer.Buffer.isBuffer(bytes) ? bytes : node_buffer.Buffer.from(bytes);
 	if (buffer.byteLength <= limit) return buffer;
-	let end = limit;
-	while (end > 0) {
-		const byte = buffer[end];
-		if (byte === void 0 || (byte & 192) !== 128) break;
-		end -= 1;
+	const excluded = buffer[limit];
+	if (excluded === void 0 || (excluded & 192) !== 128) return node_buffer.Buffer.from(buffer.subarray(0, limit));
+	const floor = Math.max(0, limit - 3);
+	let start = limit - 1;
+	while (start >= floor) {
+		const lead = buffer[start];
+		if (lead !== void 0 && (lead & 192) !== 128) {
+			let span = 1;
+			if ((lead & 224) === 192) span = 2;
+			else if ((lead & 240) === 224) span = 3;
+			else if ((lead & 248) === 240) span = 4;
+			if (start + span > limit) return node_buffer.Buffer.from(buffer.subarray(0, start));
+			break;
+		}
+		start -= 1;
 	}
-	return node_buffer.Buffer.from(buffer.subarray(0, end));
+	return node_buffer.Buffer.from(buffer.subarray(0, limit));
 }
 /**
-* Takes one owned frozen snapshot of a caller's command.
+* Bounds one delivered stream chunk to the bytes a capture still has room for.
 *
 * @remarks
-* Every public entry point snapshots before it validates, so the object validated is the object
-* spawned. Each property is read exactly once, because reading one runs the caller's own getter: a
-* command whose `file` changes between reads would otherwise validate one executable and spawn
-* another. The argument vector and the environment record are copied and frozen, so a caller
-* mutating either after the call cannot reach the spawn. An absent optional stays absent rather than
-* becoming an explicit `undefined`.
-*
-* @param command - The caller's command, whose properties may be getters
-* @returns A frozen command carrying the values read at this instant
+* A chunk that is not a buffer contributes nothing and reports `undefined` rather than throwing,
+* because a stream `data` listener receives an `unknown` payload. The cut is byte-exact and might
+* land inside a multibyte sequence, because {@link buildExecuteResult} performs the single
+* code-point-boundary trim over the whole capture rather than over each chunk. Give the capture one
+* byte more room than its limit, so that final trim can read the first excluded byte and retreat off
+* a split sequence. A chunk that fits its room is returned as the delivered buffer itself rather
+* than a copy, because a capture appending it copies again and never writes through it; a chunk that
+* overruns its room returns a copy of the bytes that fit. Treat the return as read-only either way.
+*
+* @param chunk - The delivered chunk, ignored when it is not a buffer
+* @param room - The bytes the capture still accepts
+* @returns The bytes to retain, or `undefined` when the chunk contributes none
 *
 * @example
 * ```ts
-* snapshotCommand({ file: 'git', arguments: ['status'] }) // { file: 'git', arguments: ['status'] }
+* captureChunk(Buffer.from('hello'), 3) // <Buffer 68 65 6c>
 * ```
 */
-function snapshotCommand(command) {
-	const file = command.file;
-	const argumentsList = Object.freeze([...command.arguments]);
-	const sourceEnvironment = command.environment;
-	const environment = sourceEnvironment === void 0 ? void 0 : Object.freeze({ ...sourceEnvironment });
-	const input = command.input;
-	const isolated = command.isolated;
-	return Object.freeze({
-		file,
-		arguments: argumentsList,
-		...environment === void 0 ? {} : { environment },
-		...input === void 0 ? {} : { input },
-		...isolated === void 0 ? {} : { isolated }
-	});
+function captureChunk(chunk, room) {
+	if (!node_buffer.Buffer.isBuffer(chunk) || room <= 0) return void 0;
+	if (chunk.byteLength <= room) return chunk;
+	return node_buffer.Buffer.from(chunk.subarray(0, room));
 }
 /**
 * Renders one command into its diagnostic command line.
@@ -217,7 +259,7 @@ function mergeEnvironment(isolated, base, override) {
 * command. An unreadable or malformed path reports `false` rather than throwing.
 *
 * @param target - The absolute or relative path to inspect
-* @returns True when the path resolves to a regular file; false otherwise
+* @returns True if the path resolves to a regular file; false otherwise
 *
 * @example
 * ```ts
@@ -490,7 +532,7 @@ function validateWorkspace(workspace) {
 * initiated against a pid the host may have reused.
 *
 * @param child - The child boundary
-* @returns True when the process has exited; false while it is live
+* @returns True if the process has exited; false otherwise
 *
 * @example
 * ```ts
@@ -546,7 +588,7 @@ function killProcess(child, signal) {
 *
 * @param pid - The root process id of the tree to end
 * @param timeout - The milliseconds the utility is given before it is killed
-* @returns True when the utility reported success; false when it failed, was unavailable, or was cut off
+* @returns True if the utility reported success; false otherwise (it failed, was unavailable, or was cut off)
 *
 * @example
 * ```ts
@@ -597,7 +639,7 @@ function waitForExit(child, timeout) {
 *
 * @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
+* @returns True if the host close arrived inside the deadline; false otherwise
 *
 * @example
 * ```ts
@@ -632,7 +674,7 @@ function waitForClose(child, timeout) {
 * @param child - The child boundary
 * @param grace - The cooperative POSIX window in milliseconds between `SIGTERM` and `SIGKILL`
 * @param confirm - The milliseconds the native exit is awaited after the final kill
-* @returns True when the native exit was observed; false when `confirm` elapsed without it
+* @returns True if the native exit was observed; false otherwise (`confirm` elapsed without it)
 *
 * @example
 * ```ts
@@ -692,191 +734,507 @@ function buildExecuteResult(input) {
 		truncated: input.truncated
 	});
 }
-//#endregion
-//#region src/server/Supervisor.ts
 /**
-* Supervises one child process and reports each lifecycle moment to the face composing it.
+* Runs one command to completion, buffering its output, and settles with the outcome.
 *
 * @remarks
-* This is the engine every supervised-child face shares. It owns the eager spawn, the byte-bounded
-* stderr tail and its decoded chunks, the standard-input channel and its bounded confirmation, the
-* termination sequence, and the progression from the child's native exit through the bounded `drain`
-* window to one terminal moment. It owns no output framing and no observation surface: a face
-* attaches its own consumer to `stdout`, frames bytes however its contract promises, and owns the
-* emitter and event map its consumers subscribe to.
+* The executable is resolved through {@link buildSpawn}, so no run uses a shell. On a POSIX host the
+* child is detached, which is what lets its whole process group be terminated. Standard output and
+* error are each byte-bounded by `limit` (default {@link PROCESS_OUTPUT}) and `truncated` reports
+* whether either stream exceeded it. Each capture keeps one byte beyond `limit`, so the single
+* code-point-boundary trim in {@link buildExecuteResult} reads the first excluded byte and never
+* delivers a split multibyte sequence. A positive `timeout` and an aborting `signal` both terminate the
+* child through the same bounded stop, and only the earliest is recorded: a timeout reports
+* `expired` and an abort reports `aborted`, never both. After termination the outcome is awaited for
+* a bounded window, so a descendant holding the child's stdio cannot keep the run pending. That bound
+* covers a terminated run alone: a run with no `timeout` and no `signal` settles on stdio completion
+* 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`. 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.
 *
-* 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, and `ending`
-* settles at that same moment. `settled`, `exit`, and `evidence` 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 hands the face its `close` and `terminal` moments before
-* it destroys stdout and stderr, so a face's own pull surfaces are final while its read ends still
-* exist.
+* @param command - The executable, arguments, and optional environment and input
+* @param options - Working directory, timeout, grace, signal, capture limit, and failure delivery
+* @returns The settled run outcome
+* @throws A {@link ProcessError} coded `invalid` for a malformed option, command string, or batch-bound argument, or one carrying the {@link ExecuteResult} when the run failed and `strict` is not `false`
 *
-* The face is a set of callbacks rather than an emitter, because each face publishes a different
-* event map over the same moments. `chunk` and `fault` carry the live stderr text and the child or
-* channel faults, `relieve` reports that a termination began so the face can release whatever
-* backpressure it holds, `close` ends the face's read pipeline at the terminal moment, `terminal`
-* carries the frozen {@link ProcessExit}, and `teardown` releases the face's own surface after the
-* termination completes. `relieve` is optional because a face that never pauses the child's output
-* holds no backpressure to release, and a face with nothing to do there would otherwise declare an
-* empty method to say so.
+* @example
+* ```ts
+* const result = await execute({ file: 'git', arguments: ['status'] }, { workspace: process.cwd() })
+* ```
 */
-var Supervisor = class {
-	#chunk;
-	#fault;
-	#relieve;
-	#close;
-	#terminal;
-	#teardown;
-	#child;
-	#grace;
-	#drain;
-	#evidence;
-	#delivery;
-	#decoder = new node_string_decoder.StringDecoder("utf8");
-	#exit = Promise.withResolvers();
-	#ending = Promise.withResolvers();
-	#signal;
-	#abort;
-	#writes = /* @__PURE__ */ new Map();
-	#tail = node_buffer.Buffer.alloc(0);
-	#stopping = false;
-	#settled = false;
-	#input = 0;
-	#failure;
-	#waiting;
-	#closure;
-	#termination;
-	#destruction;
-	/**
-	* Spawn one child process and begin standard-error capture.
-	*
-	* @remarks
-	* The face's callbacks are captured before anything is read or spawned, so the first moment the
-	* child can produce already has somewhere to go. `options` supplies the command, workspace,
-	* termination, capture, and standard-input settings; a face's own settings, such as an output
-	* retention bound, are read and validated by that face before it constructs this engine, so an
-	* invalid one refuses construction while nothing has been spawned.
-	*
-	* @param options - Command, workspace, termination, capture, and stdin settings
-	* @param face - The composing face's callbacks for each lifecycle moment
-	* @throws A {@link ProcessError} coded `invalid` when an option or command string is malformed
-	*/
-	constructor(options, face) {
-		this.#chunk = face.chunk;
-		this.#fault = face.fault;
-		this.#relieve = face.relieve;
-		this.#close = face.close;
-		this.#terminal = face.terminal;
-		this.#teardown = face.teardown;
-		const source = options.command;
-		const workspace = options.workspace;
-		const grace = options.grace;
-		const drain = options.drain;
-		const evidence = options.evidence;
-		const delivery = options.delivery;
-		const writable = options.writable;
-		const signal = options.signal;
-		const command = snapshotCommand(source);
-		const input = command.input;
-		validateCommand(command);
-		validateWorkspace(workspace);
-		validateTimer(grace, "option 'grace'");
-		validateTimer(drain, "option 'drain'");
-		validateTimer(delivery, "option 'delivery'");
-		validateBytes(evidence, "option 'evidence'", 0);
-		this.#grace = grace ?? _src_core.PROCESS_GRACE;
-		this.#drain = drain ?? _src_core.PROCESS_DRAIN;
-		this.#evidence = evidence ?? _src_core.PROCESS_EVIDENCE;
-		this.#delivery = delivery ?? 0;
-		this.#signal = signal;
-		const childEnvironment = mergeEnvironment(command.isolated === true, command.environment);
-		const plan = buildSpawn(command, {
-			workspace,
-			environment: childEnvironment
-		});
-		this.#child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
-			cwd: workspace,
-			detached: process.platform !== "win32",
-			env: childEnvironment,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true,
-			windowsVerbatimArguments: plan.verbatim
-		});
-		this.#child.once("error", this.#fault);
-		this.#child.once("exit", this.#expire.bind(this));
-		this.#child.once("close", this.#complete.bind(this));
-		this.#child.stdin.on("error", this.#failInputStream.bind(this));
-		this.#child.stderr.on("data", this.#retain.bind(this));
-		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 });
-			if (signal.aborted) this.stop();
-		}
-	}
-	/** The child's standard-output stream, for the composing face to attach its own consumer to. */
-	get stdout() {
-		return this.#child.stdout;
-	}
-	/** The host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
-	get pid() {
-		return this.#child.pid;
-	}
-	/** The exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
-	get code() {
-		return this.#child.exitCode;
-	}
-	/** The terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
-	get signal() {
-		return this.#child.signalCode;
-	}
-	/** The decoded byte-bounded stderr tail, frozen at the terminal moment. */
-	get evidence() {
-		return this.#tail.toString("utf8");
-	}
-	/** 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 child's own ending, awaited without the terminal moment's drain window.
-	*
-	* @remarks
-	* Never rejects, and resolves no value: `code` and `signal` carry the terminal facts as soon as
-	* the host records them. It settles at the native exit, and at the terminal moment for a child
-	* whose spawn produced no native exit at all, so it can never outlive the supervision.
-	*/
-	get ending() {
-		return this.#ending.promise;
-	}
-	/** The terminal child state, observed once after stream close or the drain cutoff. */
-	get exit() {
-		return this.#exit.promise;
-	}
-	/**
-	* Writes raw bytes to the open standard-input channel.
-	*
-	* @remarks
-	* Never rejects, and adds no framing: a face composes whatever terminator its contract promises
-	* before it calls this. `true` means the host accepted the bytes without reporting a fault; it
+async function execute(command, options) {
+	const snapshot = snapshotCommand(command);
+	const optionEnvironment = options?.environment;
+	const optionWorkspace = options?.workspace;
+	const optionInput = options?.input;
+	const optionTimeout = options?.timeout;
+	const optionGrace = options?.grace;
+	const optionSignal = options?.signal;
+	const optionStrict = options?.strict;
+	const optionLimit = options?.limit;
+	validateCommand(snapshot);
+	validateEnvironment(optionEnvironment);
+	validateWorkspace(optionWorkspace);
+	validateTimer(optionTimeout, "option 'timeout'");
+	validateTimer(optionGrace, "option 'grace'");
+	validateBytes(optionLimit, "option 'limit'", 0);
+	const limit = optionLimit ?? _src_core.PROCESS_OUTPUT;
+	const grace = optionGrace ?? _src_core.PROCESS_GRACE;
+	const timeout = optionTimeout ?? 0;
+	const strict = optionStrict ?? true;
+	const text = optionInput ?? snapshot.input;
+	const line = formatCommand(snapshot);
+	const workspace = optionWorkspace ?? process.cwd();
+	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment, optionEnvironment);
+	const plan = buildSpawn(snapshot, {
+		workspace,
+		environment
+	});
+	const settled = Promise.withResolvers();
+	const terminate = new AbortController();
+	const cleanup = new AbortController();
+	const finish = new AbortController();
+	const inputFailure = new AbortController();
+	const outChunks = [];
+	const errChunks = [];
+	let spawned = false;
+	let expired = false;
+	let aborted = false;
+	let outRetained = 0;
+	let errRetained = 0;
+	let cause;
+	let timeoutTimer;
+	let confirmTimer;
+	const child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
+		cwd: workspace,
+		detached: process.platform !== "win32",
+		env: environment,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true,
+		windowsVerbatimArguments: plan.verbatim
+	});
+	finish.signal.addEventListener("abort", () => {
+		clearTimeout(timeoutTimer);
+		clearTimeout(confirmTimer);
+		cleanup.abort();
+		settled.resolve(buildExecuteResult({
+			command: line,
+			stdout: node_buffer.Buffer.concat(outChunks),
+			stderr: node_buffer.Buffer.concat(errChunks),
+			code: child.exitCode,
+			signal: child.signalCode,
+			expired,
+			aborted,
+			truncated: outRetained > limit || errRetained > limit,
+			limit,
+			...cause === void 0 ? {} : { cause }
+		}));
+	}, { once: true });
+	terminate.signal.addEventListener("abort", () => {
+		if (finish.signal.aborted) return;
+		clearTimeout(timeoutTimer);
+		cleanup.abort();
+		stopChild(child, grace, _src_core.PROCESS_CONFIRMATION).then(() => {
+			if (finish.signal.aborted) return;
+			confirmTimer = setTimeout(() => finish.abort(), _src_core.PROCESS_CONFIRMATION);
+		});
+	}, { once: true });
+	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 captured = captureChunk(chunk, limit + 1 - outRetained);
+		if (captured === void 0) return;
+		outRetained += captured.byteLength;
+		outChunks.push(captured);
+	});
+	child.stderr.on("data", (chunk) => {
+		const captured = captureChunk(chunk, limit + 1 - errRetained);
+		if (captured === void 0) return;
+		errRetained += captured.byteLength;
+		errChunks.push(captured);
+	});
+	child.once("spawn", () => {
+		spawned = true;
+	});
+	child.once("error", (error) => {
+		if (spawned) return;
+		cause = error;
+		finish.abort();
+	});
+	child.once("close", () => finish.abort());
+	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;
+		terminate.abort();
+	}, timeout);
+	if (optionSignal !== void 0) {
+		optionSignal.addEventListener("abort", () => {
+			aborted = true;
+			terminate.abort();
+		}, {
+			once: true,
+			signal: cleanup.signal
+		});
+		if (optionSignal.aborted) {
+			aborted = true;
+			terminate.abort();
+		}
+	}
+	const result = await settled.promise;
+	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;
+}
+/**
+* Runs one command to completion synchronously, buffering its output, and returns the outcome.
+*
+* @remarks
+* The synchronous counterpart of {@link execute}, spawned through the same resolver and never through a
+* shell. The host offers no cooperative termination window and no in-flight cancellation, so this
+* contract carries neither. A positive `timeout` ends only the root process and can leave
+* descendants running; use {@link execute} or {@link Process} when timeout must terminate the tree. A
+* timeout and an output overflow both end the root with `SIGKILL`: an overflow reports `truncated`
+* and `failed` together and trims the partial output to `limit`, where {@link execute} keeps reading and
+* reports `truncated` without failing. The environment and input follow the same merge as
+* {@link execute}. Unless `strict` is `false`, a failed run throws a {@link createExecuteError}
+* carrying the {@link ExecuteResult}.
+*
+* @param command - The executable, arguments, and optional environment and input
+* @param options - Working directory, timeout, capture limit, and failure delivery
+* @returns The run outcome
+* @throws A {@link ProcessError} coded `invalid` for a malformed option, command string, or batch-bound argument, or one carrying the {@link ExecuteResult} when the run failed and `strict` is not `false`
+*
+* @example
+* ```ts
+* const result = executeSync({ file: 'git', arguments: ['--version'] }, { strict: false })
+* ```
+*/
+function executeSync(command, options) {
+	const snapshot = snapshotCommand(command);
+	const optionEnvironment = options?.environment;
+	const optionWorkspace = options?.workspace;
+	const optionInput = options?.input;
+	const optionTimeout = options?.timeout;
+	const optionStrict = options?.strict;
+	const optionLimit = options?.limit;
+	validateCommand(snapshot);
+	validateEnvironment(optionEnvironment);
+	validateWorkspace(optionWorkspace);
+	validateTimer(optionTimeout, "option 'timeout'");
+	validateBytes(optionLimit, "option 'limit'", 0);
+	const limit = optionLimit ?? _src_core.PROCESS_OUTPUT;
+	const timeout = optionTimeout ?? 0;
+	const strict = optionStrict ?? true;
+	const text = optionInput ?? snapshot.input;
+	const line = formatCommand(snapshot);
+	const workspace = optionWorkspace ?? process.cwd();
+	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment, optionEnvironment);
+	const plan = buildSpawn(snapshot, {
+		workspace,
+		environment
+	});
+	const outcome = (0, node_child_process.spawnSync)(plan.file, [...plan.arguments], {
+		cwd: workspace,
+		env: environment,
+		encoding: "buffer",
+		maxBuffer: limit,
+		killSignal: "SIGKILL",
+		windowsHide: true,
+		windowsVerbatimArguments: plan.verbatim,
+		...text !== void 0 ? { input: node_buffer.Buffer.from(text) } : {},
+		...timeout > 0 ? { timeout } : {}
+	});
+	const error = outcome.error;
+	const fault = error !== void 0 && "code" in error && (0, _orkestrel_contract.isString)(error.code) ? error.code : "";
+	const result = buildExecuteResult({
+		command: line,
+		stdout: node_buffer.Buffer.isBuffer(outcome.stdout) ? outcome.stdout : node_buffer.Buffer.alloc(0),
+		stderr: node_buffer.Buffer.isBuffer(outcome.stderr) ? outcome.stderr : node_buffer.Buffer.alloc(0),
+		code: outcome.status,
+		signal: outcome.signal,
+		expired: fault === "ETIMEDOUT",
+		aborted: false,
+		truncated: fault === "ENOBUFS",
+		limit,
+		...error === void 0 ? {} : { cause: error }
+	});
+	if (result.failed && strict) throw (0, _src_core.createExecuteError)(result, error);
+	return result;
+}
+/**
+* Spawns one command as a detached process and returns without waiting for it.
+*
+* @remarks
+* The child owns no stdio and is unreferenced, so it outlives this process and nothing here observes
+* its outcome. The error listener is attached before the child is unreferenced, so a post-spawn host
+* fault is swallowed rather than crashing the caller; an invalid command is refused before anything
+* is spawned.
+*
+* @param command - The executable, arguments, and optional environment
+* @param options - The working directory the detached child starts in
+* @returns Nothing
+* @throws A {@link ProcessError} coded `invalid` when the working directory or a command string is malformed
+*
+* @example
+* ```ts
+* detach({ file: 'node', arguments: ['daemon.js'] }, { workspace: process.cwd() })
+* ```
+*/
+function detach(command, options) {
+	const snapshot = snapshotCommand(command);
+	const optionWorkspace = options?.workspace;
+	validateCommand(snapshot);
+	validateWorkspace(optionWorkspace);
+	const workspace = optionWorkspace ?? process.cwd();
+	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment);
+	const plan = buildSpawn(snapshot, {
+		workspace,
+		environment
+	});
+	const child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
+		cwd: workspace,
+		detached: true,
+		env: environment,
+		stdio: "ignore",
+		windowsHide: true,
+		windowsVerbatimArguments: plan.verbatim
+	});
+	child.once("error", () => void 0);
+	child.unref();
+}
+//#endregion
+//#region src/server/processes/Supervisor.ts
+/**
+* Supervises one child process and reports each lifecycle moment to the face composing it.
+*
+* @remarks
+* This is the engine every supervised-child face shares. It owns the eager spawn, the byte-bounded
+* stderr tail and its decoded chunks, the standard-input channel and its bounded confirmation, the
+* termination sequence, and the progression from the child's native exit through the bounded `drain`
+* window to one terminal moment. It owns no output framing and no observation surface: a face
+* attaches its own consumer to `stdout`, frames bytes however its contract promises, and owns the
+* emitter and event map its consumers subscribe to.
+*
+* 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, and `ending`
+* settles at that same moment. `settled`, `exit`, and `evidence` 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 hands the face its `close` and `terminal` moments before
+* it destroys stdout and stderr, so a face's own pull surfaces are final while its read ends still
+* exist.
+*
+* The face is a set of callbacks rather than an emitter, because each face publishes a different
+* event map over the same moments. `chunk` and `fault` carry the live stderr text and the child or
+* channel faults, `relieve` reports that a termination began so the face can release whatever
+* backpressure it holds, `close` ends the face's read pipeline at the terminal moment, `terminal`
+* carries the frozen {@link ProcessExit}, and `teardown` releases the face's own surface after the
+* termination completes. `relieve` is optional because a face that never pauses the child's output
+* holds no backpressure to release, and a face with nothing to do there would otherwise declare an
+* empty method to say so.
+*
+* @example
+* ```ts
+* import { Supervisor } from '@orkestrel/process/server'
+*
+* const engine = new Supervisor(
+* 	{ command: { file: 'node', arguments: ['--version'] }, workspace: process.cwd() },
+* 	{
+* 		chunk: () => undefined,
+* 		fault: () => undefined,
+* 		close: () => undefined,
+* 		terminal: () => undefined,
+* 		teardown: () => undefined,
+* 	},
+* )
+* const exit = await engine.exit
+* exit.code // 0
+* await engine.destroy()
+* ```
+*/
+var Supervisor = class {
+	#chunk;
+	#fault;
+	#relieve;
+	#close;
+	#terminal;
+	#teardown;
+	#child;
+	#grace;
+	#drain;
+	#evidence;
+	#delivery;
+	#decoder = new node_string_decoder.StringDecoder("utf8");
+	#exit = Promise.withResolvers();
+	#ending = Promise.withResolvers();
+	#signal;
+	#abort;
+	#writes = /* @__PURE__ */ new Map();
+	#tail = node_buffer.Buffer.alloc(0);
+	#stopping = false;
+	#settled = false;
+	#input = 0;
+	#failure;
+	#waiting;
+	#closure;
+	#termination;
+	#destruction;
+	/**
+	* Spawns one child process and begins standard-error capture.
+	*
+	* @remarks
+	* The face's callbacks are captured before anything is read or spawned, so the first moment the
+	* child can produce already has somewhere to go. `options` supplies the command, workspace,
+	* termination, capture, and standard-input settings; a face's own settings, such as an output
+	* retention bound, are read and validated by that face before it constructs this engine, so an
+	* invalid one refuses construction while nothing has been spawned.
+	*
+	* @param options - Command, workspace, termination, capture, and stdin settings
+	* @param face - The composing face's callbacks for each lifecycle moment
+	* @throws A {@link ProcessError} coded `invalid` when an option or command string is malformed
+	*/
+	constructor(options, face) {
+		this.#chunk = face.chunk;
+		this.#fault = face.fault;
+		this.#relieve = face.relieve;
+		this.#close = face.close;
+		this.#terminal = face.terminal;
+		this.#teardown = face.teardown;
+		const source = options.command;
+		const workspace = options.workspace;
+		const grace = options.grace;
+		const drain = options.drain;
+		const evidence = options.evidence;
+		const delivery = options.delivery;
+		const writable = options.writable;
+		const signal = options.signal;
+		const command = snapshotCommand(source);
+		const input = command.input;
+		validateCommand(command);
+		validateWorkspace(workspace);
+		validateTimer(grace, "option 'grace'");
+		validateTimer(drain, "option 'drain'");
+		validateTimer(delivery, "option 'delivery'");
+		validateBytes(evidence, "option 'evidence'", 0);
+		this.#grace = grace ?? _src_core.PROCESS_GRACE;
+		this.#drain = drain ?? _src_core.PROCESS_DRAIN;
+		this.#evidence = evidence ?? _src_core.PROCESS_EVIDENCE;
+		this.#delivery = delivery ?? 0;
+		this.#signal = signal;
+		const childEnvironment = mergeEnvironment(command.isolated === true, command.environment);
+		const plan = buildSpawn(command, {
+			workspace,
+			environment: childEnvironment
+		});
+		this.#child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
+			cwd: workspace,
+			detached: process.platform !== "win32",
+			env: childEnvironment,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true,
+			windowsVerbatimArguments: plan.verbatim
+		});
+		this.#child.once("error", this.#fault);
+		this.#child.once("exit", this.#expire.bind(this));
+		this.#child.once("close", this.#complete.bind(this));
+		this.#child.stdin.on("error", this.#failInputStream.bind(this));
+		this.#child.stderr.on("data", this.#retain.bind(this));
+		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 });
+			if (signal.aborted) this.stop();
+		}
+	}
+	/** Holds the child's standard-output stream, for the composing face to attach its own consumer to. */
+	get stdout() {
+		return this.#child.stdout;
+	}
+	/** Holds the host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
+	get pid() {
+		return this.#child.pid;
+	}
+	/** Holds the exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
+	get code() {
+		return this.#child.exitCode;
+	}
+	/** Holds the terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
+	get signal() {
+		return this.#child.signalCode;
+	}
+	/** Holds the decoded byte-bounded stderr tail, frozen at the terminal moment. */
+	get evidence() {
+		return this.#tail.toString("utf8");
+	}
+	/** Reports whether the terminal moment arrived and `exit` settled. */
+	get settled() {
+		return this.#settled;
+	}
+	/** Reports whether termination began, including after the terminal moment. */
+	get stopping() {
+		return this.#stopping;
+	}
+	/**
+	* Settles at the child's own ending, awaited without the terminal moment's drain window.
+	*
+	* @remarks
+	* Never rejects, and resolves no value: `code` and `signal` carry the terminal facts as soon as
+	* the host records them. It settles at the native exit, and at the terminal moment for a child
+	* whose spawn produced no native exit at all, so it can never outlive the supervision.
+	*/
+	get ending() {
+		return this.#ending.promise;
+	}
+	/** Settles with the terminal child state, observed once after stream close or the drain cutoff. */
+	get exit() {
+		return this.#exit.promise;
+	}
+	/**
+	* Writes raw bytes to the open standard-input channel.
+	*
+	* @remarks
+	* Never rejects, and adds no framing: a face composes whatever terminator its contract promises
+	* before it calls this. `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. After `stop` or `destroy` begins, a later
@@ -884,7 +1242,30 @@ var Supervisor = class {
 	* discard.
 	*
 	* @param bytes - The payload to write, already framed by the caller
-	* @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`
+	* @returns True if the host accepted the bytes without reporting a fault; false otherwise (the channel was closed, destroyed, ended, failed, or the write remained unconfirmed through `delivery`)
+	*
+	* @example
+	* ```ts
+	* import { Supervisor } from '@orkestrel/process/server'
+	*
+	* const engine = new Supervisor(
+	* 	{
+	* 		command: { file: 'node', arguments: ['-e', 'process.stdin.pipe(process.stdout)'] },
+	* 		workspace: process.cwd(),
+	* 		writable: true,
+	* 	},
+	* 	{
+	* 		chunk: () => undefined,
+	* 		fault: () => undefined,
+	* 		close: () => undefined,
+	* 		terminal: () => undefined,
+	* 		teardown: () => undefined,
+	* 	},
+	* )
+	* const accepted = await engine.deliver(new TextEncoder().encode('ping\n'))
+	* accepted // true
+	* await engine.destroy()
+	* ```
 	*/
 	deliver(bytes) {
 		const stdin = this.#child.stdin;
@@ -935,7 +1316,7 @@ var Supervisor = class {
 	* 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
+	* @returns True if the child's native exit was observed; false otherwise (the confirmation deadline elapsed without it)
 	*/
 	stop() {
 		if (this.#termination !== void 0) return this.#termination;
@@ -1063,7 +1444,7 @@ var Supervisor = class {
 	}
 };
 //#endregion
-//#region src/server/Process.ts
+//#region src/server/processes/Process.ts
 /**
 * Supervises one child while keeping every observation channel aligned at termination.
 *
@@ -1110,7 +1491,7 @@ var Process = class {
 	#truncated = false;
 	#ended = false;
 	/**
-	* Spawn one child process and begin stream capture.
+	* Spawns one child process and begins stream capture.
 	*
 	* @param options - Command, workspace, termination, capture, stdin, and observation settings
 	* @throws A {@link ProcessError} coded `invalid` when an option or command string is malformed
@@ -1165,48 +1546,48 @@ var Process = class {
 		this.#reader.on("line", this.#push.bind(this));
 		this.#reader.once("close", this.#finish.bind(this));
 	}
-	/** The host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
+	/** Holds the host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
 	get pid() {
 		return this.#engine.pid;
 	}
-	/** The exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
+	/** Holds the exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
 	get code() {
 		return this.#engine.code;
 	}
-	/** The terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
+	/** Holds the terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
 	get signal() {
 		return this.#engine.signal;
 	}
-	/** The typed lifecycle observation surface. */
+	/** Holds the typed lifecycle observation surface. */
 	get emitter() {
 		return this.#emitter;
 	}
-	/** The captured stdout lines, in arrival order, ending after queued lines at the terminal moment. */
+	/** Yields 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, frozen at the terminal moment. */
+	/** Holds the decoded byte-bounded stderr tail, frozen at the terminal moment. */
 	get evidence() {
 		return this.#engine.evidence;
 	}
-	/** True when the `lines` stream omitted output after a retention bound was reached. */
+	/** Reports whether the `lines` stream omitted output after a retention bound was reached. */
 	get truncated() {
 		return this.#truncated;
 	}
-	/** True after the terminal moment arrived and `exit` settled. */
+	/** Reports whether the terminal moment arrived and `exit` settled. */
 	get settled() {
 		return this.#engine.settled;
 	}
-	/** True after termination began, including after the terminal moment. */
+	/** Reports whether termination began, including after the terminal moment. */
 	get stopping() {
 		return this.#engine.stopping;
 	}
-	/** The terminal child state, observed once after stream close or the drain cutoff. */
+	/** Settles with the terminal child state, observed once after stream close or the drain cutoff. */
 	get exit() {
 		return this.#engine.exit;
 	}
 	/**
-	* Write one line to the open standard-input channel.
+	* Writes one line to the open standard-input channel.
 	*
 	* @remarks
 	* Never rejects. `true` means the host accepted the bytes without reporting a fault; it does not
@@ -1220,7 +1601,7 @@ var Process = class {
 	* for bytes the package is about to discard.
 	*
 	* @param text - The line text without its trailing newline
-	* @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`
+	* @returns True if the host accepted the bytes without reporting a fault; false otherwise (the channel was closed, destroyed, ended, failed, or the write remained unconfirmed through `delivery`)
 	*/
 	send(text) {
 		return this.#engine.deliver(node_buffer.Buffer.from(`${text}\n`, "utf8"));
@@ -1234,7 +1615,7 @@ var Process = class {
 	* 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
+	* @returns True if the child's native exit was observed; false otherwise (the confirmation deadline elapsed without it)
 	*/
 	stop() {
 		return this.#engine.stop();
@@ -1352,9 +1733,9 @@ var Process = class {
 	}
 };
 //#endregion
-//#region src/server/ProcessManager.ts
+//#region src/server/processes/ProcessManager.ts
 /**
-* A keyed registry of live supervised child processes.
+* Represents a keyed registry of live supervised child processes.
 *
 * @remarks
 * A child launched under an id joins the registry and emits `launch`; when it settles it removes
@@ -1390,7 +1771,7 @@ var ProcessManager = class {
 	#destroying = false;
 	#ending;
 	/**
-	* Construct a process registry.
+	* Constructs a process registry.
 	*
 	* @param options - Initial fleet-level observation hooks and listener-error handling
 	*/
@@ -1402,16 +1783,16 @@ var ProcessManager = class {
 			...error === void 0 ? {} : { error }
 		});
 	}
-	/** The typed fleet-level observation surface. */
+	/** Holds the typed fleet-level observation surface. */
 	get emitter() {
 		return this.#emitter;
 	}
-	/** The number of live children. */
+	/** Counts the live children. */
 	get count() {
 		return this.#children.size;
 	}
 	/**
-	* The live child under `id`, or `undefined` when none is.
+	* Returns the live child under `id`, or `undefined` when none is.
 	*
 	* @param id - The registry key
 	* @returns The child, or `undefined`
@@ -1420,7 +1801,7 @@ var ProcessManager = class {
 		return this.#children.get(id);
 	}
 	/**
-	* A snapshot of every live child.
+	* Returns a snapshot of every live child.
 	*
 	* @returns The live children in launch order
 	*/
@@ -1428,7 +1809,7 @@ var ProcessManager = class {
 		return [...this.#children.values()];
 	}
 	/**
-	* Spawn and register one child under `id`.
+	* Spawns and registers one child under `id`.
 	*
 	* @remarks
 	* {@link Process} reads every option before it spawns, so a caller's own option getter runs while
@@ -1466,7 +1847,7 @@ var ProcessManager = class {
 		return this.#stopMany(target);
 	}
 	/**
-	* Stop every child, then destroy the registry emitter last.
+	* Stops every child, then destroys the registry emitter last.
 	*
 	* @remarks
 	* Always resolves, and refuses a later `launch` with a {@link createProtocolError}. Each child is
@@ -1508,599 +1889,263 @@ 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();
-	}
-};
-//#endregion
-//#region src/server/Session.ts
-/**
-* Supervises one child and publishes its standard output as raw bytes.
-*
-* @remarks
-* This is the transport face of the supervision engine `Process` also composes. It frames nothing,
-* retains nothing, and decodes nothing on the output side: every chunk the host delivers becomes one
-* `stdout` event carrying that chunk's bytes, in arrival order, so a consumer speaking a
-* length-prefixed or delimiter-framed protocol reads exactly what the child wrote and frames it
-* itself. Standard error is decoded and forwarded as `stderr`, with the same byte-bounded `evidence`
-* tail a `Process` retains, because a diagnostic stream is read rather than parsed.
-*
-* Each emitted chunk is this session's own copy, and a plain `Uint8Array` rather than the host buffer
-* the read produced, so a consumer keeps it, mutates it, concatenates it, and reads its whole backing
-* buffer without reaching memory the host still manages and without depending on a host type.
-*
-* The standard-input channel is open from the spawn, and `end` closes it without terminating
-* anything. That is the member a cooperative protocol reaches for: the child observes end of input
-* and exits on its own, which `ending` reports. `stop` and `destroy` remain the terminations, and
-* `exit` remains the terminal moment — the native exit plus at most `drain` while a descendant holds
-* the inherited read ends.
-*
-* @example
-* ```ts
-* import { Session } from '@orkestrel/process/server'
-*
-* const session = new Session({
-* 	command: { file: 'node', arguments: ['-e', 'process.stdin.pipe(process.stdout)'] },
-* 	workspace: process.cwd(),
-* })
-* ```
-*/
-var Session = class {
-	#emitter;
-	#engine;
-	#output;
-	/**
-	* Spawn one child process and begin byte capture.
-	*
-	* @param options - Command, workspace, termination, evidence, stdin, and observation settings
-	* @throws A {@link ProcessError} coded `invalid` when an option or command string is malformed
-	*/
-	constructor(options) {
-		const command = options.command;
-		const workspace = options.workspace;
-		const grace = options.grace;
-		const drain = options.drain;
-		const evidence = options.evidence;
-		const delivery = options.delivery;
-		const signal = options.signal;
-		const on = options.on;
-		const error = options.error;
-		this.#emitter = new _orkestrel_emitter.Emitter({
-			...on === void 0 ? {} : { on },
-			...error === void 0 ? {} : { error }
-		});
-		this.#output = this.#publish.bind(this);
-		this.#engine = new Supervisor({
-			command,
-			workspace,
-			writable: true,
-			...grace === void 0 ? {} : { grace },
-			...drain === void 0 ? {} : { drain },
-			...evidence === void 0 ? {} : { evidence },
-			...delivery === void 0 ? {} : { delivery },
-			...signal === void 0 ? {} : { signal }
-		}, {
-			chunk: this.#reportStderr.bind(this),
-			fault: this.#reportFault.bind(this),
-			close: this.#closeOutput.bind(this),
-			terminal: this.#reportExit.bind(this),
-			teardown: this.#emitter.destroy.bind(this.#emitter)
-		});
-		this.#engine.stdout.on("data", this.#output);
-	}
-	/** The host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
-	get pid() {
-		return this.#engine.pid;
-	}
-	/** The exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
-	get code() {
-		return this.#engine.code;
-	}
-	/** The terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
-	get signal() {
-		return this.#engine.signal;
-	}
-	/** The typed lifecycle observation surface. */
-	get emitter() {
-		return this.#emitter;
-	}
-	/** The decoded byte-bounded stderr tail, frozen at the terminal moment. */
-	get evidence() {
-		return this.#engine.evidence;
-	}
-	/** True after the terminal moment arrived and `exit` settled. */
-	get settled() {
-		return this.#engine.settled;
-	}
-	/** True after termination began, including after the terminal moment. `end` never turns it true. */
-	get stopping() {
-		return this.#engine.stopping;
-	}
-	/** The child's own ending, awaited without the terminal moment's drain window. */
-	get ending() {
-		return this.#engine.ending;
-	}
-	/** The terminal child state, observed once after stream close or the drain cutoff. */
-	get exit() {
-		return this.#engine.exit;
-	}
-	/**
-	* Writes raw bytes to the open standard-input channel.
-	*
-	* @remarks
-	* Never rejects, and appends no terminator: the child receives exactly these bytes. `true` means
-	* the host accepted them without reporting a fault; it does not prove that the child read them.
-	* The channel can queue the payload, so treat the array as owned by the channel until the
-	* returned promise settles.
-	*
-	* @param bytes - The payload to write, already framed by the caller
-	* @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`
-	*/
-	write(bytes) {
-		return this.#engine.deliver(bytes);
-	}
-	/**
-	* Closes the standard-input channel and leaves the child running.
-	*
-	* @remarks
-	* Never rejects and terminates nothing: `stopping` stays false and the terminal moment does not
-	* arrive. Every call shares one barrier, which resolves after the host flushes the writes it had
-	* already accepted. A later `write` resolves `false`.
-	*
-	* @returns The stable barrier shared by every call
-	*/
-	end() {
-		return this.#engine.end();
-	}
-	/**
-	* Terminates the child process tree and reaches the terminal observation moment.
-	*
-	* @remarks
-	* Never rejects, and every call shares one termination bounded by `grace` and `drain`.
-	*
-	* @returns True when the child's native exit was observed; false when the confirmation deadline elapsed without it
-	*/
-	stop() {
-		return this.#engine.stop();
-	}
-	/**
-	* Stops the child and destroys the observation emitter after the terminal state freezes.
-	*
-	* @remarks
-	* Always resolves, including when termination was never confirmed. Every call shares one barrier.
-	*
-	* @returns The stable barrier shared by every call
-	*/
-	destroy() {
-		return this.#engine.destroy();
-	}
-	#publish(chunk) {
-		if (!node_buffer.Buffer.isBuffer(chunk) || this.#engine.settled) return;
-		this.#emitter.emit("stdout", new Uint8Array(chunk));
-	}
-	#reportStderr(chunk) {
-		this.#emitter.emit("stderr", chunk);
-	}
-	#reportFault(cause) {
-		this.#emitter.emit("error", cause);
-	}
-	#reportExit(exit) {
-		this.#emitter.emit("exit", exit);
-	}
-	#closeOutput() {
-		this.#engine.stdout.off("data", this.#output);
+		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();
 	}
 };
 //#endregion
-//#region src/server/factories.ts
+//#region src/server/processes/Session.ts
 /**
-* Creates one supervised child process.
-*
-* @param options - Command, workspace, termination, evidence, stdin, and observation settings
-* @returns The launched {@link ProcessInterface}
+* Supervises one child and publishes its standard output as raw bytes.
 *
-* @example
-* ```ts
-* import { createProcess } from '@orkestrel/process/server'
+* @remarks
+* This is the transport face of the supervision engine `Process` also composes. It frames nothing,
+* retains nothing, and decodes nothing on the output side: every chunk the host delivers becomes one
+* `stdout` event carrying that chunk's bytes, in arrival order, so a consumer speaking a
+* length-prefixed or delimiter-framed protocol reads exactly what the child wrote and frames it
+* itself. Standard error is decoded and forwarded as `stderr`, with the same byte-bounded `evidence`
+* tail a `Process` retains, because a diagnostic stream is read rather than parsed.
 *
-* const child = createProcess({
-* 	command: { file: 'node', arguments: ['--version'] },
-* 	workspace: process.cwd(),
-* 	grace: 5000,
-* })
-* ```
-*/
-function createProcess(options) {
-	return new Process(options);
-}
-/**
-* Creates one raw byte session over a supervised child process.
+* Each emitted chunk is this session's own copy, and a plain `Uint8Array` rather than the host buffer
+* the read produced, so a consumer keeps it, mutates it, concatenates it, and reads its whole backing
+* buffer without reaching memory the host still manages and without depending on a host type.
 *
-* @param options - Command, workspace, termination, evidence, stdin, and observation settings
-* @returns The launched {@link SessionInterface}
+* The standard-input channel is open from the spawn, and `end` closes it without terminating
+* anything. That is the member a cooperative protocol reaches for: the child observes end of input
+* and exits on its own, which `ending` reports. `stop` and `destroy` remain the terminations, and
+* `exit` remains the terminal moment — the native exit plus at most `drain` while a descendant holds
+* the inherited read ends.
 *
 * @example
 * ```ts
-* import { createSession } from '@orkestrel/process/server'
+* import { Session } from '@orkestrel/process/server'
 *
-* const session = createSession({
-* 	command: { file: 'node', arguments: ['server.js', '--stdio'] },
+* const session = new Session({
+* 	command: { file: 'node', arguments: ['-e', 'process.stdin.pipe(process.stdout)'] },
 * 	workspace: process.cwd(),
-* 	grace: 5000,
 * })
 * ```
 */
-function createSession(options) {
-	return new Session(options);
-}
-/**
-* Creates one keyed registry of supervised child processes.
-*
-* @param options - Initial fleet-level observation hooks and listener-error handling
-* @returns The {@link ProcessManagerInterface} registry
-*
-* @example
-* ```ts
-* import { createProcessManager } from '@orkestrel/process/server'
-*
-* const manager = createProcessManager()
-* ```
-*/
-function createProcessManager(options) {
-	return new ProcessManager(options);
-}
-//#endregion
-//#region src/server/Retention.ts
-/**
-* Accumulates byte totals while retaining a bounded stream head.
-*
-* @example
-* ```ts
-* const retention = new Retention()
-* retention.retain(Buffer.from('hello'), 3)?.toString('utf8') // 'hel'
-* retention.retained // 3
-* ```
-*/
-var Retention = class {
-	#delivered = 0;
-	#retained = 0;
-	/** The bytes delivered by the stream. */
-	get delivered() {
-		return this.#delivered;
-	}
-	/** The bytes retained from the stream head. */
-	get retained() {
-		return this.#retained;
-	}
+var Session = class {
+	#emitter;
+	#engine;
+	#output;
 	/**
-	* Retains a delivered chunk within a byte limit.
+	* Spawns one child process and begins byte capture.
 	*
-	* @param chunk - The delivered chunk, ignored when it is not a buffer
-	* @param limit - The maximum retained byte count
-	* @returns The retained slice, or `undefined` when the chunk contributes no retained bytes
+	* @param options - Command, workspace, termination, evidence, stdin, and observation settings
+	* @throws A {@link ProcessError} coded `invalid` when an option or command string is malformed
 	*/
-	retain(chunk, limit) {
-		if (!node_buffer.Buffer.isBuffer(chunk)) return void 0;
-		this.#delivered += chunk.byteLength;
-		const room = limit - this.#retained;
-		if (room <= 0) return void 0;
-		const slice = chunk.byteLength <= room ? chunk : node_buffer.Buffer.from(chunk.subarray(0, room));
-		this.#retained += slice.byteLength;
-		return slice;
-	}
-};
-//#endregion
-//#region src/server/execution/execute.ts
-/**
-* Runs one command to completion, buffering its output, and settles with the outcome.
-*
-* @remarks
-* The executable is resolved through {@link buildSpawn}, so no run uses a shell. On a POSIX host the
-* child is detached, which is what lets its whole process group be terminated. Standard output and
-* error are each byte-bounded by `limit` (default {@link PROCESS_OUTPUT}) and `truncated` reports
-* whether either stream exceeded it. A positive `timeout` and an aborting `signal` both terminate the
-* child through the same bounded stop, and only the earliest is recorded: a timeout reports
-* `expired` and an abort reports `aborted`, never both. After termination the outcome is awaited for
-* a bounded window, so a descendant holding the child's stdio cannot keep the run pending. That bound
-* covers a terminated run alone: a run with no `timeout` and no `signal` settles on stdio completion
-* 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`. 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
-* @returns The settled run outcome
-* @throws A {@link ProcessError} coded `invalid` for a malformed option, command string, or batch-bound argument, or one carrying the {@link ExecuteResult} when the run failed and `strict` is not `false`
-*
-* @example
-* ```ts
-* const result = await execute({ file: 'git', arguments: ['status'] }, { workspace: process.cwd() })
-* ```
-*/
-async function execute(command, options) {
-	const snapshot = snapshotCommand(command);
-	const optionEnvironment = options?.environment;
-	const optionWorkspace = options?.workspace;
-	const optionInput = options?.input;
-	const optionTimeout = options?.timeout;
-	const optionGrace = options?.grace;
-	const optionSignal = options?.signal;
-	const optionStrict = options?.strict;
-	const optionLimit = options?.limit;
-	validateCommand(snapshot);
-	validateEnvironment(optionEnvironment);
-	validateWorkspace(optionWorkspace);
-	validateTimer(optionTimeout, "option 'timeout'");
-	validateTimer(optionGrace, "option 'grace'");
-	validateBytes(optionLimit, "option 'limit'", 0);
-	const limit = optionLimit ?? _src_core.PROCESS_OUTPUT;
-	const grace = optionGrace ?? _src_core.PROCESS_GRACE;
-	const timeout = optionTimeout ?? 0;
-	const strict = optionStrict ?? true;
-	const text = optionInput ?? snapshot.input;
-	const line = formatCommand(snapshot);
-	const workspace = optionWorkspace ?? process.cwd();
-	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment, optionEnvironment);
-	const plan = buildSpawn(snapshot, {
-		workspace,
-		environment
-	});
-	const settled = Promise.withResolvers();
-	const terminate = new AbortController();
-	const cleanup = new AbortController();
-	const finish = new AbortController();
-	const inputFailure = new AbortController();
-	const outChunks = [];
-	const errChunks = [];
-	const outRetention = new Retention();
-	const errRetention = new Retention();
-	let spawned = false;
-	let expired = false;
-	let aborted = false;
-	let cause;
-	let timeoutTimer;
-	let confirmTimer;
-	const child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
-		cwd: workspace,
-		detached: process.platform !== "win32",
-		env: environment,
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		],
-		windowsHide: true,
-		windowsVerbatimArguments: plan.verbatim
-	});
-	finish.signal.addEventListener("abort", () => {
-		clearTimeout(timeoutTimer);
-		clearTimeout(confirmTimer);
-		cleanup.abort();
-		settled.resolve(buildExecuteResult({
-			command: line,
-			stdout: node_buffer.Buffer.concat(outChunks),
-			stderr: node_buffer.Buffer.concat(errChunks),
-			code: child.exitCode,
-			signal: child.signalCode,
-			expired,
-			aborted,
-			truncated: outRetention.delivered > limit || errRetention.delivered > limit,
-			limit,
-			...cause === void 0 ? {} : { cause }
-		}));
-	}, { once: true });
-	terminate.signal.addEventListener("abort", () => {
-		if (finish.signal.aborted) return;
-		clearTimeout(timeoutTimer);
-		cleanup.abort();
-		stopChild(child, grace, _src_core.PROCESS_CONFIRMATION).then(() => {
-			if (finish.signal.aborted) return;
-			confirmTimer = setTimeout(() => finish.abort(), _src_core.PROCESS_CONFIRMATION);
+	constructor(options) {
+		const command = options.command;
+		const workspace = options.workspace;
+		const grace = options.grace;
+		const drain = options.drain;
+		const evidence = options.evidence;
+		const delivery = options.delivery;
+		const signal = options.signal;
+		const on = options.on;
+		const error = options.error;
+		this.#emitter = new _orkestrel_emitter.Emitter({
+			...on === void 0 ? {} : { on },
+			...error === void 0 ? {} : { error }
 		});
-	}, { once: true });
-	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);
-	});
-	child.stderr.on("data", (chunk) => {
-		const retained = errRetention.retain(chunk, limit);
-		if (retained !== void 0) errChunks.push(retained);
-	});
-	child.once("spawn", () => {
-		spawned = true;
-	});
-	child.once("error", (error) => {
-		if (spawned) return;
-		cause = error;
-		finish.abort();
-	});
-	child.once("close", () => finish.abort());
-	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;
-		terminate.abort();
-	}, timeout);
-	if (optionSignal !== void 0) {
-		optionSignal.addEventListener("abort", () => {
-			aborted = true;
-			terminate.abort();
+		this.#output = this.#publish.bind(this);
+		this.#engine = new Supervisor({
+			command,
+			workspace,
+			writable: true,
+			...grace === void 0 ? {} : { grace },
+			...drain === void 0 ? {} : { drain },
+			...evidence === void 0 ? {} : { evidence },
+			...delivery === void 0 ? {} : { delivery },
+			...signal === void 0 ? {} : { signal }
 		}, {
-			once: true,
-			signal: cleanup.signal
+			chunk: this.#reportStderr.bind(this),
+			fault: this.#reportFault.bind(this),
+			close: this.#closeOutput.bind(this),
+			terminal: this.#reportExit.bind(this),
+			teardown: this.#emitter.destroy.bind(this.#emitter)
 		});
-		if (optionSignal.aborted) {
-			aborted = true;
-			terminate.abort();
-		}
+		this.#engine.stdout.on("data", this.#output);
 	}
-	const result = await settled.promise;
-	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);
+	/** Holds the host process id, fixed when construction returns, or `undefined` when the spawn produced none. */
+	get pid() {
+		return this.#engine.pid;
 	}
-	return result;
-}
+	/** Holds the exit code the host recorded, or `null` while the child has not exited and when a signal ended it. */
+	get code() {
+		return this.#engine.code;
+	}
+	/** Holds the terminating signal name the host recorded, or `null` while the child has not exited and when it exited on its own. */
+	get signal() {
+		return this.#engine.signal;
+	}
+	/** Holds the typed lifecycle observation surface. */
+	get emitter() {
+		return this.#emitter;
+	}
+	/** Holds the decoded byte-bounded stderr tail, frozen at the terminal moment. */
+	get evidence() {
+		return this.#engine.evidence;
+	}
+	/** Reports whether the terminal moment arrived and `exit` settled. */
+	get settled() {
+		return this.#engine.settled;
+	}
+	/** Reports whether termination began, including after the terminal moment. `end` never turns it true. */
+	get stopping() {
+		return this.#engine.stopping;
+	}
+	/** Settles at the child's own ending, awaited without the terminal moment's drain window. */
+	get ending() {
+		return this.#engine.ending;
+	}
+	/** Settles with the terminal child state, observed once after stream close or the drain cutoff. */
+	get exit() {
+		return this.#engine.exit;
+	}
+	/**
+	* Writes raw bytes to the open standard-input channel.
+	*
+	* @remarks
+	* Never rejects, and appends no terminator: the child receives exactly these bytes. `true` means
+	* the host accepted them without reporting a fault; it does not prove that the child read them.
+	* The channel can queue the payload, so treat the array as owned by the channel until the
+	* returned promise settles.
+	*
+	* @param bytes - The payload to write, already framed by the caller
+	* @returns True if the host accepted the bytes without reporting a fault; false otherwise (the channel was closed, destroyed, ended, failed, or the write remained unconfirmed through `delivery`)
+	*/
+	write(bytes) {
+		return this.#engine.deliver(bytes);
+	}
+	/**
+	* Closes the standard-input channel and leaves the child running.
+	*
+	* @remarks
+	* Never rejects and terminates nothing: `stopping` stays false and the terminal moment does not
+	* arrive. Every call shares one barrier, which resolves after the host flushes the writes it had
+	* already accepted. A later `write` resolves `false`.
+	*
+	* @returns The stable barrier shared by every call
+	*/
+	end() {
+		return this.#engine.end();
+	}
+	/**
+	* Terminates the child process tree and reaches the terminal observation moment.
+	*
+	* @remarks
+	* Never rejects, and every call shares one termination bounded by `grace` and `drain`.
+	*
+	* @returns True if the child's native exit was observed; false otherwise (the confirmation deadline elapsed without it)
+	*/
+	stop() {
+		return this.#engine.stop();
+	}
+	/**
+	* Stops the child and destroys the observation emitter after the terminal state freezes.
+	*
+	* @remarks
+	* Always resolves, including when termination was never confirmed. Every call shares one barrier.
+	*
+	* @returns The stable barrier shared by every call
+	*/
+	destroy() {
+		return this.#engine.destroy();
+	}
+	#publish(chunk) {
+		if (!node_buffer.Buffer.isBuffer(chunk) || this.#engine.settled) return;
+		this.#emitter.emit("stdout", new Uint8Array(chunk));
+	}
+	#reportStderr(chunk) {
+		this.#emitter.emit("stderr", chunk);
+	}
+	#reportFault(cause) {
+		this.#emitter.emit("error", cause);
+	}
+	#reportExit(exit) {
+		this.#emitter.emit("exit", exit);
+	}
+	#closeOutput() {
+		this.#engine.stdout.off("data", this.#output);
+	}
+};
 //#endregion
-//#region src/server/execution/executeSync.ts
+//#region src/server/factories.ts
 /**
-* Runs one command to completion synchronously, buffering its output, and returns the outcome.
-*
-* @remarks
-* The synchronous counterpart of {@link execute}, spawned through the same resolver and never through a
-* shell. The host offers no cooperative termination window and no in-flight cancellation, so this
-* contract carries neither. A positive `timeout` ends only the root process and can leave
-* descendants running; use {@link execute} or {@link Process} when timeout must terminate the tree. A
-* timeout and an output overflow both end the root with `SIGKILL`: an overflow reports `truncated`
-* and `failed` together and trims the partial output to `limit`, where {@link execute} keeps reading and
-* reports `truncated` without failing. The environment and input follow the same merge as
-* {@link execute}. Unless `strict` is `false`, a failed run throws a {@link createExecuteError}
-* carrying the {@link ExecuteResult}.
+* Creates one supervised child process.
 *
-* @param command - The executable, arguments, and optional environment and input
-* @param options - Working directory, timeout, capture limit, and failure delivery
-* @returns The run outcome
-* @throws A {@link ProcessError} coded `invalid` for a malformed option, command string, or batch-bound argument, or one carrying the {@link ExecuteResult} when the run failed and `strict` is not `false`
+* @param options - Command, workspace, termination, evidence, stdin, and observation settings
+* @returns The launched {@link ProcessInterface}
 *
 * @example
 * ```ts
-* const result = executeSync({ file: 'git', arguments: ['--version'] }, { strict: false })
+* import { createProcess } from '@orkestrel/process/server'
+*
+* const child = createProcess({
+* 	command: { file: 'node', arguments: ['--version'] },
+* 	workspace: process.cwd(),
+* 	grace: 5000,
+* })
 * ```
 */
-function executeSync(command, options) {
-	const snapshot = snapshotCommand(command);
-	const optionEnvironment = options?.environment;
-	const optionWorkspace = options?.workspace;
-	const optionInput = options?.input;
-	const optionTimeout = options?.timeout;
-	const optionStrict = options?.strict;
-	const optionLimit = options?.limit;
-	validateCommand(snapshot);
-	validateEnvironment(optionEnvironment);
-	validateWorkspace(optionWorkspace);
-	validateTimer(optionTimeout, "option 'timeout'");
-	validateBytes(optionLimit, "option 'limit'", 0);
-	const limit = optionLimit ?? _src_core.PROCESS_OUTPUT;
-	const timeout = optionTimeout ?? 0;
-	const strict = optionStrict ?? true;
-	const text = optionInput ?? snapshot.input;
-	const line = formatCommand(snapshot);
-	const workspace = optionWorkspace ?? process.cwd();
-	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment, optionEnvironment);
-	const plan = buildSpawn(snapshot, {
-		workspace,
-		environment
-	});
-	const outcome = (0, node_child_process.spawnSync)(plan.file, [...plan.arguments], {
-		cwd: workspace,
-		env: environment,
-		encoding: "buffer",
-		maxBuffer: limit,
-		killSignal: "SIGKILL",
-		windowsHide: true,
-		windowsVerbatimArguments: plan.verbatim,
-		...text !== void 0 ? { input: node_buffer.Buffer.from(text) } : {},
-		...timeout > 0 ? { timeout } : {}
-	});
-	const error = outcome.error;
-	const fault = error !== void 0 && "code" in error && (0, _orkestrel_contract.isString)(error.code) ? error.code : "";
-	const result = buildExecuteResult({
-		command: line,
-		stdout: node_buffer.Buffer.isBuffer(outcome.stdout) ? outcome.stdout : node_buffer.Buffer.alloc(0),
-		stderr: node_buffer.Buffer.isBuffer(outcome.stderr) ? outcome.stderr : node_buffer.Buffer.alloc(0),
-		code: outcome.status,
-		signal: outcome.signal,
-		expired: fault === "ETIMEDOUT",
-		aborted: false,
-		truncated: fault === "ENOBUFS",
-		limit,
-		...error === void 0 ? {} : { cause: error }
-	});
-	if (result.failed && strict) throw (0, _src_core.createExecuteError)(result, error);
-	return result;
+function createProcess(options) {
+	return new Process(options);
 }
-//#endregion
-//#region src/server/execution/detach.ts
 /**
-* Spawns one command as a detached process and returns without waiting for it.
+* Creates one raw byte session over a supervised child process.
 *
-* @remarks
-* The child owns no stdio and is unreferenced, so it outlives this process and nothing here observes
-* its outcome. The error listener is attached before the child is unreferenced, so a post-spawn host
-* fault is swallowed rather than crashing the caller; an invalid command is refused before anything
-* is spawned.
+* @param options - Command, workspace, termination, evidence, stdin, and observation settings
+* @returns The launched {@link SessionInterface}
 *
-* @param command - The executable, arguments, and optional environment
-* @param options - The working directory the detached child starts in
-* @returns Nothing
-* @throws A {@link ProcessError} coded `invalid` when the working directory or a command string is malformed
+* @example
+* ```ts
+* import { createSession } from '@orkestrel/process/server'
+*
+* const session = createSession({
+* 	command: { file: 'node', arguments: ['server.js', '--stdio'] },
+* 	workspace: process.cwd(),
+* 	grace: 5000,
+* })
+* ```
+*/
+function createSession(options) {
+	return new Session(options);
+}
+/**
+* Creates one keyed registry of supervised child processes.
+*
+* @param options - Initial fleet-level observation hooks and listener-error handling
+* @returns The {@link ProcessManagerInterface} registry
 *
 * @example
 * ```ts
-* detach({ file: 'node', arguments: ['daemon.js'] }, { workspace: process.cwd() })
+* import { createProcessManager } from '@orkestrel/process/server'
+*
+* const manager = createProcessManager()
 * ```
 */
-function detach(command, options) {
-	const snapshot = snapshotCommand(command);
-	const optionWorkspace = options?.workspace;
-	validateCommand(snapshot);
-	validateWorkspace(optionWorkspace);
-	const workspace = optionWorkspace ?? process.cwd();
-	const environment = mergeEnvironment(snapshot.isolated === true, snapshot.environment);
-	const plan = buildSpawn(snapshot, {
-		workspace,
-		environment
-	});
-	const child = (0, node_child_process.spawn)(plan.file, [...plan.arguments], {
-		cwd: workspace,
-		detached: true,
-		env: environment,
-		stdio: "ignore",
-		windowsHide: true,
-		windowsVerbatimArguments: plan.verbatim
-	});
-	child.once("error", () => void 0);
-	child.unref();
+function createProcessManager(options) {
+	return new ProcessManager(options);
 }
 //#endregion
 exports.Process = Process;
 exports.ProcessManager = ProcessManager;
-exports.Retention = Retention;
 exports.Session = Session;
+exports.Supervisor = Supervisor;
 exports.buildExecutableCandidates = buildExecutableCandidates;
 exports.buildExecuteResult = buildExecuteResult;
 exports.buildPlatformSpawn = buildPlatformSpawn;
 exports.buildSpawn = buildSpawn;
+exports.captureChunk = captureChunk;
 exports.createProcess = createProcess;
 exports.createProcessManager = createProcessManager;
 exports.createSession = createSession;