@mark1russell7/service 0.5.9 → 0.5.11

package/build/index.js

@@ -431,7 +431,7 @@ const healthRuntime = (description, runs, options = {}) => {
 			if (kind === "liveness") return answer(kind, now.alive);
 			if (kind === "report") return answer(kind, now.ready && now.alive);
 			if (controller === void 0) return answer(kind, now.ready);
-			const known = now.controllers[controller];
+			const known = Object.hasOwn(now.controllers, controller) ? now.controllers[controller] : void 0;
 			if (known === void 0) throw new Error(`${description.name} has no controller ${controller}`);
 			return answer(kind, known, controller);
 		},
@@ -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";
@@ -1901,10 +2141,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 +2162,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 +2186,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
@@ -2296,229 +2542,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 +2729,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 +2883,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);