@mark1russell7/service 0.4.0 → 0.5.0

package/build/index.js

@@ -497,101 +497,398 @@ 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"];
+/** 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 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);
+			host.on(trigger, handler);
+			return () => {
+				host.off(trigger, handler);
+			};
+		},
+		async flush() {
+			const host = hostProcess();
+			await Promise.all([written(host.stdout), written(host.stderr)]);
+		},
+		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 = (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(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(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
 				};
-				flights.add(flight);
-				let promise;
+				return {
+					kind: "item",
+					value
+				};
+			}
+			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 +899,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 +914,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 +935,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 +946,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 +955,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 +985,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 +1004,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 +1019,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 +1034,36 @@ 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 = [];
+	/** This function ends the process with a code, one time, and removes each handler of a trigger. */
+	const end = (code, on) => {
+		state = "exited";
+		exitCode = code;
+		for (const off of offs) off();
+		offs = [];
+		moveExit("exited", on, `exit ${code}`);
+		finish(code);
+		port.exit(code);
+	};
+	/** This function receives a trigger of the process: the first one starts the shutdown. */
+	const triggered = (trigger) => {
+		if (exitState === "exited") return;
+		if (shutdownStarted || exitState === "stopping") {
+			if (isExitSignal(trigger) && repeatPolicy === "exit") {
+				fail(`${trigger} 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", trigger);
+			return;
 		}
-	})();
-	startup.then(() => {
-		if (failedStartup && !shutdownStarted) shutdown("the startup failed");
-	});
+		const code = exitCodes[trigger];
+		shutdown(trigger, code === void 0 ? {} : { code });
+	};
 	/** 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 +1093,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 +1124,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 +1141,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 +1162,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 +1203,51 @@ 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);
+	offs = [...EXIT_SIGNALS, ...description.shutdown.triggers ?? []].map((trigger) => port.on(trigger, () => 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
@@ -967,12 +1316,25 @@ const timingProblems = (policy, timing) => {
 	const negative = (amount) => amount !== void 0 && (!isTime(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) => {
+	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(", ")})`);
+	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 +1343,16 @@ const service = (name) => {
 	let liveness;
 	let startup;
 	let cooperative;
+	let floor;
+	let repeat;
+	const triggers = [];
+	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 +1421,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 +1448,8 @@ const service = (name) => {
 			const held = {
 				name: entry,
 				requires: [],
-				routes: {}
+				routes: {},
+				patterns: []
 			};
 			controllers.push(held);
 			const handle = {
@@ -1092,6 +1463,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 +1555,40 @@ 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");
+			for (const each of given) if (!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 [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 +1596,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 = [];
@@ -1195,16 +1616,22 @@ const service = (name) => {
 			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`);
+			problems.push(...shutdownProblems(floor, repeat, triggers, exitCodes));
 			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 +1659,11 @@ 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] },
+					...Object.keys(exitCodes).length === 0 ? {} : { exitCodes: { ...exitCodes } }
 				}
 			};
 		},
@@ -1253,7 +1684,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 +1691,7 @@ const service = (name) => {
 					dependencies: handles,
 					healthServer: probes,
 					phaseWork,
+					choices,
 					stopPollers: () => {}
 				};
 				const problems = lifecycleProblems(description, components);
@@ -1268,14 +1699,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;
 		}
 	};
@@ -1425,10 +1858,30 @@ const dependencyBindings = (dependency, scenario) => {
 	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. */
+/** 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: one time for the
+* service, and one time for each client. It 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);
@@ -1452,6 +1905,123 @@ 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/machines.ts
 /**
 * The machines of the runtime as `mark1russell7.machine/1` documents. The documents are the
@@ -1728,7 +2298,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 +2312,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 +2391,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 +2420,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 +2471,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, kubernetes, lint, localDev, mayReissue, nodeProcess, platformClock, processPortOf, realClock, recoverSpan, replay, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog };
 
 //# sourceMappingURL=index.js.map