@mark1russell7/service 0.5.10 → 0.5.12

package/build/index.js

@@ -720,6 +720,248 @@ const compilePattern = (pattern) => {
 	};
 };
 //#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 value of a promise, or `stop` when the signal aborts first. Each wait adds
+* its own listener, and removes it when the promise settles. A race against one pending promise
+* keeps each settled value until that promise ends.
+*/
+const untilAbort = (promise, signal, stop) => {
+	if (signal.aborted) return Promise.race([promise, Promise.resolve(stop)]);
+	return new Promise((resolve, reject) => {
+		const onAbort = () => resolve(stop);
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(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/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";
@@ -815,10 +1057,8 @@ const tracker = (controllers, clock, refuses, choices = /* @__PURE__ */ new Map(
 		let returned = false;
 		let source = null;
 		let unary = null;
-		let interrupt = () => {};
-		const interrupted = new Promise((resolve) => {
-			interrupt = () => resolve("interrupted");
-		});
+		const interruption = new AbortController();
+		const interrupt = () => interruption.abort();
 		const cutEnd = (cause) => {
 			const since = quantity(Math.max(0, clock.now() - started) / 1e3, "s");
 			const retryable = mayReissue(operation, since);
@@ -887,7 +1127,7 @@ const tracker = (controllers, clock, refuses, choices = /* @__PURE__ */ new Map(
 		}
 		const next = async () => {
 			if (ended) return null;
-			if (end === null) await Promise.race([ready, interrupted]);
+			if (end === null) await untilAbort(ready, interruption.signal, "interrupted");
 			if (end === null && unary !== null) {
 				const { value } = unary;
 				unary = null;
@@ -905,7 +1145,7 @@ const tracker = (controllers, clock, refuses, choices = /* @__PURE__ */ new Map(
 				const pending = source.next();
 				let step;
 				try {
-					step = await Promise.race([pending, interrupted]);
+					step = await untilAbort(Promise.resolve(pending), interruption.signal, "interrupted");
 				} catch (error) {
 					failed(error);
 					step = "interrupted";
@@ -1416,6 +1656,25 @@ const watchdog = (clock, spec, trace) => {
 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 copies a check, with its poll and the loops that mark it. */
+const copyCheck = (check) => ({
+	...check,
+	poll: { ...check.poll },
+	...check.marks === void 0 ? {} : { marks: {
+		loops: [...check.marks.loops],
+		stall: { ...check.marks.stall }
+	} }
+});
+/** This function gives the problems of the loops that mark a check. `lint()` compares the stall time with the loops. */
+const marksProblems = (check) => {
+	const marks = check.marks;
+	if (marks === void 0) return [];
+	const problems = [];
+	if (check.step !== "progress") problems.push(`check ${check.name} names the loops that mark it, but its step is ${check.step}, not progress`);
+	if (marks.loops.length === 0) problems.push(`check ${check.name} names no loop that marks it`);
+	if (typeof marks.stall.value !== "number" || !above(marks.stall)) problems.push(`check ${check.name} has a stall time that is not a time above zero`);
+	return problems;
+};
 /** This function gives the problems of a timing: a zero interval or count fails decoding. */
 const timingProblems = (policy, timing) => {
 	if (timing.type === "debounce") {
@@ -1604,14 +1863,11 @@ const service = (name) => {
 		check(check, run) {
 			once(checks, check.name, "check");
 			if (started && run === void 0) throw new Error(`check ${check.name} joins after the start, thus it needs its function`);
-			checks.push({ ...check });
+			checks.push(copyCheck(check));
 			if (run !== void 0) runs.set(check.name, run);
 			if (started) {
 				partial = true;
-				live?.addCheck({
-					...check,
-					poll: { ...check.poll }
-				}, run);
+				live?.addCheck(copyCheck(check), run);
 			}
 			return builder;
 		},
@@ -1749,6 +2005,7 @@ const service = (name) => {
 				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`);
+				problems.push(...marksProblems(check));
 				const timing = check.gates === null ? null : policies[check.gates];
 				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`);
 			}
@@ -1791,10 +2048,7 @@ const service = (name) => {
 					operations: { ...entry.operations }
 				})),
 				controllers: controllersOut,
-				checks: checks.map((entry) => ({
-					...entry,
-					poll: { ...entry.poll }
-				})),
+				checks: checks.map(copyCheck),
 				...limiters.length === 0 ? {} : { limiters: limiters.map((entry) => ({
 					...entry,
 					policy: { ...entry.policy },
@@ -1901,10 +2155,16 @@ const marginOf = (inequality, index, bind) => {
 	if (typeof bind.margin === "number") return bind.margin;
 	return typeof inequality.margin === "number" ? inequality.margin : 0;
 };
+/** This function tells if an inequality reads a symbol with no limit: "inf", "off" or an infinite number. */
+const readsAbsent = (inequality, bind) => [...inequality.lhs.terms, ...inequality.rhs.terms].some((term) => {
+	const bound = boundOf$1(bind, keyOf(term));
+	return bound !== void 0 && value(bound) === Infinity;
+});
 /**
 * This function evaluates each inequality on one binding. "<" holds when lhs + margin < rhs, and
 * ">" holds when lhs > rhs + margin. Only the inequalities with all their symbols bound apply.
-* The others are null.
+* The others are null. Absent timers can leave no order: the same infinity on each side, or both
+* signs of infinity on one side. Then the inequality holds only because a timer is absent.
 */
 const evaluate = (rule, bind) => inequalities(rule).map((inequality, index) => {
 	const lhs = sideOf(inequality.lhs, bind);
@@ -1916,6 +2176,12 @@ const evaluate = (rule, bind) => inequalities(rule).map((inequality, index) => {
 		margin,
 		holds: null
 	};
+	if ((Number.isNaN(lhs) || Number.isNaN(rhs) || lhs === rhs && !Number.isFinite(lhs)) && readsAbsent(inequality, bind)) return {
+		lhs,
+		rhs,
+		margin,
+		holds: true
+	};
 	return {
 		lhs,
 		rhs,
@@ -1934,13 +2200,7 @@ const verdictOf = (rule, bind, evaluated) => {
 	if (applicable.length === 0) return "depends";
 	if (applicable.some((index) => evaluated[index]?.holds === false)) return "violated";
 	const all = inequalities(rule);
-	return applicable.some((index) => {
-		const inequality = all[index];
-		return [...inequality.lhs.terms, ...inequality.rhs.terms].some((term) => {
-			const bound = boundOf$1(bind, keyOf(term));
-			return bound !== void 0 && value(bound) === Infinity;
-		});
-	}) ? "unbounded" : "holds";
+	return applicable.some((index) => readsAbsent(all[index], bind)) ? "unbounded" : "holds";
 };
 //#endregion
 //#region src/lint.ts
@@ -2139,14 +2399,144 @@ const declarationFindings = (svc) => svc.shutdown.onRepeatSignal === void 0 ? [{
 	evaluated: [],
 	unbound: ["shutdown.onRepeatSignal"]
 }] : [];
+/** This identifier is the rule of the findings about the stall time of a progress check (`Check.marks`). */
+const PROGRESS_RULE = "progress";
+/**
+* This rule compares the stall time of a progress check with the longest gap between two marks of
+* the slowest loop that it names. A shorter stall time trips the check while each loop turns on time.
+*/
+const PROGRESS_LAW = {
+	id: PROGRESS_RULE,
+	rule: "the stall time of a progress check is at least the longest gap between two marks of the slowest loop that it names",
+	window: "a loop that turns on time can trip the check",
+	expr: {
+		lhs: { terms: [{
+			knob: "stall",
+			coef: 1,
+			at: "check"
+		}] },
+		op: ">=",
+		rhs: { terms: [{
+			knob: "mark_gap",
+			coef: 1,
+			at: "loop"
+		}] },
+		margin: 0
+	}
+};
+/** These are the knobs of a worker that bound the gap between two of its marks. */
+const WORKER_GAP_KNOBS = [
+	"worker_sleep",
+	"unit_processing_time",
+	"retry_base",
+	"retry_cap"
+];
+/**
+* This function gives the longest gap between two marks of each loop with a name. The rule counts
+* a mark at the end of each turn of the loop, also a turn that fails.
+* - A check polls on a fixed delay from the start of each poll, and each poll ends at its timeout
+*   at the latest. Thus the gap is `interval × (1 + jitter) + timeout`.
+* - After an iteration, a lane of a worker waits its sleep, or its backoff after a failure. The
+*   longest backoff is `retry_cap` plus its jitter of up to `retry_base`. The next iteration then
+*   takes up to `unit_processing_time`. Thus the gap is the longer wait plus that bound.
+*
+* A sleep or a bound without a limit gives a gap without a limit. An iteration that does not end
+* at its abort can take more time, and the rule does not bound it.
+*/
+const gapsOf = (svc, loop) => {
+	const gaps = svc.checks.filter((check) => check.name === loop).map((check) => ({
+		loop,
+		seconds: secondsOf(check.poll.interval) * (1 + check.poll.jitter) + secondsOf(check.poll.timeout),
+		unbound: []
+	}));
+	for (const worker of svc.transports) {
+		if (worker.kind !== "worker" || worker.name !== loop) continue;
+		const knob = (name) => {
+			const amount = worker.knobs[name];
+			if (amount === void 0 || !isTime(amount.unit)) return void 0;
+			return amount.value === "infinite" ? Infinity : secondsOf(amount);
+		};
+		const unbound = WORKER_GAP_KNOBS.filter((name) => knob(name) === void 0).map((name) => `${loop}.${name}`);
+		if (unbound.length > 0) {
+			gaps.push({
+				loop,
+				seconds: void 0,
+				unbound
+			});
+			continue;
+		}
+		const [sleep, unit, base, cap] = WORKER_GAP_KNOBS.map((name) => knob(name));
+		const backoff = Number.isFinite(base) && Number.isFinite(cap) ? backoffBand({
+			base,
+			factor: 2,
+			cap,
+			jitter: {
+				kind: "add",
+				amount: base
+			}
+		}).high : Infinity;
+		gaps.push({
+			loop,
+			seconds: Math.max(sleep, backoff) + unit,
+			unbound: []
+		});
+	}
+	return gaps;
+};
+/**
+* This function gives the findings of each check that names the loops that mark it. A name that is
+* not a check or a worker of the service gets a finding of its own, with the verdict `depends`.
+* Without `marks`, a check gets no finding.
+*/
+const progressFindings = (svc) => {
+	const findings = [];
+	const finding = (check, fields) => ({
+		rule: PROGRESS_RULE,
+		scope: check.name,
+		statement: PROGRESS_LAW.rule,
+		window: PROGRESS_LAW.window,
+		...fields
+	});
+	for (const check of svc.checks) {
+		const marks = check.marks;
+		if (marks === void 0) continue;
+		const gaps = [];
+		for (const loop of marks.loops) {
+			const found = gapsOf(svc, loop);
+			if (found.length > 0) gaps.push(...found);
+			else findings.push(finding(check, {
+				verdict: "depends",
+				statement: "each loop that a progress check names is a check or a worker of the service",
+				window: `the check waits for the marks of ${loop}, and the service has no loop with that name`,
+				evaluated: [],
+				unbound: [loop]
+			}));
+		}
+		if (gaps.length === 0) continue;
+		const unbound = [...isTime(marks.stall.unit) ? [] : [`${check.name}.marks.stall`], ...gaps.flatMap((gap) => gap.unbound)];
+		const slowest = gaps.reduce((worst, gap) => (gap.seconds ?? -Infinity) > (worst.seconds ?? -Infinity) ? gap : worst);
+		const bind = {};
+		if (isTime(marks.stall.unit)) bind["stall@check"] = boundOf(marks.stall);
+		if (unbound.length === 0 && slowest.seconds !== void 0) bind["mark_gap@loop"] = Number.isFinite(slowest.seconds) ? slowest.seconds : "inf";
+		const evaluated = evaluate(PROGRESS_LAW, bind);
+		findings.push(finding(check, {
+			verdict: verdictOf(PROGRESS_LAW, bind, evaluated),
+			...unbound.length === 0 ? { statement: `${PROGRESS_LAW.rule} (${slowest.loop})` } : {},
+			evaluated,
+			unbound
+		}));
+	}
+	return findings;
+};
 /**
 * This function applies each service rule to a declaration and a scenario. A rule applies one time
 * for the service, for each client, for each consumer and worker, or for each limiter. The function
 * also gives a finding for each necessary field that the description does not give (`DECLARATION_RULE`).
+* Each progress check that names its loops also gets its findings (`PROGRESS_RULE`).
 */
 const lint = (svc, scenario, rules) => {
 	const service = serviceBindings(svc, scenario).bind;
-	const findings = [...declarationFindings(svc)];
+	const findings = [...declarationFindings(svc), ...progressFindings(svc)];
 	for (const rule of rules) {
 		if (!SERVICE_RULES.includes(rule.id)) continue;
 		const symbols = symbolsOf(rule);
@@ -2296,229 +2686,6 @@ const kubernetes = (pod) => {
 	};
 };
 //#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";
 /**
@@ -2706,7 +2873,6 @@ const queueDrain = (knobs, options) => {
 	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;
@@ -2861,7 +3027,7 @@ const queueDrain = (knobs, options) => {
 				kind: "error",
 				error
 			}));
-			const first = await Promise.race([taking, stopped]);
+			const first = await untilAbort(taking, intake.signal, STOPPED);
 			if (first === STOPPED || intake.signal.aborted) {
 				if (first === STOPPED) taking.then((late) => {
 					if (late.kind === "job") handBack(late.job);
@@ -3389,6 +3555,6 @@ const MACHINES = {
 	watchdog: WATCHDOG_MACHINE
 };
 //#endregion
-export { DECLARATION_RULE, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LIMITER_RULES, MACHINES, POLLER_MACHINE, PROCESS_TRIGGERS, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, TOKEN_BUCKET_MACHINE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, backoffBand, backoffDelay, backoffProblems, capKnob, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, localDev, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
+export { DECLARATION_RULE, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LIMITER_RULES, MACHINES, POLLER_MACHINE, PROCESS_TRIGGERS, PROGRESS_RULE, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, TOKEN_BUCKET_MACHINE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, backoffBand, backoffDelay, backoffProblems, capKnob, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, localDev, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
 
 //# sourceMappingURL=index.js.map