@mark1russell7/service 0.5.12 → 0.5.13

package/build/mongodb.js

@@ -0,0 +1,688 @@
+import { realClock } from "./clock.js";
+import { B as zeroProblems, C as notSent, E as poolProblems, F as timeProblems, G as immediate, J as keepaliveSilent, K as keepaliveAnswered, L as wholeProblems, M as sendWithReissue, P as stepChecks, R as withinBound, S as ms, T as orZero, U as WHAT, V as MANIFESTATIONS, W as firstDetector, X as unwatched, Y as kernelGiveUp, _ as inFlight, a as helloDial, b as message, c as ageProblems, d as clientProblems, f as clientRecorder, h as finiteMs, j as roundTripCheck, l as attachClient, m as dialCheck, n as closeTimer, p as deadlineProblem, q as keepaliveReset, r as transition, s as STARTING_POLL, t as clientKnob, u as clientBounds, v as keepaliveOnProblems, w as operationTable, y as localStateCheck } from "./machine-BhTRu3u9.js";
+import { quantity } from "@mark1russell7/quantity";
+//#region src/mongodb/connection.ts
+/**
+* This factory makes a `MongoClient`. It loads the driver only when a client connects, thus a
+* service that does not use MongoDB does not need it. The specifier is a value, thus the package
+* needs no types of the driver. The driver gives `MongoClient` as a named export.
+*/
+const nodeMongo = async ({ url, options }) => {
+	return new (await (import("mongodb"))).MongoClient(url, options);
+};
+//#endregion
+//#region src/mongodb/meets.ts
+/**
+* This function gives the manifestations that a MongoDB client can meet, and the detectors of each,
+* from its knobs. The cells of S1 measured them on the driver 7.7.0 against mongod 9.0.4:
+* - The monitor writes off a silent server at `connectTimeoutMS + heartbeatFrequencyMS` after its last
+*   answer: 40.002 s at the defaults, and 7 s for 5 s + 2 s. The driver then clears the pool, and
+*   fails each command in flight. With `connectTimeoutMS` 0, nothing found a freeze in 60 s.
+* - At `tcp_retries2 = 5`, the kernel gave up at 12.936 s.
+* - A `keepAliveInitialDelay` of 27 s ended an idle stream at 37.255 s.
+*
+* The monitor tests the server, not each connection of the pool. Thus a write-off finds a failure of
+* the server in flight and idle, and a failure of one connection waits for its own detector.
+*/
+const mongoMeetings = (name, knobs) => {
+	const writeoffTime = quantity((ms(knobs.connect_bound) + ms(knobs.heartbeat_interval)) / 1e3, "s");
+	const writeoff = (situation) => ({
+		by: "driver_writeoff_time",
+		within: writeoffTime,
+		situation,
+		effect: situation === "in flight" ? `the monitor writes the server off, and the driver fails the command as indeterminate. ${name} goes to failing` : `the monitor writes the server off, and the driver closes each idle connection. ${name} goes to failing`
+	});
+	const read = {
+		by: "request_timeout",
+		within: knobs.request_timeout,
+		situation: "in flight",
+		effect: "the command fails with a timeout of the socket, as indeterminate, and the driver closes the connection"
+	};
+	const idleExpiry = {
+		by: "pool_idle_expiry",
+		within: knobs.pool_idle_expiry,
+		situation: "idle",
+		effect: "the next checkout ends the idle connection, thus no command gets the dead connection"
+	};
+	const giveUp = kernelGiveUp(knobs.retrans_giveup_time, "the command fails as indeterminate");
+	const silent = (manifestation) => ({
+		manifestation,
+		what: WHAT[manifestation],
+		detectors: [
+			writeoff("in flight"),
+			read,
+			giveUp,
+			writeoff("idle"),
+			idleExpiry,
+			keepaliveSilent(knobs.keepalive_idle)
+		]
+	});
+	return [
+		{
+			manifestation: "rst",
+			what: WHAT.rst,
+			detectors: [
+				immediate("in flight", "the command fails with ECONNRESET, and the driver clears the pool"),
+				{
+					by: "heartbeat_interval",
+					within: knobs.heartbeat_interval,
+					situation: "idle",
+					effect: "the next answer of the monitor gets a reset, thus the driver writes the server off and clears the pool"
+				},
+				idleExpiry,
+				keepaliveReset(knobs.keepalive_idle)
+			]
+		},
+		{
+			manifestation: "fin",
+			what: WHAT.fin,
+			detectors: [immediate("in flight", "the command fails: the connection closed"), immediate("idle", "the stream of the monitor closes, thus the driver writes the server off and clears the pool")]
+		},
+		silent("blackhole"),
+		silent("freeze-host"),
+		{
+			manifestation: "freeze-process",
+			what: WHAT["freeze-process"],
+			detectors: [
+				writeoff("in flight"),
+				read,
+				writeoff("idle"),
+				idleExpiry,
+				keepaliveAnswered()
+			]
+		},
+		{
+			manifestation: "app-stall",
+			what: "the server stops its replies to commands for a time, for example behind a lock, and its monitor still answers",
+			detectors: [
+				{
+					by: "statement_timeout",
+					within: knobs.statement_timeout,
+					situation: "in flight",
+					effect: "the server ends the command with error 50 (MaxTimeMSExpired), a certain outcome, and the connection stays"
+				},
+				read,
+				idleExpiry,
+				keepaliveAnswered()
+			]
+		}
+	];
+};
+//#endregion
+//#region src/mongodb/client.ts
+/** The driver takes a period of the monitor of 500 ms at least. */
+const LEAST_HEARTBEAT_MS = 500;
+/** This function gives the problems of a spec: the knobs that the driver cannot use. */
+const specProblems = (name, spec) => {
+	const { knobs } = spec;
+	const problems = [
+		...timeProblems(name, knobs),
+		...zeroProblems(name, "the driver", knobs, {
+			bounded: [
+				"connect_bound",
+				"request_timeout",
+				"heartbeat_interval",
+				"client_retry_window",
+				"close_bound"
+			],
+			open: [
+				"statement_timeout",
+				"checkout_timeout",
+				"pool_idle_expiry"
+			]
+		}),
+		...wholeProblems(name, knobs, {
+			millis: [
+				"connect_bound",
+				"request_timeout",
+				"statement_timeout",
+				"heartbeat_interval",
+				"client_retry_window",
+				"checkout_timeout",
+				"pool_idle_expiry"
+			],
+			seconds: ["keepalive_idle"]
+		}),
+		...poolProblems(name, spec.pool)
+	];
+	if (ms(knobs.heartbeat_interval) < LEAST_HEARTBEAT_MS) problems.push(`${name}'s heartbeat_interval is below 500 ms, the least that the driver takes`);
+	problems.push(...keepaliveOnProblems(name, knobs, "the driver"), ...ageProblems(name, knobs, "the driver has no age for a connection"));
+	return problems;
+};
+/** This function gives the arguments of `new MongoClient` from a spec. Each timer of the driver comes from the declaration. */
+const mongoOptions = (name, spec) => {
+	const { knobs } = spec;
+	return {
+		url: `mongodb://${[{
+			host: spec.host,
+			port: spec.port
+		}, ...spec.seeds ?? []].map((seed) => `${seed.host}:${seed.port}`).join(",")}/`,
+		options: {
+			appName: name,
+			...spec.replicaSet === void 0 ? {} : { replicaSet: spec.replicaSet },
+			...spec.username === void 0 ? {} : { auth: {
+				username: spec.username,
+				password: spec.password ?? ""
+			} },
+			...spec.authSource === void 0 ? {} : { authSource: spec.authSource },
+			maxPoolSize: spec.pool.max,
+			minPoolSize: spec.pool.min,
+			connectTimeoutMS: ms(knobs.connect_bound),
+			socketTimeoutMS: ms(knobs.request_timeout),
+			serverSelectionTimeoutMS: ms(knobs.client_retry_window),
+			heartbeatFrequencyMS: ms(knobs.heartbeat_interval),
+			waitQueueTimeoutMS: orZero(knobs.checkout_timeout),
+			maxIdleTimeMS: orZero(knobs.pool_idle_expiry),
+			keepAliveInitialDelay: ms(knobs.keepalive_idle),
+			serverMonitoringMode: "stream",
+			retryReads: false,
+			retryWrites: false,
+			monitorCommands: true
+		}
+	};
+};
+/**
+* The bytes of an OP_MSG with the command `{ hello: 1, $db: "admin" }`. They are a header of 16
+* bytes with the op code 2013, the flags, a section of kind 0, and the BSON document. The server answers a
+* hello before the authentication, thus the dial needs no password.
+*/
+const HELLO = Uint8Array.of(52, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 221, 7, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 16, 104, 101, 108, 108, 111, 0, 1, 0, 0, 0, 2, 36, 100, 98, 0, 6, 0, 0, 0, 97, 100, 109, 105, 110, 0, 0);
+/** The sizes of the values of the BSON types that a hello reply holds, by type. A null size has a length prefix. */
+const FIXED = {
+	1: 8,
+	7: 12,
+	8: 1,
+	9: 8,
+	10: 0,
+	16: 4,
+	17: 8,
+	18: 8,
+	19: 16
+};
+/** This function gives the value of `ok` at the top of a BSON document, or an error. */
+const okOf = (doc) => {
+	let at = 4;
+	while (at < doc.length - 1) {
+		const type = doc[at];
+		const end = doc.indexOf(0, at + 1);
+		if (end < 0) return /* @__PURE__ */ new Error("the hello reply has a field with no end");
+		const key = doc.toString("latin1", at + 1, end);
+		at = end + 1;
+		if (key === "ok") {
+			if (type === 1) return doc.readDoubleLE(at);
+			if (type === 16) return doc.readInt32LE(at);
+			return /* @__PURE__ */ new Error(`the ok of the hello reply has the BSON type ${type}`);
+		}
+		const fixed = FIXED[type];
+		if (fixed !== void 0) at += fixed;
+		else if (type === 2) at += 4 + doc.readInt32LE(at);
+		else if (type === 3 || type === 4) at += doc.readInt32LE(at);
+		else if (type === 5) at += 5 + doc.readInt32LE(at);
+		else return /* @__PURE__ */ new Error(`the hello reply has the BSON type ${type}, which the dial does not read`);
+	}
+	return /* @__PURE__ */ new Error("the hello reply has no ok");
+};
+/**
+* This judge reads the answer to the hello. It waits for the whole message. The message must be an
+* OP_MSG with a section of kind 0, and its document must have `ok` 1.
+*/
+const helloJudge = (received) => {
+	if (received.length < 4) return "more";
+	const length = received.readInt32LE(0);
+	if (length < 26 || length > 50331648) return /* @__PURE__ */ new Error(`the answer to the hello has a length of ${length}`);
+	if (received.length < length) return "more";
+	const opCode = received.readInt32LE(12);
+	if (opCode !== 2013) return /* @__PURE__ */ new Error(`the answer to the hello has the op code ${opCode}, not 2013`);
+	if (received[20] !== 0) return /* @__PURE__ */ new Error("the answer to the hello has no section of kind 0");
+	const ok = okOf(received.subarray(21, length));
+	if (ok instanceof Error) return ok;
+	return ok === 1 ? null : /* @__PURE__ */ new Error(`the hello reply has ok ${ok}`);
+};
+/** This dial function opens a TCP connection, sends a hello, and waits for its reply. The server opens no session for it. */
+const helloCommandDial = helloDial(HELLO, helloJudge);
+/** These errors tell that the command did not leave the client: no server, a full pool, a cleared pool, or a closed client. */
+const NOT_SENT = /* @__PURE__ */ new Set([
+	"MongoServerSelectionError",
+	"MongoWaitQueueTimeoutError",
+	"MongoPoolClearedError",
+	"MongoPoolClosedError",
+	"MongoServerClosedError",
+	"MongoTopologyClosedError",
+	"MongoNotConnectedError",
+	"MongoClientClosedError"
+]);
+/**
+* These codes of the server tell that the server interrupted the command. The causes are its
+* shutdown, a step down, or a change of the state of the replica set. A part of the command can have applied.
+*/
+const INTERRUPTED = /* @__PURE__ */ new Set([
+	91,
+	189,
+	11600,
+	11602
+]);
+/** The writable servers: a primary, a standalone, a mongos, and a load balancer. */
+const WRITABLE = /* @__PURE__ */ new Set([
+	"RSPrimary",
+	"Standalone",
+	"Mongos",
+	"LoadBalancer"
+]);
+/** This function gives the outcome of a reply. A write concern error tells that the write can roll back, thus it is not certain. */
+const replyOutcome = (reply) => {
+	const concern = reply["writeConcernError"];
+	if (concern === void 0 || concern === null) return {
+		outcome: "ok",
+		value: reply
+	};
+	return {
+		outcome: "indeterminate",
+		error: `write concern ${String(concern.code)} ${String(concern.errmsg)}`
+	};
+};
+/**
+* This function gives the outcome of a failure of the driver. The driver names each error class,
+* thus the wrapper reads the name, and depends on no class of the driver:
+* - A failure before the command left the client is certain: it did not apply.
+* - An error of the server is certain, except an interruption, which can leave a part applied.
+* - A write concern error, a network error after the handshake, and a timeout of the socket are not certain.
+*/
+const failureOutcome = (error) => {
+	const text = message(error);
+	const { name, code, beforeHandshake } = typeof error === "object" && error !== null ? error : {};
+	if (typeof name === "string" && NOT_SENT.has(name)) return notSent(text);
+	if (name === "MongoNetworkError" && beforeHandshake === true) return notSent(text);
+	if (name === "MongoServerError" && typeof code === "number") {
+		const said = `${code} ${text}`;
+		return INTERRUPTED.has(code) ? {
+			outcome: "indeterminate",
+			error: said
+		} : {
+			outcome: "error",
+			error: said,
+			reply: true
+		};
+	}
+	return {
+		outcome: "indeterminate",
+		error: text
+	};
+};
+/** This function gives the host and the port of an address `host:port`. */
+const endsOf = (address) => {
+	const at = address.lastIndexOf(":");
+	const port = Number(address.slice(at + 1));
+	return at < 0 || !Number.isInteger(port) ? {
+		host: address,
+		port: null
+	} : {
+		host: address.slice(0, at),
+		port
+	};
+};
+/**
+* This function makes a MongoDB client, a dependency of a service over a `MongoClient`.
+* - It sets each timer of the driver from the declaration, and it turns off the retries of the driver.
+*   The client sends again only an idempotent operation of its table.
+* - It tells the outcome of a command in three values, from the name of each error of the driver.
+* - It writes the deadline of the server in each command (`maxTimeMS`), thus the server ends a slow command first (O07).
+* - It gives the state from the view of the topology: ready while a server is writable.
+* - It listens to each error of the driver. In Node, an error with no listener throws, and library code does not end the process (A5).
+* - It records the connection id of the server for each connection of the pool (D1).
+*
+* The outcomes, the second try, the commands in flight, the bounded close and the checks come from
+* the core of the clients. This entry gives what the driver does in its own way.
+*/
+const mongoClient = (name, spec, options = {}) => {
+	const problems = specProblems(name, spec);
+	if (problems.length > 0) throw new Error(problems.join("; "));
+	const { knobs } = spec;
+	const clock = options.clock ?? realClock;
+	const create = options.create ?? nodeMongo;
+	const dial = options.dial ?? helloCommandDial;
+	const operations = operationTable({}, spec.operations);
+	const deadline = finiteMs(knobs.statement_timeout);
+	const callBound = ms(knobs.client_retry_window) + ms(knobs.request_timeout);
+	let driver = null;
+	let status = "none";
+	const joins = [];
+	const joined = /* @__PURE__ */ new Map();
+	const flight = inFlight();
+	const emit = clientRecorder(options.record, clock, name);
+	const record = (on, to = status, detail) => {
+		const from = status;
+		status = to;
+		emit(from, to, on, detail);
+	};
+	const closing = () => status === "closing" || status === "end";
+	const onTopology = (event) => {
+		const writable = [...event.newDescription.servers.values()].some((server) => WRITABLE.has(server.type));
+		if (writable && (status === "connecting" || status === "failing")) record("topology.writable", "ready");
+		else if (!writable && status === "ready") record("topology.unwritable", "failing");
+	};
+	const onReady = (event) => {
+		const generation = joins.length + 1;
+		const { host, port } = endsOf(event.address);
+		joined.set(`${event.address}#${String(event.connectionId)}`, joins.length);
+		joins.push({
+			generation,
+			at: clock.now(),
+			address: event.address,
+			serverConnectionId: null,
+			localAddress: null,
+			localPort: null,
+			remoteAddress: host,
+			remotePort: port
+		});
+		record("join", status, `generation ${generation}, ${event.address}`);
+	};
+	const onStarted = (event) => {
+		const index = joined.get(`${event.address}#${String(event.connectionId)}`);
+		const id = event.serverConnectionId;
+		if (index === void 0 || id === null || id === void 0) return;
+		joined.delete(`${event.address}#${String(event.connectionId)}`);
+		joins[index] = {
+			...joins[index],
+			serverConnectionId: Number(id)
+		};
+	};
+	const onCleared = (event) => record("pool.cleared", status, `${event.address}${event.interruptInUseConnections === true ? ", with the commands in flight" : ""}`);
+	const onHeartbeat = (event) => record("heartbeat.failed", status, `${event.connectionId}: ${message(event.failure)}`);
+	const onError = (error) => {
+		if (status !== "end") record("client.error", status, message(error));
+	};
+	const listeners = [
+		["topologyDescriptionChanged", onTopology],
+		["connectionReady", onReady],
+		["commandStarted", onStarted],
+		["connectionPoolCleared", onCleared],
+		["serverHeartbeatFailed", onHeartbeat]
+	];
+	/** This function makes one try of a command. The driver selects a server, checks out a connection, and sends the command. */
+	const attempt = (document, signal) => {
+		const c = driver;
+		if (c === null) return Promise.resolve(notSent(`${name} has not connected`));
+		if (closing()) return Promise.resolve(notSent(`${name} is ${status}: the command did not leave the client`));
+		if (signal?.aborted) return Promise.resolve(notSent("the caller aborted the command before it left the client"));
+		const sent = deadline === void 0 || "maxTimeMS" in document ? document : {
+			...document,
+			maxTimeMS: deadline
+		};
+		return flight.track(signal, "the caller abandoned the command after it went to the driver", (settle) => {
+			c.db(spec.database).command(sent, signal === void 0 ? {} : { signal }).then((reply) => settle(replyOutcome(reply)), (error) => settle(failureOutcome(error)));
+		});
+	};
+	const command = (operation, document, sendOptions = {}) => sendWithReissue({
+		clock,
+		bound: callBound,
+		operation: operations[operation],
+		options: sendOptions,
+		attempt: (signal) => attempt(document, signal),
+		onReissue: () => record("command.reissue", status, operation)
+	});
+	const handle = {
+		async connect(signal) {
+			record("status.connecting", "connecting");
+			const c = await create(mongoOptions(name, spec));
+			driver = c;
+			for (const [event, listener] of listeners) c.on(event, listener);
+			c.on("error", onError);
+			if (signal.aborted) throw new Error(`${name}: the service stopped before the connect`);
+			const connecting = c.connect().then(() => void 0, (error) => {
+				if (!closing() && status !== "ready") record("connect.failed", "failing", message(error));
+			});
+			await withinBound(clock, ms(knobs.connect_bound), connecting);
+			if (status === "connecting") record("connect.failed", "failing", "no writable server in connect_bound");
+		},
+		async close() {
+			const c = driver;
+			if (c === null || closing()) return;
+			record("close.request", "closing");
+			if (!await withinBound(clock, ms(knobs.close_bound), c.close())) record("close.bound", status, "the close of the driver goes on");
+			flight.settleAll("the client closed with the command in flight");
+			for (const [event, listener] of listeners) c.off(event, listener);
+			record("status.end", "end");
+		}
+	};
+	const declaration = {
+		system: spec.system,
+		knobs: {
+			connect_bound: knobs.connect_bound,
+			request_timeout: knobs.request_timeout,
+			statement_timeout: knobs.statement_timeout,
+			heartbeat_interval: knobs.heartbeat_interval,
+			client_retry_window: knobs.client_retry_window,
+			driver_writeoff_time: {
+				value: (ms(knobs.connect_bound) + ms(knobs.heartbeat_interval)) / 1e3,
+				unit: "s"
+			},
+			checkout_timeout: knobs.checkout_timeout,
+			pool_idle_expiry: knobs.pool_idle_expiry,
+			keepalive_idle: knobs.keepalive_idle,
+			idle_refresh_interval: knobs.keepalive_idle,
+			max_connection_age: knobs.max_connection_age,
+			close_bound: knobs.close_bound,
+			retrans_giveup_time: knobs.retrans_giveup_time
+		},
+		operations
+	};
+	const checks = (checkOptions) => stepChecks(name, checkOptions, {
+		"local-state": localStateCheck(() => status === "ready"),
+		"round-trip": roundTripCheck((sendOptions) => command("check", { ping: 1 }, sendOptions)),
+		dial: dialCheck(dial, spec.host, spec.port)
+	});
+	return {
+		name,
+		declaration,
+		handle,
+		meets: mongoMeetings(name, knobs),
+		get status() {
+			return status;
+		},
+		joins,
+		command,
+		checks,
+		attach: (svc, checkOptions) => attachClient(svc, name, declaration, handle, checks(checkOptions)),
+		problems(description) {
+			const late = deadlineProblem(name, knobs.request_timeout, knobs.statement_timeout, "command");
+			return [...clientProblems(name, description, clientBounds(knobs)), ...late === null ? [] : [late]];
+		}
+	};
+};
+//#endregion
+//#region src/mongodb/machine.ts
+/** The states where the driver exists and serves. */
+const SERVING = [
+	"connecting",
+	"ready",
+	"failing"
+];
+const OPEN = [...SERVING, "closing"];
+/**
+* The MongoDB client of the service as a `mark1russell7.machine/1` document. It is the topology as
+* the wrapper sees it, not one connection: the document `mongodb-node` of `@mark1russell7/machines`
+* gives the monitor and each connection. The state is the view of the topology:
+* - `ready`: a server is writable: a primary, a standalone, a mongos, or a load balancer.
+* - `failing`: no server is writable, or the startup found none in `connect_bound`. The monitor
+*   goes on, and a command waits for a writable server in `client_retry_window`.
+*
+* A connection that closes and a pool that the driver clears do not change the state by themselves.
+* The write-off of a server changes the view of the topology, and that changes the state. A test
+* records the transitions of the client and replays them against this document.
+*/
+const MONGO_CLIENT_MACHINE = {
+	format: "mark1russell7.machine/1",
+	id: "service.machine.mongodb-client",
+	title: "The MongoDB client of the service, over a MongoClient of the driver 7",
+	layer: "driver",
+	version: "0.1.0",
+	sources: [{
+		ref: "packages/service/src/mongodb (the client implements this document)",
+		rung: "implemented"
+	}],
+	states: {
+		none: {
+			initial: true,
+			note: "the client exists, and its MongoClient does not"
+		},
+		connecting: { note: "the monitor looks for the servers of the topology" },
+		ready: { note: "a server is writable. A dead idle connection stays hidden until the monitor writes the server off" },
+		failing: { note: "no server is writable. A command waits for one in client_retry_window" },
+		closing: { note: "the close of the driver: it fails the commands in flight, sends endSessions, and closes the topology" },
+		end: {
+			final: true,
+			note: "the service closed the client"
+		}
+	},
+	events: {
+		"status.connecting": { kind: "local" },
+		"topology.writable": {
+			kind: "rx",
+			note: "the view of the topology has a writable server"
+		},
+		"topology.unwritable": {
+			kind: "rx",
+			note: "the view of the topology has no writable server, for example after a write-off or a step down"
+		},
+		join: {
+			kind: "rx",
+			note: "a connection of the pool finished its handshake (D1). The id of the server comes with its first command"
+		},
+		"connect.failed": {
+			kind: "local",
+			note: "the startup found no writable server in connect_bound, or the connect of the driver failed"
+		},
+		"pool.cleared": {
+			kind: "rx",
+			note: "the driver cleared the pool of a server, and with a write-off also failed its commands in flight"
+		},
+		"heartbeat.failed": {
+			kind: "rx",
+			note: "a hello of the monitor failed"
+		},
+		"client.error": {
+			kind: "rx",
+			note: "an error event of the driver"
+		},
+		"command.reissue": { kind: "local" },
+		"close.request": { kind: "local" },
+		"close.bound": {
+			kind: "timer",
+			note: "the close of the driver goes on after the bound, in the background"
+		},
+		"close.destroy": {
+			kind: "local",
+			note: "the client never records it: the driver gives no socket that the bound can destroy"
+		},
+		"status.end": { kind: "local" }
+	},
+	knobs: {
+		connect_bound: clientKnob("connectTimeoutMS"),
+		close_bound: clientKnob("close.bound")
+	},
+	timers: {
+		connect_timeout: {
+			duration: {
+				knob: "connect_bound",
+				unit: "s"
+			},
+			arms: ["enter:connecting"],
+			cancels: ["topology.writable", "connect.failed"],
+			fires: "connect.failed",
+			note: "the startup stops its wait, and the connect of the driver goes on in client_retry_window"
+		},
+		close: closeTimer()
+	},
+	transitions: [
+		transition("connect", "none", "status.connecting", "connecting"),
+		transition("writable", ["connecting", "failing"], "topology.writable", "ready"),
+		transition("unwritable", "ready", "topology.unwritable", "failing"),
+		transition("connect-failed", ["connecting", "failing"], "connect.failed", "failing", { timer: "connect_timeout" }),
+		...OPEN.map((state) => transition(`join-${state}`, state, "join", state)),
+		...OPEN.map((state) => transition(`pool-cleared-${state}`, state, "pool.cleared", state)),
+		...OPEN.map((state) => transition(`heartbeat-failed-${state}`, state, "heartbeat.failed", state)),
+		...OPEN.map((state) => transition(`client-error-${state}`, state, "client.error", state)),
+		...OPEN.map((state) => transition(`reissue-${state}`, state, "command.reissue", state)),
+		transition("close", [...SERVING], "close.request", "closing"),
+		transition("close-bound", "closing", "close.bound", "closing", { timer: "close" }),
+		transition("end", "closing", "status.end", "end")
+	]
+};
+//#endregion
+//#region src/mongodb/starting.ts
+/**
+* This poll is the poll of the checks that `MONGO_STARTING_KNOBS` fits. It is `STARTING_POLL` of
+* the core: each 5 s with a jitter of 20 %, and a timeout of 4 s (B6, O12). The poll does not depend on the driver.
+*/
+const MONGO_STARTING_POLL = STARTING_POLL;
+/**
+* These knobs are a declaration to start from, from what the cells of S1 measured on the driver
+* 7.7.0 on Node 24.21.0 against mongod 9.0.4. The runtime has no defaults: a service gives these
+* knobs, or its own. Each value holds the borders that the cells measured:
+* - `connect_bound` 5 s and `heartbeat_interval` 2 s: the write-off of a silent server came 7 s after
+*   its last answer, and the cells T01.border-off.75 and .76 held. At the defaults it came at 40.002 s.
+* - `request_timeout` 9.5 s: in the slowest poll of 10 s (O13). At the defaults the driver has no
+*   bound on a read, and only the write-off ends the command.
+* - `statement_timeout` 9 s: below `request_timeout`, thus the server ends a slow command first,
+*   with error 50 (O07).
+* - `client_retry_window` 30 s: after an election, the first write took 17 s to 18 s, and the band
+*   ended at 26.58 s (T11.defaults.10). The default of the driver, 30 s, holds that band.
+* - `checkout_timeout` 5 s: a full pool fails a checkout in a startup budget. At the defaults the wait has no bound.
+* - `pool_idle_expiry` 10 s: no cell measured it. It is the bound of O03 and O01 that the pg client
+*   uses: below a router that forgets an idle flow at 12 s. The driver applies it at the next checkout.
+* - `keepalive_idle` 30 s: the driver always turns keepalive on, at 120 s by default. This value
+*   refreshes a held idle connection through the NAT forms of the cells (240 s and 350 s).
+* - `max_connection_age` "infinite": the driver has no age for a connection.
+* - `close_bound` 2 s: behind a black hole the close of the driver waits for `endSessions`.
+* - `retrans_giveup_time` 924.6 s: the give-up of Linux at `tcp_retries2 = 15`. The cells measured 12.936 s at `tcp_retries2 = 5`.
+*/
+const MONGO_STARTING_KNOBS = {
+	connect_bound: {
+		value: 5,
+		unit: "s"
+	},
+	request_timeout: {
+		value: 9.5,
+		unit: "s"
+	},
+	statement_timeout: {
+		value: 9,
+		unit: "s"
+	},
+	heartbeat_interval: {
+		value: 2,
+		unit: "s"
+	},
+	client_retry_window: {
+		value: 30,
+		unit: "s"
+	},
+	checkout_timeout: {
+		value: 5,
+		unit: "s"
+	},
+	pool_idle_expiry: {
+		value: 10,
+		unit: "s"
+	},
+	keepalive_idle: {
+		value: 30,
+		unit: "s"
+	},
+	max_connection_age: {
+		value: "infinite",
+		unit: "s"
+	},
+	close_bound: {
+		value: 2,
+		unit: "s"
+	},
+	retrans_giveup_time: {
+		value: 924.6,
+		unit: "s"
+	}
+};
+//#endregion
+export { HELLO, MANIFESTATIONS, MONGO_CLIENT_MACHINE, MONGO_STARTING_KNOBS, MONGO_STARTING_POLL, STARTING_POLL, failureOutcome, firstDetector, helloCommandDial, helloJudge, mongoClient, mongoMeetings, mongoOptions, nodeMongo, specProblems, unwatched };
+
+//# sourceMappingURL=mongodb.js.map