@mark1russell7/service 0.4.1 → 0.5.1

package/build/index.js

@@ -3,6 +3,7 @@ import { detectionTime, heartbeat } from "./heartbeat.js";
 import { a as recoverSpan, i as heartbeatDetection, n as asWindow, r as failSpan, t as asDebounce } from "./timing-DGRi3XCI.js";
 import { n as operationProblems, t as mayReissue } from "./operation-DL5RxFds.js";
 import { backoffBand, backoffDelay, backoffProblems } from "./backoff.js";
+import { n as countOf, r as millisecondsOf, t as boundedMillisecondsOf } from "./knobs-BxG-c7Zb.js";
 import { convertExact, convertible, quantity, rationals, valueIn } from "@mark1russell7/quantity";
 import { replay } from "@mark1russell7/algebra/replay";
 //#region src/description.ts
@@ -497,101 +498,441 @@ const EXIT_SIGNALS = [
 	"SIGTERM",
 	"SIGQUIT"
 ];
-/** This port is the process of Node. */
-const nodeProcess = {
-	on(signal, handler) {
-		const host = globalThis.process;
-		if (host === void 0) throw new Error("no process: give the runtime a process port");
-		host.on(signal, handler);
-		return () => {
-			host.off(signal, handler);
-		};
-	},
-	exit(code) {
-		const host = globalThis.process;
+/** These are the process triggers that a declaration can opt in to. */
+const PROCESS_TRIGGERS = [
+	"stdin-close",
+	"ipc-close",
+	"ipc-message"
+];
+/** This function tells if a number is an exit code of a process: a whole number from 0 to 255. */
+const isExitCode = (code) => Number.isInteger(code) && code >= 0 && code <= 255;
+/** This function tells if a trigger is an exit signal. A repeat signal obeys `onRepeatSignal`. */
+const isExitSignal = (trigger) => EXIT_SIGNALS.includes(trigger);
+/** This function tells if a value is a message shape: a value of JSON, with no function and no undefined. */
+const isMessageShape = (value) => {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isMessageShape);
+	if (typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === Object.prototype || prototype === null) && Object.values(value).every(isMessageShape);
+};
+/** This function tells if a message of the IPC channel matches a shape. */
+const matchesMessage = (shape, message) => {
+	if (shape === null || typeof shape !== "object") return Object.is(shape, message);
+	if (Array.isArray(shape)) {
+		const items = shape;
+		return Array.isArray(message) && message.length === items.length && items.every((item, at) => matchesMessage(item, message[at]));
+	}
+	if (message === null || typeof message !== "object" || Array.isArray(message)) return false;
+	const fields = message;
+	return Object.entries(shape).every(([field, value]) => Object.hasOwn(fields, field) && matchesMessage(value, fields[field]));
+};
+/** This time is the interval of the timer of a hold, the most that a timer of Node accepts. */
+const HOLD_INTERVAL = 2147483647;
+/** This function adds a handler to some events of an emitter. The handler operates one time at most. */
+const once = (emitter, events, handler) => {
+	let called = false;
+	const fire = () => {
+		if (called) return;
+		called = true;
+		handler();
+	};
+	for (const event of events) emitter.on(event, fire);
+	return () => {
+		for (const event of events) emitter.off(event, fire);
+	};
+};
+/** This function gives a promise that ends when the data before it in a stream is written. */
+const written = (stream) => new Promise((resolve) => {
+	if (stream === void 0 || stream.destroyed === true || stream.writable === false) {
+		resolve();
+		return;
+	}
+	try {
+		stream.write("", () => resolve());
+	} catch {
+		resolve();
+	}
+});
+/**
+* This function makes a process port on a host. `find` gives the host at each use, or undefined
+* when the platform has no process. Then the use throws.
+*/
+const processPortOf = (find) => {
+	const hostProcess = () => {
+		const host = find();
 		if (host === void 0) throw new Error("no process: give the runtime a process port");
-		host.exit(code);
+		return host;
+	};
+	return {
+		on(trigger, handler) {
+			const host = hostProcess();
+			if (trigger === "stdin-close") {
+				const input = host.stdin;
+				if (input === void 0) return () => {};
+				if (input.readableEnded === true) {
+					let live = true;
+					queueMicrotask(() => {
+						if (live) handler();
+					});
+					return () => {
+						live = false;
+					};
+				}
+				return once(input, ["end", "close"], handler);
+			}
+			if (trigger === "ipc-close") return once(host, ["disconnect"], handler);
+			if (trigger === "ipc-message") {
+				const receive = (message) => handler(message);
+				host.on("message", receive);
+				return () => {
+					host.off("message", receive);
+				};
+			}
+			host.on(trigger, handler);
+			return () => {
+				host.off(trigger, handler);
+			};
+		},
+		async flush() {
+			const host = hostProcess();
+			await Promise.all([written(host.stdout), written(host.stderr)]);
+		},
+		hold() {
+			hostProcess();
+			const timer = setInterval(() => {}, HOLD_INTERVAL);
+			let held = true;
+			return () => {
+				if (!held) return;
+				held = false;
+				clearInterval(timer);
+			};
+		},
+		exit(code) {
+			hostProcess().exit(code);
+		}
+	};
+};
+/** This port is the process of Node. */
+const nodeProcess = processPortOf(() => globalThis.process);
+//#endregion
+//#region src/routes.ts
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*/;
+/** This function gives the problems of the syntax of a pattern: an empty pattern, a part without a name, or a name two times. */
+const patternProblems = (owner, pattern) => {
+	const problems = [];
+	if (pattern.length === 0) problems.push(`${owner} has an empty route pattern`);
+	const names = /* @__PURE__ */ new Set();
+	for (let at = 0; at < pattern.length; at += 1) {
+		if (pattern[at] !== ":") continue;
+		const name = NAME.exec(pattern.slice(at + 1))?.[0];
+		if (name === void 0) {
+			problems.push(`${owner}'s pattern ${pattern} has a ":" without a name at ${at}`);
+			continue;
+		}
+		if (names.has(name)) problems.push(`${owner}'s pattern ${pattern} names :${name} two times`);
+		names.add(name);
+		at += name.length;
+	}
+	return problems;
+};
+/** This function gives the problems of a pattern and of each of its operations, which `describe()` refuses. */
+const routePatternProblems = (owner, declared) => {
+	const problems = patternProblems(owner, declared.pattern);
+	const names = Object.keys(declared.operations);
+	if (names.length === 0) problems.push(`${owner}'s pattern ${declared.pattern} declares no operation`);
+	for (const name of names) problems.push(...operationProblems(owner, `${declared.pattern} (${name})`, declared.operations[name]));
+	return problems;
+};
+/** This function compiles a pattern to a matcher. The match must cover the whole route. */
+const compilePattern = (pattern) => {
+	const kinds = [];
+	let source = "^";
+	for (let at = 0; at < pattern.length; at += 1) {
+		const char = pattern[at];
+		if (char === "*") {
+			source += "([\\s\\S]*)";
+			kinds.push({ kind: "wildcard" });
+			continue;
+		}
+		if (char === ":") {
+			const name = NAME.exec(pattern.slice(at + 1))?.[0];
+			if (name !== void 0) {
+				source += "([^/]+)";
+				kinds.push({
+					kind: "param",
+					name
+				});
+				at += name.length;
+				continue;
+			}
+		}
+		source += char.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
 	}
+	const matcher = new RegExp(`${source}$`);
+	return {
+		pattern,
+		match(route) {
+			const found = matcher.exec(route);
+			if (found === null) return null;
+			const params = {};
+			const wildcards = [];
+			kinds.forEach((part, index) => {
+				const text = found[index + 1] ?? "";
+				if (part.kind === "param") params[part.name] = text;
+				else wildcards.push(text);
+			});
+			return {
+				params,
+				wildcards
+			};
+		}
+	};
 };
 //#endregion
 //#region src/requests.ts
+const isAsyncIterable$1 = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.asyncIterator] === "function";
+const isPromiseLike = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+/** This function gives a stream of events from a function that gives the next event. */
+const streamOf = (next, stop) => {
+	let chain = Promise.resolve();
+	const iterator = {
+		next() {
+			const step = chain.then(next).then((event) => event === null ? {
+				value: void 0,
+				done: true
+			} : {
+				value: event,
+				done: false
+			});
+			chain = step.catch(() => {});
+			return step;
+		},
+		return() {
+			stop();
+			return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	};
+	return {
+		[Symbol.asyncIterator]: () => iterator,
+		async collect() {
+			const items = [];
+			for (;;) {
+				const step = await iterator.next();
+				if (step.done === true) throw new Error("the stream ended without its end");
+				if (step.value.kind === "item") items.push(step.value.value);
+				else return {
+					items,
+					end: step.value
+				};
+			}
+		}
+	};
+};
 /**
 * This function makes a tracker. `refuses` gives the reason that the service refuses a new request
-* for a controller at this time, or null when it admits it.
+* for a controller at this time, or null when it admits it. `choices` gives the function of each
+* route pattern, by controller and by pattern.
 */
-const tracker = (controllers, clock, refuses) => {
-	const byName = new Map(controllers.map((controller) => [controller.name, controller]));
+const tracker = (controllers, clock, refuses, choices = /* @__PURE__ */ new Map()) => {
+	const byName = new Map(controllers.map((controller) => [controller.name, {
+		controller,
+		patterns: (controller.patterns ?? []).map((declared) => ({
+			declared,
+			compiled: compilePattern(declared.pattern)
+		}))
+	}]));
 	const flights = /* @__PURE__ */ new Set();
 	const idle = /* @__PURE__ */ new Set();
 	let intake = true;
+	/** This function gives the operation of a request: its exact route, else the first pattern that matches it. */
+	const operationOf = (controller, route, detail) => {
+		const held = byName.get(controller);
+		if (held === void 0) throw new Error(`there is no controller ${controller}`);
+		const exact = held.controller.routes[route];
+		if (exact !== void 0) return exact;
+		for (const { declared, compiled } of held.patterns) {
+			const found = compiled.match(route);
+			if (found === null) continue;
+			const names = Object.keys(declared.operations);
+			const choose = choices.get(controller)?.get(declared.pattern);
+			const name = choose === void 0 ? names[0] : choose({
+				controller,
+				route,
+				...found,
+				detail
+			});
+			const operation = declared.operations[name];
+			if (operation === void 0) throw new Error(`the pattern ${declared.pattern} of ${controller} declares no operation ${String(name)} for ${route}`);
+			return operation;
+		}
+		throw new Error(`controller ${controller} does not declare the route ${route}`);
+	};
 	const settle = (flight) => {
-		flights.delete(flight);
+		if (!flights.delete(flight)) return;
 		if (flights.size === 0) for (const done of [...idle]) done();
 	};
-	/** This function answers a request that the shutdown stopped, by the idempotency of its route. */
-	const cut = (flight, cause) => {
-		const operation = byName.get(flight.controller).routes[flight.route];
-		const since = quantity(Math.max(0, clock.now() - flight.started) / 1e3, "s");
-		const retryable = mayReissue(operation, since);
-		return {
-			kind: "cut",
-			status: retryable ? 503 : 500,
-			retryable,
-			cause
+	/** This function starts the work of an admitted request, and gives its stream. */
+	const open = (controller, operation, work) => {
+		const started = clock.now();
+		const abort = new AbortController();
+		let delivered = 0;
+		let end = null;
+		let ended = false;
+		let returned = false;
+		let source = null;
+		let unary = null;
+		let interrupt = () => {};
+		const interrupted = new Promise((resolve) => {
+			interrupt = () => resolve("interrupted");
+		});
+		const cutEnd = (cause) => {
+			const since = quantity(Math.max(0, clock.now() - started) / 1e3, "s");
+			const retryable = mayReissue(operation, since);
+			return {
+				kind: "cut",
+				status: delivered > 0 ? null : retryable ? 503 : 500,
+				retryable,
+				cause,
+				delivered
+			};
 		};
-	};
-	return {
-		request(controller, route, work) {
-			const held = byName.get(controller);
-			if (held === void 0) throw new Error(`there is no controller ${controller}`);
-			if (held.routes[route] === void 0) throw new Error(`controller ${controller} does not declare the route ${route}`);
-			const refusal = intake ? refuses(controller) : "the service stopped its intake";
-			if (refusal !== null) return Promise.resolve({
-				kind: "refused",
-				status: 503,
-				retryable: true,
-				cause: refusal
-			});
-			return new Promise((resolve) => {
-				let answered = false;
-				const flight = {
-					controller,
-					route,
-					started: clock.now(),
-					abort: new AbortController(),
-					answer: (outcome) => {
-						if (answered) return;
-						answered = true;
-						settle(flight);
-						resolve(outcome);
-					}
+		/** This function ends the work of the request: the end is known, and the request leaves the flights. */
+		const finish = (given) => {
+			if (end !== null) return;
+			end = given;
+			settle(flight);
+			interrupt();
+		};
+		/** This function ends the work after a throw: a failure after the shutdown aborted it is a cut. */
+		const failed = (error) => finish(abort.signal.aborted ? cutEnd("the shutdown aborted it, and it failed") : {
+			kind: "failed",
+			error,
+			delivered
+		});
+		const closeSource = () => {
+			if (source === null || returned) return;
+			returned = true;
+			try {
+				Promise.resolve(source.return?.()).catch(() => {});
+			} catch {}
+		};
+		const flight = {
+			controller,
+			cooperative: () => {
+				abort.abort(/* @__PURE__ */ new Error("the cooperative abort of the drain"));
+				closeSource();
+			},
+			cut: (cause) => {
+				abort.abort(new Error(cause));
+				finish(cutEnd(cause));
+				closeSource();
+			}
+		};
+		flights.add(flight);
+		/** This function takes the result of the work: a stream, or one value. */
+		const take = (result) => {
+			if (end !== null) return;
+			if (isAsyncIterable$1(result)) {
+				source = result[Symbol.asyncIterator]();
+				if (abort.signal.aborted) closeSource();
+			} else {
+				unary = { value: result };
+				settle(flight);
+			}
+		};
+		let ready;
+		try {
+			const result = work(abort.signal);
+			if (isAsyncIterable$1(result) || !isPromiseLike(result)) {
+				take(result);
+				ready = Promise.resolve();
+			} else ready = Promise.resolve(result).then(take, failed);
+		} catch (error) {
+			failed(error);
+			ready = Promise.resolve();
+		}
+		const next = async () => {
+			if (ended) return null;
+			if (end === null) await Promise.race([ready, interrupted]);
+			if (end === null && unary !== null) {
+				const { value } = unary;
+				unary = null;
+				delivered = 1;
+				end = {
+					kind: "done",
+					delivered
+				};
+				return {
+					kind: "item",
+					value
 				};
-				flights.add(flight);
-				let promise;
+			}
+			if (end === null && source !== null) {
+				const pending = source.next();
+				let step;
 				try {
-					promise = Promise.resolve(work(flight.abort.signal));
+					step = await Promise.race([pending, interrupted]);
 				} catch (error) {
-					promise = Promise.reject(error);
+					failed(error);
+					step = "interrupted";
 				}
-				promise.then((value) => {
-					if (answered) return;
-					answered = true;
-					settle(flight);
-					resolve({
+				if (step !== "interrupted") {
+					if (step.done !== true) {
+						delivered += 1;
+						return {
+							kind: "item",
+							value: step.value
+						};
+					}
+					finish(abort.signal.aborted ? cutEnd("the shutdown ended the stream") : {
 						kind: "done",
-						value
+						delivered
 					});
-				}, (error) => {
-					if (answered) return;
-					const outcome = flight.abort.signal.aborted ? cut(flight, "the shutdown aborted it, and it failed") : {
-						kind: "failed",
-						error
-					};
-					answered = true;
-					settle(flight);
-					resolve(outcome);
+				}
+			}
+			ended = true;
+			return end;
+		};
+		const stop = () => {
+			if (end === null) {
+				abort.abort(/* @__PURE__ */ new Error("the reader stopped the stream"));
+				finish({
+					kind: "done",
+					delivered
 				});
-			});
+				closeSource();
+			}
+			ended = true;
+		};
+		return streamOf(next, stop);
+	};
+	return {
+		request(controller, route, work, options = {}) {
+			const operation = operationOf(controller, route, options.detail);
+			const refusal = intake ? refuses(controller) : "the service stopped its intake";
+			if (refusal !== null) {
+				let given = false;
+				const refused = {
+					kind: "refused",
+					status: 503,
+					retryable: true,
+					cause: refusal,
+					delivered: 0
+				};
+				return streamOf(() => {
+					if (given) return Promise.resolve(null);
+					given = true;
+					return Promise.resolve(refused);
+				}, () => {
+					given = true;
+				});
+			}
+			return open(controller, operation, work);
 		},
 		inFlight(controller) {
 			let count = 0;
@@ -602,7 +943,7 @@ const tracker = (controllers, clock, refuses) => {
 			intake = false;
 		},
 		cooperativeAbort() {
-			for (const flight of flights) flight.abort.abort(/* @__PURE__ */ new Error("the cooperative abort of the drain"));
+			for (const flight of [...flights]) flight.cooperative();
 		},
 		drain(deadline) {
 			if (flights.size === 0) return Promise.resolve();
@@ -617,10 +958,7 @@ const tracker = (controllers, clock, refuses) => {
 				};
 				idle.add(done);
 				const cancel = clock.after(Math.max(0, deadline - clock.now()), () => {
-					for (const flight of [...flights]) {
-						flight.abort.abort(/* @__PURE__ */ new Error("the drain reached its deadline"));
-						flight.answer(cut(flight, "the drain reached its deadline"));
-					}
+					for (const flight of [...flights]) flight.cut("the drain reached its deadline");
 					done();
 				});
 			});
@@ -641,7 +979,9 @@ const tracker = (controllers, clock, refuses) => {
 * - `close transports`: each transport closes.
 * - `stop the poller`: each check and watchdog stops. Then the signal of the service aborts.
 * - `tear down dependencies`: each dependency closes, in the reverse sequence of its connection.
-* - `close the health server`: the probes stop last.
+* - `close the health server`: the probes stop.
+* - `flush the output`: the work of the owners of this phase ends, and then the process port
+*   writes the buffered output. Without this phase, the process exits without a wait.
 */
 const STAGES = [
 	"fail readiness",
@@ -650,7 +990,8 @@ const STAGES = [
 	"close transports",
 	"stop the poller",
 	"tear down dependencies",
-	"close the health server"
+	"close the health server",
+	"flush the output"
 ];
 /** This function gives the place of a stage in the sequence, or -1 for a phase of another name. */
 const stageRank = (name) => STAGES.indexOf(name);
@@ -658,12 +999,12 @@ const stageRank = (name) => STAGES.indexOf(name);
 const ABORT_AFTER = stageRank("stop the poller");
 /**
 * This function gives the time of the cooperative abort, in milliseconds after the drain starts. It
-* is the cap less the cooperative window, and not less than half the cap. A window without a bound
-* gives half the cap.
+* is the cap less the cooperative window. With the floor `half`, it is not less than half the cap,
+* and a window without a bound gives half the cap. With the floor `none`, it is not less than 0.
 */
-const cooperativeAbortAt = (cap, window) => {
+const cooperativeAbortAt = (cap, window, floor = "half") => {
 	const before = window.value === "infinite" ? Number.POSITIVE_INFINITY : valueIn(window, "ms");
-	return Math.max(cap - before, cap / 2);
+	return Math.max(cap - before, floor === "none" ? 0 : cap / 2);
 };
 const message = (error) => error instanceof Error ? error.message : String(error);
 /**
@@ -688,12 +1029,12 @@ const lifecycleProblems = (description, components) => {
 };
 /**
 * This function starts the lifecycle of a service. The startup has a sequence: the health server
-* first, then each dependency, then each transport, and the startup gate last. A signal during the
+* first, then each dependency, then each transport, and the startup gate last. A trigger during the
 * startup gets its shutdown after the startup ends. The shutdown does the declared phases in their
-* sequence, each one capped. Only the lifecycle ends the process: 0 after a clean shutdown, and 1
-* after an error.
+* sequence, each one capped. Only the lifecycle ends the process. Its exit code is the code of the
+* exit request, else 1 after an error, else 0.
 */
-const lifecycle = (description, runtime, components, options = {}) => {
+const lifecycle = (description, runtime, components, options = {}, bind = () => {}) => {
 	const clock = options.clock ?? realClock;
 	const port = options.process ?? nodeProcess;
 	const record = (machine, from, to, on, detail) => options.record?.({
@@ -707,8 +1048,11 @@ const lifecycle = (description, runtime, components, options = {}) => {
 	});
 	const service = new AbortController();
 	const errors = [];
+	const exitCodes = description.shutdown.exitCodes ?? {};
+	const repeatPolicy = description.shutdown.onRepeatSignal;
 	let state = "starting";
 	let exitCode = null;
+	let requested;
 	let intakeStopped = false;
 	let shutdownStarted = false;
 	let failedStartup = false;
@@ -719,14 +1063,14 @@ const lifecycle = (description, runtime, components, options = {}) => {
 	};
 	const fail = (cause) => {
 		errors.push(cause);
-		record("exit", exitState, exitState, "error", cause);
+		if (exitState !== "exited") record("exit", exitState, exitState, "error", cause);
 	};
 	const requests = tracker(description.controllers, clock, (controller) => {
 		if (state === "starting") return "the service has not started";
 		if (state === "exited") return "the service has exited";
 		if (state === "draining") return null;
 		return runtime.verdict().controllers[controller] === true ? null : `controller ${controller} is not ready`;
-	});
+	}, components.choices);
 	let finish = () => {};
 	const done = new Promise((resolve) => {
 		finish = resolve;
@@ -734,45 +1078,49 @@ const lifecycle = (description, runtime, components, options = {}) => {
 	let healthListening = false;
 	const connected = [];
 	const startedTransports = [];
-	const offs = EXIT_SIGNALS.map((signal) => port.on(signal, () => {
-		shutdown(signal);
-	}));
-	const startup = (async () => {
-		runtime.beginStartup();
-		const started = (what) => record("gate", "starting", "starting", "component.started", what);
-		try {
-			if (components.healthServer !== null) {
-				await components.healthServer.listen(runtime);
-				healthListening = true;
-				started("the health server");
-			}
-			for (const dependency of description.dependencies) {
-				const handle = components.dependencies.get(dependency.name);
-				if (handle === void 0) continue;
-				await handle.connect(service.signal);
-				connected.push([dependency.name, handle]);
-				started(`dependency ${dependency.name}`);
-			}
-			for (const transport of description.transports) {
-				const impl = components.transports.get(transport.name);
-				await impl.start(service.signal);
-				startedTransports.push([transport.name, impl]);
-				started(`${transport.kind} ${transport.name}`);
+	let startupEnded = () => {};
+	const startup = new Promise((resolve) => {
+		startupEnded = resolve;
+	});
+	let offs = [];
+	let release = () => {};
+	/** This function ends the process with a code, one time, and removes each handler of a trigger and the hold. */
+	const end = (code, on) => {
+		state = "exited";
+		exitCode = code;
+		for (const off of offs) off();
+		offs = [];
+		moveExit("exited", on, `exit ${code}`);
+		finish(code);
+		release();
+		port.exit(code);
+	};
+	/**
+	* This function receives a trigger of the process: the first one starts the shutdown. The cause
+	* names the trigger, and a message that stands for a signal tells it.
+	*/
+	const triggered = (trigger, cause = trigger) => {
+		if (exitState === "exited") return;
+		if (shutdownStarted || exitState === "stopping") {
+			if (isExitSignal(trigger) && repeatPolicy === "exit") {
+				fail(`${cause} came again while the shutdown ran, and the declaration exits at once`);
+				end(1, "exit.repeat");
+				return;
 			}
-			await runtime.warmUp();
-			if (state === "starting") state = "running";
-		} catch (error) {
-			const cause = `the startup failed: ${message(error)}`;
-			failedStartup = true;
-			runtime.failStartup(cause);
-			fail(cause);
-			if (exitState === "running") moveExit("stopping", "startup.fail", cause);
-			else record("exit", exitState, exitState, "startup.fail", cause);
+			record("exit", exitState, exitState, "exit.repeat", cause);
+			return;
 		}
-	})();
-	startup.then(() => {
-		if (failedStartup && !shutdownStarted) shutdown("the startup failed");
-	});
+		const code = exitCodes[trigger];
+		shutdown(cause, code === void 0 ? {} : { code });
+	};
+	const messages = description.shutdown.messages ?? [];
+	/** This function receives a message of the IPC channel. The first declared shape that it matches gives its trigger. */
+	const received = (message) => {
+		const found = messages.find((each) => matchesMessage(each.match, message));
+		if (found === void 0) return;
+		if (found.as === void 0) triggered("ipc-message");
+		else triggered(found.as, `${found.as} (a message of the IPC channel)`);
+	};
 	/** This function does the work of one phase, until its cap. It gives true when the work ended in time. */
 	const runPhase = async (phase, hold, work) => {
 		const cap = valueIn(phase.cap, "ms");
@@ -802,14 +1150,22 @@ const lifecycle = (description, runtime, components, options = {}) => {
 		capped.abort(/* @__PURE__ */ new Error(`the phase ${phase.name} reached its cap`));
 		return pending === 0;
 	};
-	async function shutdown(cause = "the service asked for it") {
-		if (shutdownStarted || exitState === "exited") {
+	async function shutdown(cause = "the service asked for it", request = {}) {
+		if (request.code !== void 0 && !isExitCode(request.code)) throw new Error(`${description.name}: the exit code ${request.code} is not a whole number from 0 to 255`);
+		if (exitState === "exited") return done;
+		if (request.code !== void 0 && requested === void 0) requested = request.code;
+		if (shutdownStarted) {
 			if (exitState === "stopping") record("exit", exitState, exitState, "exit.repeat", cause);
 			return done;
 		}
 		shutdownStarted = true;
 		if (exitState === "running") moveExit("stopping", "exit.request", cause);
 		await startup;
+		if (exitState === "exited") {
+			runtime.stop();
+			components.stopPollers();
+			return exitCode;
+		}
 		state = "draining";
 		runtime.drain();
 		let drainState = "running";
@@ -825,10 +1181,12 @@ const lifecycle = (description, runtime, components, options = {}) => {
 		const phases = description.shutdown.phases;
 		let on = "exit.request";
 		for (const phase of phases) {
+			if (exitState === "exited") break;
 			const rank = stageRank(phase.name);
 			moveDrain(phase.name, on);
 			if (rank > ABORT_AFTER) abortService();
 			const work = [];
+			const owned = components.phaseWork.get(phase.name) ?? [];
 			if (phase.name === "stop intake") {
 				work.push(() => {
 					intakeStopped = true;
@@ -840,7 +1198,7 @@ const lifecycle = (description, runtime, components, options = {}) => {
 			if (phase.name === "drain") {
 				const cap = valueIn(phase.cap, "ms");
 				const cooperative = new AbortController();
-				const fireAt = cooperativeAbortAt(cap, description.shutdown.cooperativeWindow);
+				const fireAt = cooperativeAbortAt(cap, description.shutdown.cooperativeWindow, description.shutdown.cooperativeFloor);
 				cancelAbort = clock.after(fireAt, () => {
 					cooperative.abort(/* @__PURE__ */ new Error("the cooperative abort of the drain"));
 					requests.cooperativeAbort();
@@ -861,26 +1219,33 @@ const lifecycle = (description, runtime, components, options = {}) => {
 				const server = components.healthServer;
 				work.push(() => server.close());
 			}
-			for (const owned of components.phaseWork.get(phase.name) ?? []) work.push(owned);
+			if (phase.name === "flush the output") work.push(async (context) => {
+				await Promise.all(owned.map(async (each) => {
+					try {
+						await each(context);
+					} catch (error) {
+						fail(`the phase ${phase.name} failed: ${message(error)}`);
+					}
+				}));
+				await port.flush?.();
+			});
+			else for (const each of owned) work.push(each);
 			const inTime = await runPhase(phase, phase.name === "fail readiness", work);
 			cancelAbort();
 			if (!inTime) fail(`the phase ${phase.name} did not end in its cap of ${valueIn(phase.cap, "s")} s`);
 			on = inTime ? "phase.done" : "phase.cap";
 		}
-		moveDrain("done", on);
+		if (exitState !== "exited") moveDrain("done", on);
 		abortService();
 		runtime.stop();
 		components.stopPollers();
 		if (!intakeStopped) requests.stopIntake();
-		for (const off of offs) off();
-		state = "exited";
-		exitCode = errors.length > 0 ? 1 : 0;
-		moveExit("exited", "shutdown.done", `exit ${exitCode}`);
-		finish(exitCode);
-		port.exit(exitCode);
-		return exitCode;
+		if (exitState === "exited") return exitCode;
+		const code = requested !== void 0 && requested !== 0 ? requested : errors.length > 0 ? 1 : 0;
+		end(code, "shutdown.done");
+		return code;
 	}
-	return {
+	const life = {
 		health: runtime,
 		get state() {
 			return state;
@@ -895,10 +1260,52 @@ const lifecycle = (description, runtime, components, options = {}) => {
 		done,
 		signal: service.signal,
 		shutdown,
-		request: (controller, route, work) => requests.request(controller, route, work),
+		request: (controller, route, work, request) => requests.request(controller, route, work, request),
 		inFlight: (controller) => requests.inFlight(controller),
 		keepAlive: () => state === "running" && runtime.verdict().ready
 	};
+	bind(life);
+	release = port.hold?.() ?? (() => {});
+	offs = [...EXIT_SIGNALS, ...description.shutdown.triggers ?? []].map((trigger) => port.on(trigger, trigger === "ipc-message" ? received : () => triggered(trigger)));
+	(async () => {
+		const started = (what) => record("gate", "starting", "starting", "component.started", what);
+		try {
+			runtime.beginStartup();
+			if (components.healthServer !== null) {
+				await components.healthServer.listen(runtime);
+				healthListening = true;
+				started("the health server");
+			}
+			for (const dependency of description.dependencies) {
+				const handle = components.dependencies.get(dependency.name);
+				if (handle === void 0) continue;
+				await handle.connect(service.signal);
+				connected.push([dependency.name, handle]);
+				started(`dependency ${dependency.name}`);
+			}
+			for (const transport of description.transports) {
+				const impl = components.transports.get(transport.name);
+				await impl.start(service.signal, life);
+				startedTransports.push([transport.name, impl]);
+				started(`${transport.kind} ${transport.name}`);
+			}
+			await runtime.warmUp();
+			if (state === "starting") state = "running";
+		} catch (error) {
+			const cause = `the startup failed: ${message(error)}`;
+			failedStartup = true;
+			runtime.failStartup(cause);
+			fail(cause);
+			if (exitState === "running") moveExit("stopping", "startup.fail", cause);
+			else if (exitState === "stopping") record("exit", exitState, exitState, "startup.fail", cause);
+		} finally {
+			startupEnded();
+		}
+	})();
+	startup.then(() => {
+		if (failedStartup && !shutdownStarted && exitState !== "exited") shutdown("the startup failed");
+	});
+	return life;
 };
 //#endregion
 //#region src/watchdog.ts
@@ -952,8 +1359,8 @@ const watchdog = (clock, spec, trace) => {
 };
 //#endregion
 //#region src/builder.ts
-const isTime = (amount) => convertible(amount.unit, "s");
-const above = (amount) => amount.value === "infinite" || isTime(amount) && valueIn(amount, "s") > 0;
+const isTime$1 = (amount) => convertible(amount.unit, "s");
+const above = (amount) => amount.value === "infinite" || isTime$1(amount) && valueIn(amount, "s") > 0;
 const whole = (count) => Number.isInteger(count) && count >= 1;
 /** This function gives the problems of a timing: a zero interval or count fails decoding. */
 const timingProblems = (policy, timing) => {
@@ -964,15 +1371,33 @@ const timingProblems = (policy, timing) => {
 		if (!whole(timing.recoverAfter)) problems.push(`the ${policy} debounce recovers after ${timing.recoverAfter} polls, not a whole number above zero`);
 		return problems;
 	}
-	const negative = (amount) => amount !== void 0 && (!isTime(amount) || valueIn(amount, "s") < 0);
+	const negative = (amount) => amount !== void 0 && (!isTime$1(amount) || valueIn(amount, "s") < 0);
 	return negative(timing.failAfter) || negative(timing.recoverAfter) ? [`the ${policy} window is not a time of zero or more`] : [];
 };
+/** This function gives the problems of the rules of the shutdown: an unknown name, or an exit code that a process cannot give. */
+const shutdownProblems = (floor, repeat, triggers, exitCodes, messages) => {
+	const problems = [];
+	if (floor !== void 0 && floor !== "half" && floor !== "none") problems.push(`the cooperative floor ${String(floor)} is not "half" or "none"`);
+	if (repeat !== void 0 && repeat !== "ignore" && repeat !== "exit") problems.push(`the policy of a repeat signal ${String(repeat)} is not "ignore" or "exit"`);
+	for (const trigger of triggers) if (!PROCESS_TRIGGERS.includes(trigger)) problems.push(`the trigger ${String(trigger)} is not a process trigger (${PROCESS_TRIGGERS.join(", ")})`);
+	if (triggers.includes("ipc-message") && messages.length === 0) problems.push(`the trigger ipc-message has no message to match: declare it with svc.trigger("ipc-message", { match })`);
+	for (const message of messages) {
+		if (!isMessageShape(message.match)) problems.push(`the match of a message trigger is not a value of JSON: ${String(message.match)}`);
+		if (message.as !== void 0 && !isExitSignal(message.as)) problems.push(`a message trigger stands for ${String(message.as)}, not an exit signal (${EXIT_SIGNALS.join(", ")})`);
+	}
+	for (const [trigger, code] of Object.entries(exitCodes)) {
+		if (!(EXIT_SIGNALS.includes(trigger) || triggers.includes(trigger))) problems.push(`the exit code of ${trigger} names no exit signal and no declared trigger`);
+		if (code === void 0 || !isExitCode(code)) problems.push(`the exit code of ${trigger} is ${String(code)}, not a whole number from 0 to 255`);
+	}
+	return problems;
+};
 /** This function starts the composition of a service. */
 const service = (name) => {
 	if (name.trim().length === 0) throw new Error("a service needs a name");
 	const transports = [];
 	const dependencies = [];
 	const controllers = [];
+	const choices = /* @__PURE__ */ new Map();
 	const checks = [];
 	const runs = /* @__PURE__ */ new Map();
 	const couplings = [];
@@ -981,11 +1406,17 @@ const service = (name) => {
 	let liveness;
 	let startup;
 	let cooperative;
+	let floor;
+	let repeat;
+	const triggers = [];
+	const messages = [];
+	const exitCodes = {};
 	let started = false;
 	let partial = false;
 	let runtime;
 	let live;
 	let running;
+	let life;
 	const transportImpls = /* @__PURE__ */ new Map();
 	const handles = /* @__PURE__ */ new Map();
 	const phaseWork = /* @__PURE__ */ new Map();
@@ -1054,6 +1485,9 @@ const service = (name) => {
 		get health() {
 			return live ?? null;
 		},
+		get lifecycle() {
+			return life ?? null;
+		},
 		dependency(entry, spec, handle) {
 			once(dependencies, entry, "dependency");
 			if (handle !== void 0 && !started) handles.set(entry, handle);
@@ -1078,7 +1512,8 @@ const service = (name) => {
 			const held = {
 				name: entry,
 				requires: [],
-				routes: {}
+				routes: {},
+				patterns: []
 			};
 			controllers.push(held);
 			const handle = {
@@ -1092,6 +1527,21 @@ const service = (name) => {
 					if (held.routes[served] !== void 0) throw new Error(`${entry} already serves ${served}`);
 					held.routes[served] = { ...operation };
 					return handle;
+				},
+				pattern(pattern, operations, operationOf) {
+					composing(`${entry}'s route patterns`);
+					if (held.patterns.some((each) => each.pattern === pattern)) throw new Error(`${entry} already has the route pattern ${pattern}`);
+					if (operationOf === void 0 && Object.keys(operations).length > 1) throw new Error(`${entry}'s pattern ${pattern} has ${Object.keys(operations).length} operations, thus it needs the function that picks one`);
+					held.patterns.push({
+						pattern,
+						operations: Object.fromEntries(Object.entries(operations).map(([name, operation]) => [name, { ...operation }]))
+					});
+					if (operationOf !== void 0) {
+						const mine = choices.get(entry) ?? /* @__PURE__ */ new Map();
+						mine.set(pattern, operationOf);
+						choices.set(entry, mine);
+					}
+					return handle;
 				}
 			};
 			return handle;
@@ -1169,6 +1619,47 @@ const service = (name) => {
 			cooperative = window;
 			return builder;
 		},
+		cooperativeFloor(given) {
+			composing("the cooperative floor");
+			floor = given;
+			return builder;
+		},
+		onRepeatSignal(policy) {
+			composing("the policy of a repeat signal");
+			repeat = policy;
+			return builder;
+		},
+		trigger(...given) {
+			composing("a trigger");
+			const [first, message] = given;
+			if (first === "ipc-message" && typeof message === "object" && message !== null) {
+				if (!triggers.includes("ipc-message")) triggers.push("ipc-message");
+				messages.push({ ...message });
+				return builder;
+			}
+			for (const each of given) if (typeof each === "string" && !triggers.includes(each)) triggers.push(each);
+			return builder;
+		},
+		exitCode(trigger, code) {
+			composing(`the exit code of ${trigger}`);
+			exitCodes[trigger] = code;
+			return builder;
+		},
+		profile(given) {
+			composing("a profile");
+			if (given.readiness !== void 0) builder.readiness(given.readiness);
+			if (given.liveness !== void 0) builder.liveness(given.liveness);
+			if (given.startup !== void 0) builder.startup(given.startup);
+			for (const coupling of given.couplings ?? []) builder.couple(coupling);
+			for (const each of given.phases ?? []) builder.phase(each.name, each.cap);
+			if (given.cooperativeWindow !== void 0) builder.cooperativeWindow(given.cooperativeWindow);
+			if (given.cooperativeFloor !== void 0) builder.cooperativeFloor(given.cooperativeFloor);
+			if (given.onRepeatSignal !== void 0) builder.onRepeatSignal(given.onRepeatSignal);
+			if (given.triggers !== void 0) builder.trigger(...given.triggers);
+			for (const message of given.messages ?? []) builder.trigger("ipc-message", message);
+			for (const [trigger, code] of Object.entries(given.exitCodes ?? {})) if (code !== void 0) builder.exitCode(trigger, code);
+			return builder;
+		},
 		describe() {
 			const missing = [];
 			if (readiness === void 0) missing.push("readiness (svc.readiness)");
@@ -1176,6 +1667,7 @@ const service = (name) => {
 			if (startup === void 0) missing.push("a startup budget (svc.startup)");
 			if (phases.length === 0) missing.push("its shutdown phases (svc.phase)");
 			if (cooperative === void 0) missing.push("a cooperative window, or no bound (svc.cooperativeWindow)");
+			if (repeat === void 0) missing.push(`what a repeat signal does, "ignore" or "exit" (svc.onRepeatSignal)`);
 			if (missing.length > 0) throw new Error(`${name} does not declare ${missing.join("; ")}: the runtime has no defaults`);
 			const known = new Set(dependencies.map((entry) => entry.name));
 			const problems = [];
@@ -1186,25 +1678,31 @@ const service = (name) => {
 			for (const gate of ["readiness", "liveness"]) problems.push(...timingProblems(gate, policies[gate]));
 			for (const check of checks) {
 				if (check.dependency !== null && !known.has(check.dependency)) problems.push(`check ${check.name} exercises ${check.dependency}, which is not a dependency`);
-				if (!isTime(check.poll.interval) || !isTime(check.poll.timeout)) problems.push(`check ${check.name} polls in a unit that is not a time`);
+				if (!isTime$1(check.poll.interval) || !isTime$1(check.poll.timeout)) problems.push(`check ${check.name} polls in a unit that is not a time`);
 				else if (!above(check.poll.interval) || !above(check.poll.timeout)) problems.push(`check ${check.name} polls with an interval or a timeout that is not above zero`);
 				if (!(check.poll.jitter >= 0 && check.poll.jitter < 1)) problems.push(`check ${check.name} has a jitter of ${check.poll.jitter}, not a fraction below 1`);
 				const timing = check.gates === null ? null : policies[check.gates];
-				if (timing?.type === "debounce" && isTime(check.poll.interval) && above(timing.interval) && valueIn(check.poll.interval, "s") !== valueIn(timing.interval, "s")) problems.push(`check ${check.name} polls every ${valueIn(check.poll.interval, "s")} s, but the ${check.gates} debounce counts polls every ${valueIn(timing.interval, "s")} s`);
+				if (timing?.type === "debounce" && isTime$1(check.poll.interval) && above(timing.interval) && valueIn(check.poll.interval, "s") !== valueIn(timing.interval, "s")) problems.push(`check ${check.name} polls every ${valueIn(check.poll.interval, "s")} s, but the ${check.gates} debounce counts polls every ${valueIn(timing.interval, "s")} s`);
 			}
 			for (const controller of controllers) {
 				for (const needed of controller.requires) if (!known.has(needed)) problems.push(`controller ${controller.name} requires ${needed}, which is not a dependency`);
 				for (const [route, operation] of Object.entries(controller.routes)) problems.push(...operationProblems(`controller ${controller.name}`, route, operation));
+				for (const declared of controller.patterns) problems.push(...routePatternProblems(`controller ${controller.name}`, declared));
 			}
 			for (const dependency of dependencies) for (const [name, operation] of Object.entries(dependency.operations)) problems.push(...operationProblems(`dependency ${dependency.name}`, name, operation));
-			for (const phase of phases) if (!isTime(phase.cap)) problems.push(`phase ${phase.name}'s cap is not a time`);
+			for (const phase of phases) if (!isTime$1(phase.cap)) problems.push(`phase ${phase.name}'s cap is not a time`);
+			problems.push(...shutdownProblems(floor, repeat, triggers, exitCodes, messages));
 			const ranked = phases.map((phase) => phase.name).filter((each) => stageRank(each) >= 0);
 			for (let at = 1; at < ranked.length; at += 1) if (stageRank(ranked[at]) < stageRank(ranked[at - 1])) problems.push(`the phase "${ranked[at]}" comes after "${ranked[at - 1]}", but the stages go ${STAGES.join(", ")}`);
 			if (problems.length > 0) throw new Error(`${name}: ${problems.join("; ")}`);
 			const controllersOut = controllers.map((entry) => ({
 				name: entry.name,
 				requires: [...entry.requires],
-				routes: { ...entry.routes }
+				routes: { ...entry.routes },
+				...entry.patterns.length === 0 ? {} : { patterns: entry.patterns.map((each) => ({
+					pattern: each.pattern,
+					operations: { ...each.operations }
+				})) }
 			}));
 			return {
 				format: FORMAT,
@@ -1232,7 +1730,12 @@ const service = (name) => {
 				couplings: couplings.map((entry) => ({ ...entry })),
 				shutdown: {
 					phases: phases.map((entry) => ({ ...entry })),
-					cooperativeWindow: cooperative
+					cooperativeWindow: cooperative,
+					...floor === void 0 ? {} : { cooperativeFloor: floor },
+					onRepeatSignal: repeat,
+					...triggers.length === 0 ? {} : { triggers: [...triggers] },
+					...messages.length === 0 ? {} : { messages: messages.map((each) => ({ ...each })) },
+					...Object.keys(exitCodes).length === 0 ? {} : { exitCodes: { ...exitCodes } }
 				}
 			};
 		},
@@ -1253,7 +1756,6 @@ const service = (name) => {
 		run(options = {}) {
 			if (running !== void 0) return running;
 			if (runtime !== void 0) return Promise.reject(/* @__PURE__ */ new Error(`${name} started its health only: run() starts the whole lifecycle`));
-			let life;
 			try {
 				const description = builder.describe();
 				const components = {
@@ -1261,6 +1763,7 @@ const service = (name) => {
 					dependencies: handles,
 					healthServer: probes,
 					phaseWork,
+					choices,
 					stopPollers: () => {}
 				};
 				const problems = lifecycleProblems(description, components);
@@ -1268,14 +1771,16 @@ const service = (name) => {
 				const made = makeRuntime(options);
 				started = true;
 				live = made.runtime;
-				life = lifecycle(made.description, made.runtime, {
+				const ran = lifecycle(made.description, made.runtime, {
 					...components,
 					stopPollers: made.stopPollers
-				}, options);
+				}, options, (given) => {
+					life = given;
+				});
+				running = ran.started.then(() => ran);
 			} catch (error) {
 				return Promise.reject(error);
 			}
-			running = life.started.then(() => life);
 			return running;
 		}
 	};
@@ -1374,6 +1879,7 @@ const SERVICE_RULES = [
 	"O17",
 	"O18",
 	"O19",
+	"O20",
 	"O21",
 	"O22",
 	"O23",
@@ -1383,6 +1889,14 @@ const SERVICE_RULES = [
 const secondsOf = (amount) => rationals.toNumber(convertExact(rationals.fromNumber(amount.value), amount.unit, "s"));
 /** This function gives an amount, or no bound, as the law binds it. */
 const boundOf = (amount) => amount.value === "infinite" ? "inf" : secondsOf(amount);
+/** This function tells if a unit is a time. A unit that the package does not know is not a time. */
+const isTime = (unit) => {
+	try {
+		return convertible(unit, "s");
+	} catch {
+		return false;
+	}
+};
 /** This function gives the largest of some numbers of seconds, or undefined when there are none. */
 const most = (values) => values.length === 0 ? void 0 : Math.max(...values);
 /** This function gives what the declaration tells about the service, as symbols of the law, and the source of each. */
@@ -1424,15 +1938,64 @@ const dependencyBindings = (dependency, scenario) => {
 	for (const [symbol, amount] of Object.entries(scenario.dependencies?.[dependency.name] ?? {})) bind[symbol.includes("@") ? symbol : `${symbol}@dependency`] = boundOf(amount);
 	return bind;
 };
+/**
+* These are the hops of the law at which the knobs of a transport bind, by its kind. A worker does
+* its units as a consumer does, thus both bind at `consumer` (O20). A server binds at no hop yet.
+*/
+const TRANSPORT_HOPS = {
+	server: null,
+	consumer: "consumer",
+	worker: "consumer"
+};
+/**
+* This function gives the time knobs of a transport at the hop of its kind, and the values of the
+* scenario for its source. A knob with a hop in its name binds at that hop. A count binds no symbol.
+*/
+const transportBindings = (transport, hop, scenario) => {
+	const bind = {};
+	for (const [knob, amount] of Object.entries(transport.knobs)) {
+		if (!isTime(amount.unit)) continue;
+		bind[knob.includes("@") ? knob : `${knob}@${hop}`] = boundOf(amount);
+	}
+	for (const [symbol, amount] of Object.entries(scenario.transports?.[transport.name] ?? {})) bind[symbol] = boundOf(amount);
+	return bind;
+};
 const SCOPED = /@(client|dependency|server)$/;
-/** This function applies each service rule to a declaration and a scenario: one time for the service, and one time for each client. */
+const TRANSPORT_SCOPED = /@consumer$/;
+/** This identifier is the rule of the findings about a field that the declaration does not give. */
+const DECLARATION_RULE = "declaration";
+/**
+* This function gives a finding for each field of the shutdown that a description does not give.
+* `describe()` refuses such a declaration. A description from another source, for example the
+* JSON of 0.4, can lack the field. The verdict is `depends`, and `unbound` names the field.
+*/
+const declarationFindings = (svc) => svc.shutdown.onRepeatSignal === void 0 ? [{
+	rule: DECLARATION_RULE,
+	scope: svc.name,
+	verdict: "depends",
+	statement: "the declaration tells what a signal does while the shutdown runs: ignore or exit",
+	window: "a repeat signal has no declared effect",
+	evaluated: [],
+	unbound: ["shutdown.onRepeatSignal"]
+}] : [];
+/**
+* This function applies each service rule to a declaration and a scenario. A rule applies one time
+* for the service, for each client, or for each consumer and worker. The function also gives a
+* finding for each necessary field that the description does not give (`DECLARATION_RULE`).
+*/
 const lint = (svc, scenario, rules) => {
 	const service = serviceBindings(svc, scenario).bind;
-	const findings = [];
+	const findings = [...declarationFindings(svc)];
 	for (const rule of rules) {
 		if (!SERVICE_RULES.includes(rule.id)) continue;
 		const symbols = symbolsOf(rule);
-		const scopes = symbols.some((symbol) => SCOPED.test(symbol)) ? svc.dependencies.map((dependency) => [dependency.name, {
+		const scopes = symbols.some((symbol) => TRANSPORT_SCOPED.test(symbol)) ? svc.transports.flatMap((transport) => {
+			const hop = TRANSPORT_HOPS[transport.kind];
+			return hop === null ? [] : [[transport.name, {
+				...service,
+				...transportBindings(transport, hop, scenario)
+			}]];
+		}) : symbols.some((symbol) => SCOPED.test(symbol)) ? svc.dependencies.map((dependency) => [dependency.name, {
 			...service,
 			...dependencyBindings(dependency, scenario)
 		}]) : [[svc.name, service]];
@@ -1452,6 +2015,767 @@ const lint = (svc, scenario, rules) => {
 	return findings;
 };
 //#endregion
+//#region src/profiles.ts
+const s = (value) => ({
+	value,
+	unit: "s"
+});
+const phase = (name, cap) => ({
+	name,
+	cap
+});
+/**
+* This profile is for a service on the computer of a developer. No load balancer routes to it,
+* thus it has no readiness hold. Its caps sum to 10 s, and a second signal exits at once. It
+* declares no checks, thus the caller declares readiness, liveness and the startup budget.
+*/
+const localDev = {
+	phases: [
+		phase("stop intake", s(1)),
+		phase("drain", s(4)),
+		phase("close transports", s(1)),
+		phase("stop the poller", s(1)),
+		phase("tear down dependencies", s(1)),
+		phase("close the health server", s(1)),
+		phase("flush the output", s(1))
+	],
+	cooperativeWindow: s(2),
+	cooperativeFloor: "half",
+	onRepeatSignal: "exit"
+};
+/**
+* This profile is for a background host on the computer of a developer, under a supervisor or a
+* command that stops it. It has the caps of `localDev`. A repeat signal has no effect, thus the
+* host ends its drain. It has no process trigger: a background host has no parent on stdin.
+*/
+const daemon = {
+	phases: localDev.phases.map((each) => ({ ...each })),
+	cooperativeWindow: localDev.cooperativeWindow,
+	cooperativeFloor: "half",
+	onRepeatSignal: "ignore"
+};
+/**
+* This profile is for a small process: a command that runs one time, or a child process on stdio.
+* It has no checks and no probes, and its policies gate nothing. The cooperative abort occurs at the
+* start of the drain, thus a first Ctrl-C stops the work at once. A second signal exits at once.
+* The exit codes tell the shell how the process stopped: 130 for SIGINT, 143 for SIGTERM and 131
+* for SIGQUIT. A stdio child also declares `triggers: ["stdin-close"]`.
+*/
+const ephemeral = {
+	readiness: {
+		type: "window",
+		failAfter: s(0)
+	},
+	liveness: {
+		type: "window",
+		failAfter: s(0)
+	},
+	startup: s(10),
+	phases: [
+		phase("stop intake", s(1)),
+		phase("drain", s(2)),
+		phase("close transports", s(1)),
+		phase("stop the poller", s(1)),
+		phase("tear down dependencies", s(2)),
+		phase("flush the output", s(1))
+	],
+	cooperativeWindow: s(2),
+	cooperativeFloor: "none",
+	onRepeatSignal: "exit",
+	exitCodes: {
+		SIGINT: 130,
+		SIGTERM: 143,
+		SIGQUIT: 131
+	}
+};
+/** These are the parts of the budget of each stage in the profile `kubernetes`, in thirtieths. */
+const KUBERNETES_SHARES = [
+	["fail readiness", 2],
+	["stop intake", 5],
+	["drain", 15],
+	["close transports", 2],
+	["stop the poller", 1],
+	["tear down dependencies", 2],
+	["close the health server", 1]
+];
+/** This part of the budget is the cooperative window, in thirtieths. */
+const KUBERNETES_WINDOW = 5;
+/**
+* This function gives the profile of a pod in Kubernetes. The budget is the grace less the preStop
+* sleep: the time from SIGTERM to SIGKILL. Each stage gets a part of the budget, rounded down to
+* the millisecond.
+* - The parts in thirtieths are 2, 5, 15, 2, 1, 2 and 1, in the sequence of the stages. Thus 2
+*   thirtieths of the budget stay as a margin before SIGKILL.
+* - The cooperative window is 5 thirtieths of the budget.
+* - The kubelet sends SIGTERM one time, thus a repeat signal has no effect.
+*
+* At the defaults of Kubernetes (a grace of 30 s and no preStop hook), the caps are 2, 5, 15, 2, 1,
+* 2 and 1 s. Thus the sum of the caps and the preStop sleep fits in the grace (O10). The window is
+* shorter than the drain, which is shorter than the budget (O16).
+*/
+const kubernetes = (pod) => {
+	const time = (amount, what) => {
+		if (!convertible(amount.unit, "s")) throw new Error(`the ${what} of the pod is not a time`);
+		return valueIn(amount, "ms");
+	};
+	const grace = time(pod.grace, "grace");
+	const preStop = time(pod.preStop, "preStop sleep");
+	if (preStop < 0) throw new Error("the preStop sleep of the pod is less than 0");
+	const budget = grace - preStop;
+	if (!(budget > 0)) throw new Error(`the grace of the pod (${grace} ms) is not longer than its preStop sleep (${preStop} ms)`);
+	const part = (thirtieths) => s(Math.floor(budget * thirtieths / 30) / 1e3);
+	return {
+		phases: KUBERNETES_SHARES.map(([name, thirtieths]) => phase(name, part(thirtieths))),
+		cooperativeWindow: part(KUBERNETES_WINDOW),
+		cooperativeFloor: "half",
+		onRepeatSignal: "ignore"
+	};
+};
+//#endregion
+//#region src/units.ts
+/** This function gives the cause of an abort as text. */
+const causeOf = (signal) => signal.reason instanceof Error ? signal.reason.message : String(signal.reason ?? "the unit got an abort");
+/**
+* This function does one unit of work, and gives its end. With a request, the unit goes through
+* `life.request`, thus the service counts it, drains it and can cut it. A throw after the abort of
+* the transport is a cut, not a failure (S6 A10). A throw after the bound is a failure.
+*/
+const runUnit = async (run) => {
+	const { clock, bound, abort, life, request, unit, work } = run;
+	const timeout = new AbortController();
+	const cancel = Number.isFinite(bound) ? clock.after(bound, () => timeout.abort(/* @__PURE__ */ new Error(`the unit did not end in its unit_processing_time of ${bound} ms`))) : () => {};
+	const call = async (tracker) => work(AbortSignal.any(tracker === void 0 ? [abort.signal, timeout.signal] : [
+		abort.signal,
+		timeout.signal,
+		tracker
+	]));
+	const thrown = (error) => {
+		if (abort.signal.aborted) return {
+			kind: "cut",
+			cause: causeOf(abort.signal),
+			retryable: false
+		};
+		if (timeout.signal.aborted) return {
+			kind: "failed",
+			error: timeout.signal.reason
+		};
+		return {
+			kind: "failed",
+			error
+		};
+	};
+	try {
+		if (request === void 0) try {
+			return {
+				kind: "done",
+				value: await call()
+			};
+		} catch (error) {
+			return thrown(error);
+		}
+		let collected;
+		try {
+			const route = typeof request.route === "string" ? request.route : request.route(unit);
+			const detail = request.detail?.(unit);
+			collected = life.request(request.controller, route, (signal) => call(signal).then((value) => ({ value })), detail === void 0 ? {} : { detail }).collect();
+		} catch (error) {
+			return {
+				kind: "failed",
+				error
+			};
+		}
+		const { items, end } = await collected;
+		if (end.kind === "done") return {
+			kind: "done",
+			value: items[0]?.value
+		};
+		if (end.kind === "failed") return thrown(end.error);
+		if (end.kind === "refused") return {
+			kind: "refused",
+			cause: end.cause
+		};
+		return {
+			kind: "cut",
+			cause: end.cause,
+			retryable: end.retryable
+		};
+	} finally {
+		cancel();
+	}
+};
+/** This function makes a flight set on a clock. */
+const flights = (clock) => {
+	const units = /* @__PURE__ */ new Set();
+	const idle = /* @__PURE__ */ new Set();
+	const lower = /* @__PURE__ */ new Set();
+	let aborted = null;
+	const settle = () => {
+		for (const done of [...lower]) done();
+		lower.clear();
+		if (units.size === 0) for (const done of [...idle]) done();
+	};
+	const abort = (reason) => {
+		aborted ??= { reason };
+		for (const unit of [...units]) if (!unit.signal.aborted) unit.abort(aborted.reason);
+	};
+	return {
+		get size() {
+			return units.size;
+		},
+		add(unit) {
+			units.add(unit);
+			if (aborted !== null && !unit.signal.aborted) unit.abort(aborted.reason);
+			return () => {
+				if (units.delete(unit)) settle();
+			};
+		},
+		abort,
+		clear() {
+			units.clear();
+			settle();
+		},
+		drain(deadline, signal) {
+			const cooperative = () => abort(signal.reason);
+			if (signal.aborted) cooperative();
+			else signal.addEventListener("abort", cooperative, { once: true });
+			if (units.size === 0 || deadline <= clock.now()) {
+				signal.removeEventListener("abort", cooperative);
+				return Promise.resolve();
+			}
+			return new Promise((resolve) => {
+				let cancel = () => {};
+				const done = () => {
+					idle.delete(done);
+					cancel();
+					signal.removeEventListener("abort", cooperative);
+					resolve();
+				};
+				idle.add(done);
+				cancel = clock.after(Math.max(0, deadline - clock.now()), done);
+			});
+		},
+		less() {
+			return new Promise((resolve) => lower.add(resolve));
+		},
+		release() {
+			for (const done of [...lower]) done();
+			lower.clear();
+		}
+	};
+};
+/** This function makes a sleeper on a clock. */
+const sleeper = (clock) => {
+	let wakes = 0;
+	let stopped = false;
+	const sleeps = /* @__PURE__ */ new Set();
+	const backoffs = /* @__PURE__ */ new Set();
+	const wait = (ms, into) => stopped ? Promise.resolve() : new Promise((resolve) => {
+		let cancel = () => {};
+		const done = () => {
+			if (!into.delete(done)) return;
+			cancel();
+			resolve();
+		};
+		into.add(done);
+		if (Number.isFinite(ms)) cancel = clock.after(ms, done);
+	});
+	return {
+		get wakes() {
+			return wakes;
+		},
+		sleep(ms, since) {
+			if (since !== wakes) return Promise.resolve();
+			return wait(ms, sleeps);
+		},
+		backoff(ms) {
+			return wait(ms, backoffs);
+		},
+		wake() {
+			wakes += 1;
+			const ended = sleeps.size;
+			for (const done of [...sleeps]) done();
+			return ended;
+		},
+		stop() {
+			stopped = true;
+			for (const done of [...sleeps, ...backoffs]) done();
+		}
+	};
+};
+/** This function waits for a work until a bound on the clock, in milliseconds. */
+const settleWithin = (clock, ms, work) => new Promise((resolve) => {
+	const cancel = Number.isFinite(ms) ? clock.after(ms, () => resolve({ kind: "bound" })) : () => {};
+	work.then(() => {
+		cancel();
+		resolve({ kind: "done" });
+	}, (error) => {
+		cancel();
+		resolve({
+			kind: "failed",
+			error
+		});
+	});
+});
+/**
+* This function gives the backoff of the knobs of a loop. The first delay is `retry_base`, and each
+* delay is two times longer, up to `retry_cap`. Each delay has a jitter up to the base, as in the Redis client.
+*/
+const retryOf = (knobs, owner) => {
+	const base = boundedMillisecondsOf(knobs, "retry_base", owner);
+	const backoff = {
+		base,
+		factor: 2,
+		cap: boundedMillisecondsOf(knobs, "retry_cap", owner),
+		jitter: {
+			kind: "add",
+			amount: base
+		}
+	};
+	const problems = backoffProblems(backoff);
+	if (problems.length > 0) throw new Error(`${owner}: the retry_base and retry_cap give no backoff: ${problems.join(", ")}`);
+	return backoff;
+};
+/**
+* This function gives the problems of the bounds of a loop in a declaration. The close bound fits
+* in the cap of `close transports`. The bound of a unit fits in the cap of `drain`, or the drain can cut a unit (S6 A10).
+*/
+const boundProblems = (owner, closeBound, unitBound, description) => {
+	const capOf = (name) => {
+		const phase = description.shutdown.phases.find((each) => each.name === name);
+		return phase === void 0 ? void 0 : valueIn(phase.cap, "ms");
+	};
+	const found = [];
+	const close = capOf("close transports");
+	if (close === void 0) found.push(`${owner} needs the phase "close transports" to close`);
+	else if (closeBound >= close) found.push(`the close_bound of ${owner}, ${closeBound} ms, does not fit in the cap of "close transports", ${close} ms`);
+	const drain = capOf("drain");
+	if (drain === void 0) found.push(`${owner} needs the phase "drain" to end its units`);
+	else if (!Number.isFinite(unitBound)) found.push(`the unit_processing_time of ${owner} has no bound, thus the drain can cut a unit at its cap of ${drain} ms`);
+	else if (unitBound >= drain) found.push(`the unit_processing_time of ${owner}, ${unitBound} ms, does not fit in the cap of "drain", ${drain} ms`);
+	return found;
+};
+//#endregion
+//#region src/worker.ts
+const OWNER$1 = "workerLoop";
+/**
+* This function makes a worker loop as a transport (S6 A10). It has a setup, an iteration and a
+* teardown, and each lane does its iterations one at a time.
+* - The start does the setup. A failed setup gets its teardown, and the start throws.
+* - The first iteration of each lane comes after the startup ends. Each sleep and each backoff is on the clock.
+* - `stopIntake` starts no new iteration, and it ends each sleep and each backoff.
+* - `drain` waits for each iteration in flight until the deadline, and gives it the cooperative
+*   abort. A throw after that abort is not a failure.
+* - `close` aborts each iteration, waits for its end, and does the teardown, all in `close_bound`.
+*/
+const workerLoop = (knobs, options) => {
+	const sleep = millisecondsOf(knobs, "worker_sleep", OWNER$1);
+	const bound = millisecondsOf(knobs, "unit_processing_time", OWNER$1);
+	const backoff = retryOf(knobs, OWNER$1);
+	const closeBound = boundedMillisecondsOf(knobs, "close_bound", OWNER$1);
+	const lanes = countOf(knobs, "concurrency", OWNER$1);
+	if (!Number.isFinite(lanes)) throw new Error(`${OWNER$1} needs a concurrency with a bound: each lane is a loop`);
+	const clock = options.clock ?? realClock;
+	const random = options.random ?? Math.random;
+	const running = flights(clock);
+	const rests = sleeper(clock);
+	const intake = new AbortController();
+	const pending = /* @__PURE__ */ new Set();
+	let started = false;
+	let setup = null;
+	let state;
+	let tornDown = null;
+	let closing = null;
+	const report = (error, failures) => {
+		try {
+			options.onError?.(error, failures);
+		} catch {}
+	};
+	/** This function does the teardown one time, after the setup ends, and only when the setup started. */
+	const teardown = () => {
+		if (tornDown !== null) return tornDown;
+		const release = options.teardown;
+		const made = setup;
+		tornDown = made === null || release === void 0 ? Promise.resolve() : made.then((given) => release(given), () => release(void 0));
+		return tornDown;
+	};
+	const keep = (work) => {
+		pending.add(work);
+		const forget = () => {
+			pending.delete(work);
+		};
+		work.then(forget, forget);
+		return work;
+	};
+	/** This function is one lane: an iteration, then its sleep or its backoff, until the intake stops. */
+	const lane = async (index, life) => {
+		let failures = 0;
+		let since = rests.wakes;
+		await rests.sleep(0, since);
+		for (;;) {
+			if (intake.signal.aborted) return;
+			since = rests.wakes;
+			const abort = new AbortController();
+			const remove = running.add(abort);
+			const count = failures;
+			const end = await runUnit({
+				clock,
+				bound,
+				abort,
+				life,
+				request: options.request,
+				unit: index,
+				work: (signal) => keep((async () => options.iteration({
+					signal,
+					intake: intake.signal,
+					state,
+					lane: index,
+					failures: count,
+					life
+				}))())
+			});
+			remove();
+			if (end.kind === "cut") return;
+			if (end.kind === "done") {
+				failures = 0;
+				await rests.sleep(end.value === "more" ? 0 : sleep, end.value === "more" ? rests.wakes : since);
+				continue;
+			}
+			failures += 1;
+			report(end.kind === "failed" ? end.error : /* @__PURE__ */ new Error(`the service refused the iteration: ${end.cause}`), failures);
+			await rests.backoff(backoffDelay(backoff, failures, random));
+		}
+	};
+	return {
+		knobs: { ...knobs },
+		async start(signal, life) {
+			if (closing !== null) throw new Error(`${OWNER$1}: a closed loop does not start again`);
+			if (started) throw new Error(`${OWNER$1}: the loop started already`);
+			started = true;
+			const make = options.setup;
+			setup = make === void 0 ? Promise.resolve(void 0) : new Promise((resolve) => resolve(make(signal)));
+			try {
+				await setup.then((given) => {
+					state = given;
+				});
+			} catch (error) {
+				await settleWithin(clock, closeBound, teardown());
+				throw error;
+			}
+			life.started.then(() => {
+				if (intake.signal.aborted || life.state !== "running") return;
+				for (let index = 0; index < lanes; index += 1) lane(index, life).catch((error) => report(error, 0));
+			});
+		},
+		stopIntake() {
+			if (intake.signal.aborted) return;
+			intake.abort(/* @__PURE__ */ new Error(`${OWNER$1} stopped its intake`));
+			rests.stop();
+		},
+		drain(deadline, signal) {
+			return running.drain(deadline, signal);
+		},
+		inFlight: () => running.size,
+		wake() {
+			if (intake.signal.aborted) return false;
+			rests.wake();
+			return true;
+		},
+		close() {
+			if (closing !== null) return closing;
+			if (!intake.signal.aborted) intake.abort(/* @__PURE__ */ new Error(`${OWNER$1} closed`));
+			rests.stop();
+			running.abort(/* @__PURE__ */ new Error(`${OWNER$1} closed`));
+			running.clear();
+			closing = (async () => {
+				const began = clock.now();
+				const ended = await settleWithin(clock, closeBound, Promise.allSettled([...pending]));
+				const down = await settleWithin(clock, Math.max(0, closeBound - (clock.now() - began)), teardown());
+				if (ended.kind === "bound") throw new Error(`${OWNER$1}: an iteration did not end in the close_bound of ${closeBound} ms after its abort`);
+				if (down.kind === "failed") throw down.error;
+				if (down.kind === "bound") throw new Error(`${OWNER$1}: the teardown did not end in the close_bound of ${closeBound} ms`);
+			})();
+			return closing;
+		},
+		problems(description) {
+			return boundProblems(OWNER$1, closeBound, bound, description);
+		}
+	};
+};
+//#endregion
+//#region src/queue.ts
+/**
+* This function gives the redelivery policy of S6 A11. A poison message gets `ack`. Each other job
+* goes back on the queue after its first failure, one time. After a later failure, `then` gives the
+* action: the declared policy of the queue.
+*/
+const redeliverOnce = (then, poison) => (failure) => {
+	if (poison?.(failure.error, failure.job) === true) return "ack";
+	if (failure.delivery <= 1) return "requeue";
+	return typeof then === "function" ? then(failure) : then;
+};
+const OWNER = "queueDrain";
+const ACTIONS = [
+	"requeue",
+	"reject",
+	"ack"
+];
+const STOPPED = Symbol("the intake stopped");
+const isAsyncIterable = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.asyncIterator] === "function";
+/**
+* This function makes a queue drain as a transport (S6 A11). One taker takes the jobs from the
+* source while a slot is free, and each job operates in its slot.
+* - A success gets `ack`. A failure gets the action of the redelivery policy.
+* - `stopIntake` takes no new job, and a job that the drain took and did not start goes back (`requeue`, `unstarted`).
+* - `drain` waits for each job in flight until the deadline, and gives it the cooperative abort.
+* - `close` aborts each job, waits for its end, and closes the source, all in `close_bound`. A job
+*   that does not end in the bound gets `reject`.
+*/
+const queueDrain = (knobs, options) => {
+	const poll = millisecondsOf(knobs, "queue_poll_interval", OWNER);
+	const bound = millisecondsOf(knobs, "unit_processing_time", OWNER);
+	const backoff = retryOf(knobs, OWNER);
+	const closeBound = boundedMillisecondsOf(knobs, "close_bound", OWNER);
+	const concurrency = countOf(knobs, "concurrency", OWNER);
+	const { settle } = options;
+	const clock = options.clock ?? realClock;
+	const random = options.random ?? Math.random;
+	const running = flights(clock);
+	const rests = sleeper(clock);
+	const intake = new AbortController();
+	const stopped = new Promise((resolve) => intake.signal.addEventListener("abort", () => resolve(STOPPED), { once: true }));
+	const pending = /* @__PURE__ */ new Set();
+	const active = /* @__PURE__ */ new Set();
+	let refusals = 0;
+	let pausedUntil = Number.NEGATIVE_INFINITY;
+	let cancelSource = () => {};
+	let started = false;
+	let closing = null;
+	const report = (error, job) => {
+		try {
+			options.onError?.(error, job);
+		} catch {}
+	};
+	const keep = (work) => {
+		pending.add(work);
+		const forget = () => {
+			pending.delete(work);
+		};
+		work.then(forget, forget);
+	};
+	/** This function tells the queue the end of a job, one time. A throw of the queue is a failure. */
+	const once = async (unit, tell) => {
+		if (unit.settled) return;
+		unit.settled = true;
+		try {
+			await tell();
+		} catch (error) {
+			report(error, unit.job);
+		}
+	};
+	const handBack = (job) => keep((async () => {
+		try {
+			await settle.requeue(job, "unstarted");
+		} catch (error) {
+			report(error, job);
+		}
+	})());
+	/** This function gives the action of the policy for a failed job. A policy that throws, or that gives no action, rejects the job. */
+	const actionOf = (job, error, delivery) => {
+		try {
+			const action = options.redelivery({
+				job,
+				error,
+				delivery
+			});
+			if (ACTIONS.includes(action)) return action;
+			report(/* @__PURE__ */ new Error(`the redelivery policy gave ${String(action)}, not requeue, reject or ack`), job);
+		} catch (thrown) {
+			report(thrown, job);
+		}
+		return "reject";
+	};
+	const settleEnd = (unit, end, delivery) => {
+		const { job } = unit;
+		if (end.kind === "done") return once(unit, () => settle.ack(job));
+		if (end.kind === "refused") {
+			report(/* @__PURE__ */ new Error(`the service refused the job: ${end.cause}`), job);
+			return once(unit, () => settle.requeue(job, "unstarted"));
+		}
+		if (end.kind === "cut") {
+			if (end.retryable) return once(unit, () => settle.requeue(job, "cut"));
+			const cut = new Error(end.cause);
+			return once(unit, () => settle.reject(job, cut));
+		}
+		const { error } = end;
+		report(error, job);
+		const action = actionOf(job, error, delivery);
+		if (action === "requeue") return once(unit, () => settle.requeue(job, "failed"));
+		return once(unit, () => action === "ack" ? settle.ack(job) : settle.reject(job, error));
+	};
+	/** This function starts one job in a slot. The slot stays in flight until the queue has the end of the job. */
+	const runJob = (job, life) => {
+		const unit = {
+			job,
+			settled: false
+		};
+		active.add(unit);
+		const abort = new AbortController();
+		const remove = running.add(abort);
+		let delivery;
+		try {
+			delivery = settle.delivery(job);
+		} catch (error) {
+			report(error, job);
+			delivery = Number.POSITIVE_INFINITY;
+		}
+		keep((async () => {
+			const end = await runUnit({
+				clock,
+				bound,
+				abort,
+				life,
+				request: options.request,
+				unit: job,
+				work: (signal) => options.handle(job, {
+					signal,
+					intake: intake.signal,
+					delivery,
+					life
+				})
+			});
+			if (end.kind === "refused") {
+				refusals += 1;
+				pausedUntil = clock.now() + backoffDelay(backoff, refusals, random);
+			} else refusals = 0;
+			await settleEnd(unit, end, delivery);
+		})().finally(() => {
+			active.delete(unit);
+			remove();
+		}));
+	};
+	/** This function gives the take of the source. */
+	const takeOf = () => {
+		const source = options.source;
+		if (isAsyncIterable(source)) {
+			const iterator = source[Symbol.asyncIterator]();
+			cancelSource = () => {
+				try {
+					Promise.resolve(iterator.return?.()).catch(() => {});
+				} catch {}
+			};
+			return async () => {
+				const step = await iterator.next();
+				return step.done === true ? { kind: "end" } : {
+					kind: "job",
+					job: step.value
+				};
+			};
+		}
+		const pull = source;
+		return () => new Promise((resolve) => resolve(pull(intake.signal))).then((job) => job === null || job === void 0 ? { kind: "none" } : {
+			kind: "job",
+			job
+		});
+	};
+	/** This function is the taker: it takes a job while a slot is free, until the intake stops or the source ends. */
+	const taker = async (life) => {
+		const take = takeOf();
+		let failures = 0;
+		for (;;) {
+			if (intake.signal.aborted) return;
+			if (running.size >= concurrency) {
+				await running.less();
+				continue;
+			}
+			const pause = pausedUntil - clock.now();
+			if (pause > 0) {
+				await rests.backoff(pause);
+				continue;
+			}
+			const since = rests.wakes;
+			const taking = take().catch((error) => ({
+				kind: "error",
+				error
+			}));
+			const first = await Promise.race([taking, stopped]);
+			if (first === STOPPED || intake.signal.aborted) {
+				if (first === STOPPED) taking.then((late) => {
+					if (late.kind === "job") handBack(late.job);
+				});
+				else if (first.kind === "job") handBack(first.job);
+				return;
+			}
+			if (first.kind === "error") {
+				failures += 1;
+				report(first.error, void 0);
+				await rests.backoff(backoffDelay(backoff, failures, random));
+				continue;
+			}
+			failures = 0;
+			if (first.kind === "end") {
+				report(/* @__PURE__ */ new Error(`the source of ${OWNER} ended while its intake was open: it takes no more jobs`), void 0);
+				return;
+			}
+			if (first.kind === "none") {
+				await rests.sleep(poll, since);
+				continue;
+			}
+			runJob(first.job, life);
+		}
+	};
+	const stopTaking = (cause) => {
+		if (intake.signal.aborted) return;
+		intake.abort(new Error(cause));
+		rests.stop();
+		running.release();
+		cancelSource();
+	};
+	return {
+		knobs: { ...knobs },
+		start(_signal, life) {
+			if (closing !== null) throw new Error(`${OWNER}: a closed drain does not start again`);
+			if (started) throw new Error(`${OWNER}: the drain started already`);
+			started = true;
+			life.started.then(() => {
+				if (intake.signal.aborted || life.state !== "running") return;
+				taker(life).catch((error) => report(error, void 0));
+			});
+		},
+		stopIntake() {
+			stopTaking(`${OWNER} stopped its intake`);
+		},
+		drain(deadline, signal) {
+			return running.drain(deadline, signal);
+		},
+		inFlight: () => running.size,
+		wake() {
+			if (intake.signal.aborted) return false;
+			rests.wake();
+			return true;
+		},
+		close() {
+			if (closing !== null) return closing;
+			stopTaking(`${OWNER} closed`);
+			running.abort(/* @__PURE__ */ new Error(`${OWNER} closed`));
+			running.clear();
+			closing = (async () => {
+				const began = clock.now();
+				const ended = await settleWithin(clock, closeBound, Promise.allSettled([...pending]));
+				if (ended.kind === "bound") for (const unit of [...active]) once(unit, () => settle.reject(unit.job, /* @__PURE__ */ new Error(`${OWNER} closed with the job in flight`)));
+				const shut = options.close;
+				const down = await settleWithin(clock, Math.max(0, closeBound - (clock.now() - began)), shut === void 0 ? Promise.resolve() : (async () => shut())());
+				if (ended.kind === "bound") throw new Error(`${OWNER}: a job did not end in the close_bound of ${closeBound} ms after its abort`);
+				if (down.kind === "failed") throw down.error;
+				if (down.kind === "bound") throw new Error(`${OWNER}: the close of the source did not end in the close_bound of ${closeBound} ms`);
+			})();
+			return closing;
+		},
+		problems(description) {
+			return boundProblems(OWNER, closeBound, bound, description);
+		}
+	};
+};
+//#endregion
 //#region src/machines.ts
 /**
 * The machines of the runtime as `mark1russell7.machine/1` documents. The documents are the
@@ -1728,7 +3052,9 @@ const POLLER_MACHINE = {
 };
 /**
 * The exit manager is the only part that ends the process. The first exit request starts the
-* shutdown, and a later one has no effect. An error makes the exit code 1.
+* shutdown. A later request has no effect, but a repeat signal exits at once when the declaration
+* says `onRepeatSignal: "exit"`. The exit code is the code of the exit request, else 1 after an
+* error, else 0.
 */
 const EXIT_MACHINE = {
 	...base("exit", "The exit manager"),
@@ -1740,23 +3066,35 @@ const EXIT_MACHINE = {
 	events: {
 		"exit.request": {
 			kind: "app",
-			note: "SIGINT, SIGTERM, SIGQUIT or shutdown()"
+			note: "SIGINT, SIGTERM, SIGQUIT, a declared process trigger or shutdown()"
+		},
+		"exit.repeat": {
+			kind: "app",
+			note: "a trigger or shutdown() while the shutdown runs"
 		},
-		"exit.repeat": { kind: "app" },
 		"startup.fail": { kind: "local" },
 		error: { kind: "local" },
 		"shutdown.done": { kind: "local" }
 	},
-	knobs: {},
+	knobs: { on_repeat_signal: {
+		key: "shutdown.onRepeatSignal",
+		scope: "service",
+		unit: null,
+		default: null
+	} },
 	timers: {},
 	transitions: [
 		t("request", "running", "exit.request", "stopping"),
 		t("startup-fail", "running", "startup.fail", "stopping"),
 		t("error-running", "running", "error", "running"),
-		t("repeat", "stopping", "exit.repeat", "stopping"),
+		t("repeat", "stopping", "exit.repeat", "stopping", { guard: "a process trigger or shutdown() repeats, or a signal repeats and on_repeat_signal is not exit" }),
+		t("repeat-exit", "stopping", "exit.repeat", "exited", {
+			guard: "a signal repeats and on_repeat_signal is exit",
+			note: "the process exits at once with the code 1"
+		}),
 		t("startup-fail-stopping", "stopping", "startup.fail", "stopping"),
 		t("error", "stopping", "error", "stopping"),
-		t("exit", "stopping", "shutdown.done", "exited", { note: "the exit code is 1 after an error, else 0" })
+		t("exit", "stopping", "shutdown.done", "exited", { note: "the exit code is the code of the exit request, else 1 after an error, else 0" })
 	]
 };
 /** A watchdog measures how late its own tick comes, and a late tick shows a blocked event loop. */
@@ -1807,7 +3145,8 @@ const capKnob = (phase) => `${phase.replace(/[^A-Za-z0-9]+/g, "_")}_cap`;
 /**
 * This function gives the drain of a declaration as a machine. It has one state for each declared
 * phase, in its sequence, and each state has a timer at its cap. The drain also has the cooperative abort: the
-* cap of the drain less the cooperative window, and half that cap at the least.
+* cap of the drain less the cooperative window. With the floor `half`, it is half that cap at the
+* least. With the floor `none`, it is 0 at the least.
 */
 const drainMachine = (description) => {
 	const phases = description.shutdown.phases;
@@ -1835,9 +3174,10 @@ const drainMachine = (description) => {
 		cancels: ["phase.done"],
 		fires: "phase.cap"
 	};
+	const floor = description.shutdown.cooperativeFloor === "none" ? "0" : "drain_cap / 2";
 	if (phases.some((phase) => phase.name === "drain")) timers["cooperative_abort"] = {
 		duration: {
-			expr: "max(drain_cap - cooperative_window, drain_cap / 2)",
+			expr: `max(drain_cap - cooperative_window, ${floor})`,
 			unit: "s"
 		},
 		arms: ["enter:drain"],
@@ -1885,6 +3225,6 @@ const MACHINES = {
 	watchdog: WATCHDOG_MACHINE
 };
 //#endregion
-export { EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, MACHINES, POLLER_MACHINE, SERVICE_RULES, STAGES, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, backoffBand, backoffDelay, backoffProblems, capKnob, cooperativeAbortAt, detectionTime, drainMachine, evaluate, failSpan, heartbeat, heartbeatDetection, inequalities, lint, mayReissue, nodeProcess, platformClock, realClock, recoverSpan, replay, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog };
+export { DECLARATION_RULE, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, MACHINES, POLLER_MACHINE, PROCESS_TRIGGERS, SERVICE_RULES, STAGES, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, backoffBand, backoffDelay, backoffProblems, capKnob, cooperativeAbortAt, daemon, detectionTime, drainMachine, ephemeral, evaluate, failSpan, heartbeat, heartbeatDetection, inequalities, isExitCode, isExitSignal, isMessageShape, kubernetes, lint, localDev, matchesMessage, mayReissue, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redeliverOnce, replay, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
 
 //# sourceMappingURL=index.js.map