@mark1russell7/service 0.5.11 → 0.5.13

package/build/{lifecycle-CGEegMI0.d.ts → lifecycle-fgYfxrHK.d.ts}

@@ -255,6 +255,21 @@ interface Check {
   /** This gate is the policy that it controls, or null for a check that only reports. It has no default. */
   readonly gates: Gate | null;
   readonly poll: Poll;
+  /**
+   * These are the loops that mark the progress of a check of the step `progress`, and its stall
+   * time. Without a declaration, the check names no loops, and `lint()` does not compare its stall time.
+   */
+  readonly marks?: ProgressMarks | undefined;
+}
+/**
+ * A progress mark declaration tells which loops mark the progress of a check, and how long the
+ * check waits for a mark. The check function fails when no loop marked in the stall time.
+ */
+interface ProgressMarks {
+  /** These are the names of the loops: a check (its poller) or a worker of the service. */
+  readonly loops: readonly string[];
+  /** This time is the most time from one mark to the next before the check fails. */
+  readonly stall: Quantity;
 }
 /**
  * A dependency is something that the service uses, with its client. Its knobs have the names that
@@ -701,5 +716,5 @@ interface Lifecycle {
   keepAlive(): boolean;
 }
 //#endregion
-export { failSpan as $, LifecycleEvent as A, Gate as B, ProbeAnswer as C, Operation as Ct, Outcome as D, CheckFn as E, CooperativeFloor as F, Step as G, Phase as H, Coupling as I, Poll as J, Transport as K, Dependency as L, Recorder as M, Check as N, Result as O, Controller as P, asWindow as Q, ExitCodes as R, HealthVerdict as S, Idempotency as St, StartOptions as T, RepeatSignal as U, MessageTrigger as V, ServiceDescription as W, Timing as X, Span as Y, asDebounce as Z, RequestOptions as _, isExitSignal as _t, PhaseContext as a, EXIT_SIGNALS as at, CheckVerdict as b, nodeProcess as bt, STAGES as c, ExitTrigger as ct, TransportImpl as d, PROCESS_TRIGGERS as dt, heartbeatDetection as et, cooperativeAbortAt as f, ProcessHost as ft, RequestFn as g, isExitCode as gt, RequestEvent as h, embeddedProcess as ht, LifecycleState as i, RouteRequest as it, MachineName as j, Trace as k, ShutdownOptions as l, HostStream as lt, RequestEnd as m, ProcessTrigger as mt, HealthServer as n, OperationOf as nt, PhaseWork as o, EmbeddedProcess as ot, stageRank as p, ProcessPort as pt, FailsBy as q, Lifecycle as r, RoutePattern as rt, RunOptions as s, ExitSignal as st, DependencyHandle as t, recoverSpan as tt, Stage as u, MessageShape as ut, RequestStream as v, isMessageShape as vt, ProbeKind as w, mayReissue as wt, Health as x, processPortOf as xt, RequestWork as y, matchesMessage as yt, FORMAT as z };
-//# sourceMappingURL=lifecycle-CGEegMI0.d.ts.map
+export { asWindow as $, LifecycleEvent as A, Gate as B, ProbeAnswer as C, Idempotency as Ct, Outcome as D, CheckFn as E, CooperativeFloor as F, ServiceDescription as G, Phase as H, Coupling as I, FailsBy as J, Step as K, Dependency as L, Recorder as M, Check as N, Result as O, Controller as P, asDebounce as Q, ExitCodes as R, HealthVerdict as S, processPortOf as St, StartOptions as T, mayReissue as Tt, ProgressMarks as U, MessageTrigger as V, RepeatSignal as W, Span as X, Poll as Y, Timing as Z, RequestOptions as _, isExitCode as _t, PhaseContext as a, RouteRequest as at, CheckVerdict as b, matchesMessage as bt, STAGES as c, ExitSignal as ct, TransportImpl as d, MessageShape as dt, failSpan as et, cooperativeAbortAt as f, PROCESS_TRIGGERS as ft, RequestFn as g, embeddedProcess as gt, RequestEvent as h, ProcessTrigger as ht, LifecycleState as i, RoutePattern as it, MachineName as j, Trace as k, ShutdownOptions as l, ExitTrigger as lt, RequestEnd as m, ProcessPort as mt, HealthServer as n, recoverSpan as nt, PhaseWork as o, EXIT_SIGNALS as ot, stageRank as p, ProcessHost as pt, Transport as q, Lifecycle as r, OperationOf as rt, RunOptions as s, EmbeddedProcess as st, DependencyHandle as t, heartbeatDetection as tt, Stage as u, HostStream as ut, RequestStream as v, isExitSignal as vt, ProbeKind as w, Operation as wt, Health as x, nodeProcess as xt, RequestWork as y, isMessageShape as yt, FORMAT as z };
+//# sourceMappingURL=lifecycle-fgYfxrHK.d.ts.map

package/build/machine-BhTRu3u9.js

@@ -0,0 +1,552 @@
+import { t as mayReissue } from "./operation-DL5RxFds.js";
+import { backoffDelay } from "./backoff.js";
+import { quantity, valueIn } from "@mark1russell7/quantity";
+import { connect } from "node:net";
+//#region src/client/meets.ts
+/** These are the manifestations that each client gives a meeting for, in this sequence. */
+const MANIFESTATIONS = [
+	"rst",
+	"fin",
+	"blackhole",
+	"freeze-host",
+	"freeze-process",
+	"app-stall"
+];
+/**
+* These words tell each manifestation that does not depend on the driver. The words of `app-stall`
+* name an example, and the example is a fact of each server, thus each client gives them.
+*/
+const WHAT = {
+	rst: "the server answers each segment with a reset, and refuses each new connection",
+	fin: "the process of the server ends, and its kernel closes the connection",
+	blackhole: "the network drops each segment in the two directions",
+	"freeze-host": "the host of the server stops, without a close: the death without a close",
+	"freeze-process": "the process of the server stops, and its kernel stays up"
+};
+/** This amount is a detector that does not find the failure. */
+const NEVER = {
+	value: "infinite",
+	unit: "s"
+};
+const s = (value) => quantity(Math.round(value * 1e6) / 1e6, "s");
+const seconds = (amount) => amount.value === "infinite" ? Number.POSITIVE_INFINITY : valueIn(amount, "s");
+/** This function gives the time at which Node's TCP keepalive gives up a silent peer: the idle time, then 10 probes 1 s apart. */
+const keepaliveGiveUp = (idle) => idle.value === "infinite" ? NEVER : s(seconds(idle) + 10);
+/** This detector is a segment that arrives at once: a reset or a FIN. */
+const immediate = (situation, effect) => ({
+	by: "the next segment",
+	within: s(0),
+	situation,
+	effect
+});
+/** This detector is TCP keepalive on a silent peer. It gives up after its probes, and the socket closes. */
+const keepaliveSilent = (idle) => ({
+	by: "keepalive_idle",
+	within: keepaliveGiveUp(idle),
+	situation: "idle",
+	effect: "TCP keepalive gives up, and the socket closes"
+});
+/** This detector is TCP keepalive on a peer whose kernel stays up. That kernel answers each probe, thus keepalive does not find the failure. */
+const keepaliveAnswered = () => ({
+	by: "keepalive_idle",
+	within: NEVER,
+	situation: "idle",
+	effect: "the kernel of the server answers each probe"
+});
+/** This detector is TCP keepalive on a peer that resets: the first probe gets the reset. */
+const keepaliveReset = (idle) => ({
+	by: "keepalive_idle",
+	within: idle.value === "infinite" ? NEVER : idle,
+	situation: "idle",
+	effect: "the first probe gets a reset"
+});
+/** This detector is the kernel, which gives up the retransmissions of a segment in flight. A driver can add what follows. */
+const kernelGiveUp = (within, after) => ({
+	by: "retrans_giveup_time",
+	within,
+	situation: "in flight",
+	effect: `the kernel gives up the retransmissions and closes the socket${after === void 0 ? "" : `, and ${after}`}`
+});
+/** This function gives the first detector of a manifestation in a situation, or null when no detector has an end (C3). */
+const firstDetector = (meeting, situation) => {
+	return meeting.detectors.filter((detector) => detector.situation === situation && detector.within.value !== "infinite").sort((a, b) => seconds(a.within) - seconds(b.within))[0] ?? null;
+};
+/** This function gives each manifestation and situation that no detector of the client finds: the standing rule, as a query (C3, E9). */
+const unwatched = (meets) => meets.flatMap((meeting) => ["in flight", "idle"].flatMap((situation) => firstDetector(meeting, situation) === null ? [{
+	manifestation: meeting.manifestation,
+	situation
+}] : []));
+//#endregion
+//#region src/client/core.ts
+/** This function gives an amount in milliseconds. "infinite" is `Infinity`. */
+const ms = (amount) => amount.value === "infinite" ? Number.POSITIVE_INFINITY : valueIn(amount, "ms");
+/** This function gives an amount in milliseconds, or undefined for "infinite". Each driver then writes its own form of "no timer". */
+const finiteMs = (amount) => {
+	const value = ms(amount);
+	return Number.isFinite(value) ? value : void 0;
+};
+/** This function gives the text of an error. */
+const message = (error) => error instanceof Error ? error.message : String(error);
+/** This function gives the addresses and the ports of a socket for a join. Each one is null when the socket does not give it. */
+const socketEnds = (socket) => ({
+	localAddress: socket?.localAddress ?? null,
+	localPort: socket?.localPort ?? null,
+	remoteAddress: socket?.remoteAddress ?? null,
+	remotePort: socket?.remotePort ?? null
+});
+/** This function declares a client in a service: its dependency, its handle, and each of its checks. */
+const attachClient = (svc, name, declaration, handle, checks) => {
+	svc.dependency(name, declaration, handle);
+	for (const [check, run] of checks) svc.check(check, run);
+	return svc;
+};
+/** This function gives the table of operations of a client: the defaults of its driver, then the operations of its spec. */
+const operationTable = (defaults, more) => ({
+	...defaults,
+	...more
+});
+/** This function makes the recorder of a client. Each event has the machine "client", and the name of the client as its instance. */
+const clientRecorder = (record, clock, name) => (from, to, on, detail) => record?.({
+	at: clock.now(),
+	machine: "client",
+	instance: name,
+	from,
+	to,
+	on,
+	...detail === void 0 ? {} : { detail }
+});
+/** This function gives the outcome of a call that did not leave the client. It is certain: the call did not apply. */
+const notSent = (error) => ({
+	outcome: "error",
+	error,
+	reply: false
+});
+/** This function makes the record of the calls in flight of a client. */
+const inFlight = () => {
+	const closes = /* @__PURE__ */ new Set();
+	const waiters = /* @__PURE__ */ new Set();
+	const wake = () => {
+		if (closes.size > 0) return;
+		for (const waiter of [...waiters]) waiter();
+		waiters.clear();
+	};
+	return {
+		get size() {
+			return closes.size;
+		},
+		idle: () => new Promise((resolve) => {
+			if (closes.size === 0) resolve();
+			else waiters.add(resolve);
+		}),
+		track(signal, abandoned, start, after) {
+			return new Promise((resolve) => {
+				let settled = false;
+				const settle = (value, cause) => {
+					if (settled) return;
+					settled = true;
+					closes.delete(close);
+					signal?.removeEventListener("abort", aborted);
+					after?.(value, cause);
+					resolve(value);
+					wake();
+				};
+				const close = (error) => settle({
+					outcome: "indeterminate",
+					error
+				}, new Error(error));
+				const aborted = () => close(abandoned);
+				closes.add(close);
+				signal?.addEventListener("abort", aborted, { once: true });
+				start(settle);
+			});
+		},
+		settleAll(error) {
+			for (const close of [...closes]) close(error);
+		}
+	};
+};
+/**
+* This function sends one call through the record of the calls in flight, with a timer of the
+* wrapper. A driver with no timer for its call uses it: amqplib, and the agent of Node. At `bound`
+* milliseconds the call is indeterminate with the error `timedOut`, because it left the client.
+* The timer stops when the call settles, before `after` operates.
+*/
+const trackWithTimer = (flight, clock, bound, signal, abandoned, timedOut, start, after) => {
+	let stop = () => {};
+	return flight.track(signal, abandoned, (settle) => {
+		stop = clock.after(bound, () => settle({
+			outcome: "indeterminate",
+			error: timedOut
+		}));
+		start(settle);
+	}, (value, cause) => {
+		stop();
+		after?.(value, cause);
+	});
+};
+/**
+* This function waits for the work of a close, for `bound` milliseconds at most. It gives true when
+* the work ended in its bound, with a success or a failure. It gives false at the bound. The driver
+* then destroys each socket that stays, because a silent server does not close its half.
+*/
+const withinBound = (clock, bound, work) => {
+	const done = work.then(() => true, () => true);
+	let cancel = () => {};
+	const timer = new Promise((resolve) => {
+		cancel = clock.after(bound, () => resolve(false));
+	});
+	return Promise.race([done, timer]).then((ended) => {
+		cancel();
+		return ended;
+	});
+};
+/** This function makes the ready wait of a client. The function `ready` tells if the client is ready. */
+const readyWait = (clock, ready) => {
+	const waiters = /* @__PURE__ */ new Set();
+	return {
+		wait: (within, signal) => new Promise((resolve) => {
+			if (ready()) {
+				resolve(true);
+				return;
+			}
+			let cancel = () => {};
+			const done = (value) => {
+				waiters.delete(wake);
+				cancel();
+				signal?.removeEventListener("abort", aborted);
+				resolve(value);
+			};
+			const wake = () => done(true);
+			const aborted = () => done(false);
+			waiters.add(wake);
+			cancel = clock.after(within, () => done(ready()));
+			signal?.addEventListener("abort", aborted, { once: true });
+		}),
+		wake() {
+			for (const wake of [...waiters]) wake();
+		}
+	};
+};
+/**
+* This function gives the backoff of the tries to connect: from `retry_base`, doubling to
+* `retry_cap`, each with a jitter up to the base. The client rounds each delay to a whole millisecond.
+*/
+const retryBackoff = (knobs) => ({
+	base: ms(knobs.retry_base),
+	factor: 2,
+	cap: ms(knobs.retry_cap),
+	jitter: {
+		kind: "add",
+		amount: ms(knobs.retry_base)
+	}
+});
+/** This function makes the retry schedule of a client, from its backoff and its random numbers. RabbitMQ and WebSocket use it. */
+const retrySchedule = (clock, backoff, random) => {
+	let tries = 0;
+	let timer = null;
+	return {
+		get tries() {
+			return tries;
+		},
+		schedule(due) {
+			tries += 1;
+			const delay = Math.round(backoffDelay(backoff, tries, random));
+			timer?.();
+			timer = clock.after(delay, () => {
+				timer = null;
+				due();
+			});
+		},
+		cancel() {
+			timer?.();
+			timer = null;
+		},
+		reset() {
+			tries = 0;
+		}
+	};
+};
+/** This function gives the problems of the retry knobs: the cap must not be below the base. */
+const retryProblems = (name, knobs) => ms(knobs.retry_cap) < ms(knobs.retry_base) ? [`${name}'s retry_cap is below its retry_base`] : [];
+/**
+* This function gives the problem of a count of misses that is not a whole number above zero. A
+* client that closes its connection after a count of heartbeat misses uses it. `mechanism` names the heartbeat, for example "watchdog".
+*/
+const missesProblems = (name, misses, mechanism) => Number.isInteger(misses) && misses >= 1 ? [] : [`${name}'s ${mechanism} closes the connection after ${misses} misses, not a whole number above zero`];
+/** This function gives the problems of the knobs of a spec that each client has: each knob must be a time of zero or more. */
+const timeProblems = (name, knobs) => {
+	const problems = [];
+	for (const [knob, amount] of Object.entries(knobs)) if (amount.value !== "infinite" && !(ms(amount) >= 0)) problems.push(`${name}'s ${knob} is not a time of zero or more`);
+	return problems;
+};
+/** This function writes a bound for a driver that reads 0 as no timer: "infinite" is 0. */
+const orZero = (amount) => finiteMs(amount) ?? 0;
+/** This function tells if an amount is a whole number of milliseconds. "infinite" is whole. */
+const wholeMs = (amount) => amount.value === "infinite" || Number.isInteger(ms(amount));
+/** This function tells if an amount is a whole number of seconds. "infinite" is whole. */
+const wholeSeconds = (amount) => amount.value === "infinite" || Number.isInteger(valueIn(amount, "s"));
+const knobOf = (knobs, knob) => knobs[knob];
+/**
+* This function gives the problems of the knobs of a driver that reads 0 as no timer. pg and the
+* MongoDB driver read 0 so. A bounded knob must be a finite time above zero. An open knob can be
+* "infinite", and 0 is then a mistake.
+*/
+const zeroProblems = (name, driver, knobs, kinds) => {
+	const problems = [];
+	for (const knob of kinds.bounded ?? []) {
+		const value = ms(knobOf(knobs, knob));
+		if (!(value > 0) || !Number.isFinite(value)) problems.push(`${name}'s ${knob} is not a finite time above zero: ${driver} reads 0 as no bound`);
+	}
+	for (const knob of kinds.open ?? []) {
+		const amount = knobOf(knobs, knob);
+		if (amount.value !== "infinite" && !(ms(amount) > 0)) problems.push(`${name}'s ${knob} is zero: give "infinite" for no bound`);
+	}
+	return problems;
+};
+/** This function gives the problems of the knobs that a driver takes in whole milliseconds or in whole seconds. */
+const wholeProblems = (name, knobs, kinds) => [...(kinds.millis ?? []).filter((knob) => !wholeMs(knobOf(knobs, knob))).map((knob) => `${name}'s ${knob} is not a whole number of milliseconds`), ...(kinds.seconds ?? []).filter((knob) => !wholeSeconds(knobOf(knobs, knob))).map((knob) => `${name}'s ${knob} is not a whole number of seconds`)];
+/** This function gives the problems of the sizes of a pool: at most `max` connections, and `min` from 0 to `max`. */
+const poolProblems = (name, pool) => {
+	const problems = [];
+	if (!Number.isInteger(pool.max) || pool.max < 1) problems.push(`${name}'s pool has a max of ${pool.max}, not a whole number above zero`);
+	if (!Number.isInteger(pool.min) || pool.min < 0 || pool.min > pool.max) problems.push(`${name}'s pool has a min of ${pool.min}, not a whole number from 0 to its max`);
+	return problems;
+};
+/**
+* This function gives the problem O07 of a client whose server has a deadline, or null. The client
+* must wait longer than the deadline of the server. Then the server ends a slow call with an error
+* first. Otherwise the client gives up first, and the server goes on with the call. `call` names
+* the call of the server, for example a statement.
+*/
+const deadlineProblem = (name, request, deadline, call) => deadline.value !== "infinite" && ms(request) <= ms(deadline) ? `${name}'s request_timeout is not above its statement_timeout: the server goes on with a ${call} that the client gave up (O07)` : null;
+/**
+* This function gives the problem O01 of a client pool, or null. The pool must close an idle
+* connection before its server does. Otherwise a request can go on a connection that the server
+* closed. A server that keeps an idle connection with no bound gives no problem. `knob` names the
+* idle time of the client: `pool_idle_expiry` of a pool, or `client_idle_timeout` of a gRPC channel.
+*/
+const idleCloseProblem = (name, expiry, close, knob = "pool_idle_expiry") => close.value !== "infinite" && !(ms(expiry) < ms(close)) ? `${name}'s ${knob} is not below the idle close of its server: a request can go on a connection that the server closed (O01)` : null;
+/**
+* This function gives the problems of the timers that the wrapper has, because its driver has none.
+* Each one must be a finite time above zero. `bounds` gives what each knob bounds, for example "a call".
+*/
+const wrapperTimerProblems = (name, knobs, bounds) => Object.entries(bounds).filter(([knob]) => {
+	const value = ms(knobOf(knobs, knob));
+	return !(value > 0) || !Number.isFinite(value);
+}).map(([knob, what]) => `${name}'s ${knob} is not a finite time above zero: the timer of the wrapper is the only bound of ${what}`);
+/** This function gives the problem of a finite connection age, for a client that does not replace a connection at an age. `reason` tells why. */
+const ageProblems = (name, knobs, reason) => knobs.max_connection_age.value === "infinite" ? [] : [`${name}'s max_connection_age is not "infinite": ${reason}`];
+/** This function gives the problem of a keepalive that is not a finite time above zero, for a driver that always turns keepalive on. */
+const keepaliveOnProblems = (name, knobs, driver) => {
+	const value = ms(knobs.keepalive_idle);
+	return value > 0 && Number.isFinite(value) ? [] : [`${name}'s keepalive_idle is not a finite time above zero: ${driver} always turns keepalive on`];
+};
+/**
+* This function sends a call, and gives its outcome in three values. It sends again only an
+* idempotent operation, one time at most, after an outcome that is not certain. A reply of the
+* server is certain. The second try ends at the bound of the call, not one bound after its own start.
+*/
+const sendWithReissue = async (call) => {
+	const { clock, bound } = call;
+	const { signal } = call.options;
+	const operation = call.options.reissue === false ? void 0 : call.operation;
+	const started = clock.now();
+	const first = await call.attempt(signal);
+	if (first.outcome === "ok") return {
+		outcome: "ok",
+		value: first.value,
+		attempts: 1
+	};
+	const again = !(first.outcome === "error" && first.reply) && operation !== void 0 && signal?.aborted !== true && mayReissue(operation, quantity((clock.now() - started) / 1e3, "s"));
+	const left = bound - (clock.now() - started);
+	if (!again || left <= 0) return {
+		...first,
+		attempts: 1
+	};
+	if (call.beforeAgain !== void 0 && !await call.beforeAgain(left, signal)) return {
+		...first,
+		attempts: 1
+	};
+	call.onReissue();
+	const end = new AbortController();
+	const stop = clock.after(Math.max(0, bound - (clock.now() - started)), () => end.abort());
+	const forward = () => end.abort();
+	signal?.addEventListener("abort", forward, { once: true });
+	const second = await call.attempt(end.signal);
+	stop();
+	signal?.removeEventListener("abort", forward);
+	return second.outcome === "ok" ? {
+		outcome: "ok",
+		value: second.value,
+		attempts: 2
+	} : {
+		...second,
+		attempts: 2
+	};
+};
+/**
+* This function gives the checks of a client, for `svc.check(check, run)`. It gives a check only for
+* each step that the options name, and only when the client has a function for that step.
+*/
+const stepChecks = (name, options, runs) => {
+	const made = [];
+	for (const [step, run] of Object.entries(runs)) {
+		if (run === void 0 || !(step in options.steps)) continue;
+		made.push([{
+			name: `${name}.${step}`,
+			dependency: name,
+			step,
+			ownConnection: run.ownConnection,
+			gates: options.steps[step] ?? null,
+			poll: options.poll
+		}, run.run]);
+	}
+	return made;
+};
+/** This function makes a check outcome from a sent result: only `ok` passes. */
+const passes = (sent) => sent.outcome === "ok" ? "ok" : "error";
+/** This check gives the state of the client, without a round trip. */
+const localStateCheck = (ready) => ({
+	ownConnection: true,
+	run: () => ready() ? "ok" : "error"
+});
+/**
+* This check sends one call on the connection of the application. A check measures the step at this time.
+* Thus it does not send the call again, and only `ok` passes.
+*/
+const roundTripCheck = (send) => ({
+	ownConnection: true,
+	run: async (signal) => passes(await send({
+		signal,
+		reissue: false
+	}))
+});
+/**
+* This check opens a new connection each time. It finds a server that refuses connections, but not
+* a stalled connection of the application. A failed dial throws, and the poller counts the throw as an error.
+*/
+const dialCheck = (dial, host, port) => ({
+	ownConnection: false,
+	run: async (signal) => {
+		await dial(host, port, signal);
+		return "ok";
+	}
+});
+/** This function gives the bounds of a client that `clientProblems` examines, from its knobs. */
+const clientBounds = (knobs) => ({
+	close: ms(knobs.close_bound),
+	request: ms(knobs.request_timeout)
+});
+/**
+* This function gives the problems of a client in a description:
+* - The client needs the phase "tear down dependencies", and its close must fit in the cap of that phase.
+* - A round-trip check must end in one jittered poll (B7, O13).
+*/
+const clientProblems = (name, description, bounds) => {
+	const found = [];
+	const teardown = description.shutdown.phases.find((phase) => phase.name === "tear down dependencies");
+	if (teardown === void 0) found.push(`${name} needs the phase "tear down dependencies" to close`);
+	else if (bounds.close >= valueIn(teardown.cap, "ms")) found.push(`${name}'s close_bound of ${bounds.close} ms does not fit in the cap of "tear down dependencies"`);
+	for (const check of description.checks) {
+		if (check.dependency !== name || check.step !== "round-trip") continue;
+		const slowest = valueIn(check.poll.timeout, "ms") + valueIn(check.poll.interval, "ms") * (1 + check.poll.jitter);
+		if (bounds.request > slowest) found.push(`${name}'s request_timeout outlives one jittered poll of ${check.name} (B7, O13)`);
+	}
+	return found;
+};
+/**
+* This poll is a poll of the checks to start from: each 5 s with a jitter of 20 %, and a timeout of
+* 4 s (B6, O12). Its slowest poll is 4 s + 5 s × 1.2 = 10 s, the slowest poll of the cells of O13.
+* It does not depend on a driver. The starting knobs of each driver fit it.
+*/
+const STARTING_POLL = {
+	interval: {
+		value: 5,
+		unit: "s"
+	},
+	jitter: .2,
+	timeout: {
+		value: 4,
+		unit: "s"
+	}
+};
+//#endregion
+//#region src/client/dial.ts
+/**
+* This function makes a dial function. The dial opens a TCP connection, sends `hello`, and reads the
+* answer until `judge` decides. An abort, an error of the socket, and a close before the decision fail the dial.
+* The dial destroys its socket at its end.
+*/
+const helloDial = (hello, judge) => (host, port, signal) => new Promise((resolve, reject) => {
+	if (signal.aborted) {
+		reject(/* @__PURE__ */ new Error("the dial was aborted"));
+		return;
+	}
+	const socket = connect({
+		host,
+		port
+	});
+	let received = Buffer.alloc(0);
+	const end = (error) => {
+		signal.removeEventListener("abort", onAbort);
+		socket.destroy();
+		if (error === void 0) resolve();
+		else reject(error);
+	};
+	const onAbort = () => end(/* @__PURE__ */ new Error("the dial was aborted"));
+	signal.addEventListener("abort", onAbort, { once: true });
+	socket.once("connect", () => socket.write(hello));
+	socket.on("data", (chunk) => {
+		received = Buffer.concat([received, chunk]);
+		const verdict = judge(received);
+		if (verdict === "more") return;
+		end(verdict ?? void 0);
+	});
+	socket.once("error", (error) => end(error));
+	socket.once("close", () => end(/* @__PURE__ */ new Error("the server closed the dial")));
+});
+/** This function gives the authority of a host and a port for a Host header. An IPv6 address goes in brackets. */
+const authority = (host, port) => `${host.includes(":") ? `[${host}]` : host}:${port}`;
+/**
+* This function makes a judge of the status line of an HTTP/1.1 answer. The judge waits for the end
+* of the line, in the first 8 KiB. Then `accept` reads the status code, and gives null for a good status or an error.
+* The HTTP client accepts each status. The WebSocket client accepts only 101.
+*/
+const statusLineJudge = (accept) => (received) => {
+	const end = received.indexOf("\r\n");
+	if (end < 0) return received.length > 8192 ? /* @__PURE__ */ new Error("the answer has no status line in its first 8 KiB") : "more";
+	const line = received.toString("latin1", 0, end);
+	const status = /^HTTP\/1\.[01] (\d{3})/.exec(line);
+	return status === null ? /* @__PURE__ */ new Error(`the answer ${JSON.stringify(line)} is not an HTTP/1.1 status line`) : accept(Number(status[1]), line);
+};
+//#endregion
+//#region src/client/machine.ts
+/** This function gives one transition of a machine document. */
+const transition = (id, from, on, to, extra = {}) => ({
+	id,
+	from,
+	on,
+	to,
+	...extra
+});
+/** This function gives a knob of a client in a machine document, by the option of the driver that it sets. */
+const clientKnob = (key) => ({
+	key,
+	scope: "client",
+	unit: "s",
+	default: null
+});
+/** This timer is the bound of the close. The close request arms it, and the end cancels it. At its end, the driver destroys each socket. */
+const closeTimer = () => ({
+	duration: {
+		knob: "close_bound",
+		unit: "s"
+	},
+	arms: ["close.request"],
+	cancels: ["status.end"],
+	fires: "close.bound"
+});
+//#endregion
+export { retrySchedule as A, zeroProblems as B, notSent as C, readyWait as D, poolProblems as E, timeProblems as F, immediate as G, NEVER as H, trackWithTimer as I, keepaliveSilent as J, keepaliveAnswered as K, wholeProblems as L, sendWithReissue as M, socketEnds as N, retryBackoff as O, stepChecks as P, withinBound as R, ms as S, orZero as T, WHAT as U, MANIFESTATIONS as V, firstDetector as W, unwatched as X, kernelGiveUp as Y, inFlight as _, helloDial as a, message as b, ageProblems as c, clientProblems as d, clientRecorder as f, idleCloseProblem as g, finiteMs as h, authority as i, roundTripCheck as j, retryProblems as k, attachClient as l, dialCheck as m, closeTimer as n, statusLineJudge as o, deadlineProblem as p, keepaliveReset as q, transition as r, STARTING_POLL as s, clientKnob as t, clientBounds as u, keepaliveOnProblems as v, operationTable as w, missesProblems as x, localStateCheck as y, wrapperTimerProblems as z };
+
+//# sourceMappingURL=machine-BhTRu3u9.js.map