@mark1russell7/machines 0.3.13 → 0.3.15

package/build/index.js

@@ -1349,7 +1349,7 @@ const UNDICI_CLIENT = machineSchema.parse({
 });
 //#endregion
 //#region src/ioredis-sentinel.ts
-const AT$6 = "ioredis 6.0.0 built";
+const AT$7 = "ioredis 6.0.0 built";
 /**
 * This document is the Sentinel path of ioredis 6.0.0. It tells how ioredis finds the primary of a
 * group through the Sentinels, loses it, and connects to the new one. The standalone states of
@@ -1370,43 +1370,43 @@ const IOREDIS_SENTINEL = machineSchema.parse({
 	},
 	sources: [
 		{
-			ref: `${AT$6}/connectors/SentinelConnector/index.js:46-121 connect (each Sentinel in turn, then sentinelRetryStrategy)`,
+			ref: `${AT$7}/connectors/SentinelConnector/index.js:46-121 connect (each Sentinel in turn, then sentinelRetryStrategy)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/connectors/SentinelConnector/index.js:145-151 resolveMaster (get-master-addr-by-name, then SENTINEL sentinels)`,
+			ref: `${AT$7}/connectors/SentinelConnector/index.js:145-151 resolveMaster (get-master-addr-by-name, then SENTINEL sentinels)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/connectors/SentinelConnector/index.js:175-212 connectToSentinel and resolve (one connection for each question, no retry)`,
+			ref: `${AT$7}/connectors/SentinelConnector/index.js:175-212 connectToSentinel and resolve (one connection for each question, no retry)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/connectors/SentinelConnector/index.js:27-39 check (the role of the ready check)`,
+			ref: `${AT$7}/connectors/SentinelConnector/index.js:27-39 check (the role of the ready check)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/connectors/SentinelConnector/FailoverDetector.js:6-43 (+switch-master, only with failoverDetector)`,
+			ref: `${AT$7}/connectors/SentinelConnector/FailoverDetector.js:6-43 (+switch-master, only with failoverDetector)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/redis/RedisOptions.js:9-57 (the defaults)`,
+			ref: `${AT$7}/redis/RedisOptions.js:9-57 (the defaults)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/redis/event_handler.js:294-355 closeHandler (retryStrategy, then maxRetriesPerRequest flushes the queue)`,
+			ref: `${AT$7}/redis/event_handler.js:294-355 closeHandler (retryStrategy, then maxRetriesPerRequest flushes the queue)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/redis/event_handler.js:364-449 readyHandler (retryAttempts back to 0, the resend, the offline queue)`,
+			ref: `${AT$7}/redis/event_handler.js:364-449 readyHandler (retryAttempts back to 0, the resend, the offline queue)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/Redis.js:123-240 _connect (connectTimeout, keepAlive) and :379-405 sendCommand (the offline queue)`,
+			ref: `${AT$7}/Redis.js:123-240 _connect (connectTimeout, keepAlive) and :379-405 sendCommand (the offline queue)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$6}/Redis.js:599-605 handleReconnection (reconnectOnError: null, thus a READONLY error goes to the caller)`,
+			ref: `${AT$7}/Redis.js:599-605 handleReconnection (reconnectOnError: null, thus a READONLY error goes to the caller)`,
 			rung: "implemented"
 		}
 	],
@@ -3566,7 +3566,7 @@ const IOREDIS_STATUS = machineSchema.parse(ioredis_status_default);
 const MANIFESTATIONS = z.record(z.string(), z.array(z.string())).parse(manifestations_default);
 //#endregion
 //#region src/mongo/mongod-replication.ts
-const AT$5 = "mongodb r9.0.4 src/mongo/db/repl";
+const AT$6 = "mongodb r9.0.4 src/mongo/db/repl";
 /**
 * This document is the replication of mongod 9.0.4. It gives one member of a replica set, its view
 * of the primary, and the election that it can hold. The states are the states of the member. The
@@ -3597,95 +3597,95 @@ const MONGOD_REPL = machineSchema.parse({
 	},
 	sources: [
 		{
-			ref: `${AT$5}/repl_set_config.idl:74-109 the settings: heartbeatIntervalMillis 2000, heartbeatTimeoutSecs 10, electionTimeoutMillis 10000, catchUpTimeoutMillis -1, catchUpTakeoverDelayMillis 30000`,
+			ref: `${AT$6}/repl_set_config.idl:74-109 the settings: heartbeatIntervalMillis 2000, heartbeatTimeoutSecs 10, electionTimeoutMillis 10000, catchUpTimeoutMillis -1, catchUpTakeoverDelayMillis 30000`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/repl_server_parameters.idl:320-328 replElectionTimeoutOffsetLimitFraction 0.15`,
+			ref: `${AT$6}/repl_server_parameters.idl:320-328 replElectionTimeoutOffsetLimitFraction 0.15`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/topology_coordinator.cpp:1058-1101 the heartbeat window and the timeout of each request, :1124-1147 the next heartbeat, :1239-1248 a member DOWN`,
+			ref: `${AT$6}/topology_coordinator.cpp:1058-1101 the heartbeat window and the timeout of each request, :1124-1147 the next heartbeat, :1239-1248 a member DOWN`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/topology_coordinator.h:62 kMaxHeartbeatRetries 2`,
+			ref: `${AT$6}/topology_coordinator.h:62 kMaxHeartbeatRetries 2`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_heartbeat.cpp:97-111 the random offset, :346-352 a heartbeat from the primary postpones the election, :1215-1271 the election timeout and its offset`,
+			ref: `${AT$6}/replication_coordinator_impl_heartbeat.cpp:97-111 the random offset, :346-352 a heartbeat from the primary postpones the election, :1215-1271 the election timeout and its offset`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/data_replicator_external_state_impl.cpp:70-81 an oplog batch that names a primary postpones the election`,
+			ref: `${AT$6}/data_replicator_external_state_impl.cpp:70-81 an oplog batch that names a primary postpones the election`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/delayable_timeout_callback.cpp:149-172 the offset changes at most once in its own length`,
+			ref: `${AT$6}/delayable_timeout_callback.cpp:149-172 the offset changes at most once in its own length`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/topology_coordinator.cpp:1440-1457 and :1476-1489 the liveness check: a primary that cannot see a majority steps down`,
+			ref: `${AT$6}/topology_coordinator.cpp:1440-1457 and :1476-1489 the liveness check: a primary that cannot see a majority steps down`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_heartbeat.cpp:1158-1188 the liveness check runs at the stalest member's last update plus the election timeout`,
+			ref: `${AT$6}/replication_coordinator_impl_heartbeat.cpp:1158-1188 the liveness check runs at the stalest member's last update plus the election timeout`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_elect_v1.cpp:189-226 the dry run, :268-382 the term, the durable vote and the real vote, :408-468 the win`,
+			ref: `${AT$6}/replication_coordinator_impl_elect_v1.cpp:189-226 the dry run, :268-382 the term, the durable vote and the real vote, :408-468 the win`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/vote_requester.cpp:96 a vote request times out at min(electionTimeoutMillis, 30 s), :160-177 a majority of yes votes ends the round`,
+			ref: `${AT$6}/vote_requester.cpp:96 a vote request times out at min(electionTimeoutMillis, 30 s), :160-177 a majority of yes votes ends the round`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/topology_coordinator.cpp:3741-3790 a member votes for each candidate whose data is not staler than its own, and only an arbiter refuses one because it sees a primary`,
+			ref: `${AT$6}/topology_coordinator.cpp:3741-3790 a member votes for each candidate whose data is not staler than its own, and only an arbiter refuses one because it sees a primary`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_catchup.cpp:35-85 the catch-up and its timeout, :110-133 it ends when each other member answered a heartbeat since the win, or failed one, :349-379 the win restarts each heartbeat`,
+			ref: `${AT$6}/replication_coordinator_impl_catchup.cpp:35-85 the catch-up and its timeout, :110-133 it ends when each other member answered a heartbeat since the win, or failed one, :349-379 the win restarts each heartbeat`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/topology_coordinator.cpp:3841-3849 and :3910-3932 a restarted heartbeat, and the latest optime that the catch-up waits for`,
+			ref: `${AT$6}/topology_coordinator.cpp:3841-3849 and :3910-3932 a restarted heartbeat, and the latest optime that the catch-up waits for`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl.cpp:1490-1570 the end of the drain: a reconfig of the term, then writes, :2580-2588 the hello of a primary that cannot write yet`,
+			ref: `${AT$6}/replication_coordinator_impl.cpp:1490-1570 the end of the drain: a reconfig of the term, then writes, :2580-2588 the hello of a primary that cannot write yet`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_step_up_step_down.cpp:64-329 replSetStepDown: the wait for a caught-up secondary, the step-down and the hand-off`,
+			ref: `${AT$6}/replication_coordinator_impl_step_up_step_down.cpp:64-329 replSetStepDown: the wait for a caught-up secondary, the step-down and the hand-off`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/repl_set_commands.cpp:545-561 stepDownSecs 60 and secondaryCatchUpPeriodSecs 10`,
+			ref: `${AT$6}/repl_set_commands.cpp:545-561 stepDownSecs 60 and secondaryCatchUpPeriodSecs 10`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl.idl:18-26 enableElectionHandoff true, and replication_coordinator_impl.cpp:2830-2873 the hand-off: replSetStepUp with skipDryRun`,
+			ref: `${AT$6}/replication_coordinator_impl.idl:18-26 enableElectionHandoff true, and replication_coordinator_impl.cpp:2830-2873 the hand-off: replSetStepUp with skipDryRun`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl.cpp:1516 the reconfig of the term, :4598 and :4750 a new config starts each heartbeat again`,
+			ref: `${AT$6}/replication_coordinator_impl.cpp:1516 the reconfig of the term, :4598 and :4750 a new config starts each heartbeat again`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl_heartbeat.cpp:367-376 a heartbeat response that moves a member's optime forward moves the commit point and wakes the writes that wait`,
+			ref: `${AT$6}/replication_coordinator_impl_heartbeat.cpp:367-376 a heartbeat response that moves a member's optime forward moves the commit point and wakes the writes that wait`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/oplog_fetcher.cpp:119-133 the awaitData timeout min(electionTimeoutMillis / 2, 30 s), :317-324 the socket timeout adds oplogNetworkTimeoutBufferSeconds, :640-647 the exhaust read`,
+			ref: `${AT$6}/oplog_fetcher.cpp:119-133 the awaitData timeout min(electionTimeoutMillis / 2, 30 s), :317-324 the socket timeout adds oplogNetworkTimeoutBufferSeconds, :640-647 the exhaust read`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/oplog_fetcher.cpp:395-441 an error makes a new cursor while restarts remain, :596-611 the new cursor sets the retried find timeout, :1073-1113 one restart after 5 ms`,
+			ref: `${AT$6}/oplog_fetcher.cpp:395-441 an error makes a new cursor while restarts remain, :596-611 the new cursor sets the retried find timeout, :1073-1113 one restart after 5 ms`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/repl_server_parameters.idl:121-126 oplogRetriedFindMaxSeconds 2, :234-244 oplogFetcherSteadyStateMaxFetcherRestarts 1, :344-351 oplogNetworkTimeoutBufferSeconds 5`,
+			ref: `${AT$6}/repl_server_parameters.idl:121-126 oplogRetriedFindMaxSeconds 2, :234-244 oplogFetcherSteadyStateMaxFetcherRestarts 1, :344-351 oplogNetworkTimeoutBufferSeconds 5`,
 			rung: "implemented"
 		},
 		{
@@ -3693,19 +3693,19 @@ const MONGOD_REPL = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/bgsync.cpp:395-447 a member without a sync source waits for new heartbeat data or 1 s (:971-976), and topology_coordinator.cpp:1124-1136 it sends its heartbeats each 500 ms`,
+			ref: `${AT$6}/bgsync.cpp:395-447 a member without a sync source waits for new heartbeat data or 1 s (:971-976), and topology_coordinator.cpp:1124-1136 it sends its heartbeats each 500 ms`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/replication_coordinator_impl.cpp:4947-4972 a member that loses its sync source starts each heartbeat again at once`,
+			ref: `${AT$6}/replication_coordinator_impl.cpp:4947-4972 a member that loses its sync source starts each heartbeat again at once`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/sync_source_feedback.cpp:37-47 the keepalive of the reporter min(electionTimeoutMillis / 2, 30 s), :39-40 the network timeout 30 s, :99-117 and :134-236 a new reporter only after the old one ends`,
+			ref: `${AT$6}/sync_source_feedback.cpp:37-47 the keepalive of the reporter min(electionTimeoutMillis / 2, 30 s), :39-40 the network timeout 30 s, :99-117 and :134-236 a new reporter only after the old one ends`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5}/reporter.cpp:113-117 a reporter ends when its command in flight ends, :119-169 a trigger, :195-228 each replSetUpdatePosition has the network timeout`,
+			ref: `${AT$6}/reporter.cpp:113-117 a reporter ends when its command in flight ends, :119-169 a trigger, :195-228 each replSetUpdatePosition has the network timeout`,
 			rung: "implemented"
 		},
 		{
@@ -4324,7 +4324,7 @@ const MONGOD_REPL = machineSchema.parse({
 });
 //#endregion
 //#region src/mongo/mongod-session.ts
-const AT$4 = "mongodb r9.0.4 src/mongo";
+const AT$5 = "mongodb r9.0.4 src/mongo";
 /**
 * This document is the hold of mongod 9.0.4 on one client connection, over its socket. `mongod`
 * turns keepalive on for each TCP session. It lowers two keepalive options of the socket to a
@@ -4351,27 +4351,27 @@ const MONGOD_SESSION = machineSchema.parse({
 	},
 	sources: [
 		{
-			ref: `${AT$4}/transport/asio/asio_session_impl.cpp:156-165 each TCP session: TCP_NODELAY, SO_KEEPALIVE, setSocketKeepAliveParams, failures at debug 3 in a release build`,
+			ref: `${AT$5}/transport/asio/asio_session_impl.cpp:156-165 each TCP session: TCP_NODELAY, SO_KEEPALIVE, setSocketKeepAliveParams, failures at debug 3 in a release build`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$4}/util/net/socket_utils.h:15-16 kMaxKeepIdleSecs 300 and kMaxKeepIntvlSecs 1, :19-22 the defaults of setSocketKeepAliveParams`,
+			ref: `${AT$5}/util/net/socket_utils.h:15-16 kMaxKeepIdleSecs 300 and kMaxKeepIntvlSecs 1, :19-22 the defaults of setSocketKeepAliveParams`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$4}/util/net/socket_utils.cpp:165-196 applyMax: read the option, and set the maximum only when the value is higher, :199-220 TCP_KEEPIDLE and TCP_KEEPINTVL, never TCP_KEEPCNT`,
+			ref: `${AT$5}/util/net/socket_utils.cpp:165-196 applyMax: read the option, and set the maximum only when the value is higher, :199-220 TCP_KEEPIDLE and TCP_KEEPINTVL, never TCP_KEEPCNT`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$4}/util/net/socket_utils.cpp:176-181 and :190-194 the log of a failed read or set, at the severity of the caller`,
+			ref: `${AT$5}/util/net/socket_utils.cpp:176-181 and :190-194 the log of a failed read or set, at the severity of the caller`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$4}/util/net/sock.cpp:135-142 the older socket path: SO_KEEPALIVE, then the same maximums, failures as errors`,
+			ref: `${AT$5}/util/net/sock.cpp:135-142 the older socket path: SO_KEEPALIVE, then the same maximums, failures as errors`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$4}/db/repl/replication_info.cpp:131-143 an awaitable hello waits until now + maxAwaitTimeMS on the precise clock, or a change of the topology`,
+			ref: `${AT$5}/db/repl/replication_info.cpp:131-143 an awaitable hello waits until now + maxAwaitTimeMS on the precise clock, or a change of the topology`,
 			rung: "implemented"
 		}
 	],
@@ -4533,7 +4533,7 @@ const MONGOD_SESSION = machineSchema.parse({
 });
 //#endregion
 //#region src/mongo/mongodb-node.ts
-const AT$3 = "mongodb 7.7.0 src";
+const AT$4 = "mongodb 7.7.0 src";
 /**
 * This document is the MongoDB Node driver 7.7.0, for one server of a replica set. It gives one
 * connection of the driver by its role, and the timers that act on it. The roles are the monitor
@@ -4560,75 +4560,75 @@ const MONGODB_NODE = machineSchema.parse({
 	},
 	sources: [
 		{
-			ref: `${AT$3}/connection_string.ts:804-807 connectTimeoutMS 30000, :850-853 heartbeatFrequencyMS 10000, :934-937 minHeartbeatFrequencyMS 500`,
+			ref: `${AT$4}/connection_string.ts:804-807 connectTimeoutMS 30000, :850-853 heartbeatFrequencyMS 10000, :934-937 minHeartbeatFrequencyMS 500`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/connection_string.ts:1100-1103 serverSelectionTimeoutMS 30000, :1107-1111 socketTimeoutMS 0, :1178-1182 waitQueueTimeoutMS 0`,
+			ref: `${AT$4}/connection_string.ts:1100-1103 serverSelectionTimeoutMS 30000, :1107-1111 socketTimeoutMS 0, :1178-1182 waitQueueTimeoutMS 0`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/connection_string.ts:896-898 maxConnecting 2, :906-908 maxIdleTimeMS 0, :910-912 maxPoolSize 100, :930-933 minPoolSize 0, :1075-1082 retryReads and retryWrites true, :1089-1091 serverMonitoringMode auto`,
+			ref: `${AT$4}/connection_string.ts:896-898 maxConnecting 2, :906-908 maxIdleTimeMS 0, :910-912 maxPoolSize 100, :930-933 minPoolSize 0, :1075-1082 retryReads and retryWrites true, :1089-1091 serverMonitoringMode auto`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/cmap/connect.ts:291 DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS 120000, :336-338 keepAlive and noDelay, :378-417 makeSocket: setKeepAlive, setNoDelay, setTimeout(connectTimeoutMS), :432-438 the connect timeout`,
+			ref: `${AT$4}/cmap/connect.ts:291 DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS 120000, :336-338 keepAlive and noDelay, :378-417 makeSocket: setKeepAlive, setNoDelay, setTimeout(connectTimeoutMS), :432-438 the connect timeout`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/cmap/connect.ts:117-120 the handshake reads with socketTimeoutMS = connectTimeoutMS`,
+			ref: `${AT$4}/cmap/connect.ts:117-120 the handshake reads with socketTimeoutMS = connectTimeoutMS`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/monitor.ts:245-259 the streaming protocol, :338-371 the awaitable hello: maxAwaitTimeMS = heartbeatFrequencyMS, socketTimeoutMS = connectTimeoutMS + maxAwaitTimeMS`,
+			ref: `${AT$4}/sdam/monitor.ts:245-259 the streaming protocol, :338-371 the awaitable hello: maxAwaitTimeMS = heartbeatFrequencyMS, socketTimeoutMS = connectTimeoutMS + maxAwaitTimeMS`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/monitor.ts:273-293 a failed heartbeat: ResetPool, and InterruptInUseConnections for a timeout`,
+			ref: `${AT$4}/sdam/monitor.ts:273-293 a failed heartbeat: ResetPool, and InterruptInUseConnections for a timeout`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/monitor.ts:175-194 reset: the next check after heartbeatFrequencyMS, :609-636 wake: no check sooner than minHeartbeatFrequencyMS, :668-691 the next check after heartbeatFrequencyMS`,
+			ref: `${AT$4}/sdam/monitor.ts:175-194 reset: the next check after heartbeatFrequencyMS, :609-636 wake: no check sooner than minHeartbeatFrequencyMS, :668-691 the next check after heartbeatFrequencyMS`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/monitor.ts:490-565 the RTT pinger: its own connection, a hello each heartbeatFrequencyMS, no socket timeout`,
+			ref: `${AT$4}/sdam/monitor.ts:490-565 the RTT pinger: its own connection, a hello each heartbeatFrequencyMS, no socket timeout`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/cmap/connection.ts:328-334 a socket timeout, 1 ms later, is a MongoNetworkTimeoutError, :461-505 the socket timeout of a command, set again at each reply`,
+			ref: `${AT$4}/cmap/connection.ts:328-334 a socket timeout, 1 ms later, is a MongoNetworkTimeoutError, :461-505 the socket timeout of a command, set again at each reply`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/server.ts:186 resetServer, :390-444 handleError, :450-515 decorateCommandError, :532-546 markServerUnknown: a network error that is not a timeout resets the monitor`,
+			ref: `${AT$4}/sdam/server.ts:186 resetServer, :390-444 handleError, :450-515 decorateCommandError, :532-546 markServerUnknown: a network error that is not a timeout resets the monitor`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/topology.ts:559 the selection timeout, :568-572 and :635-664 MongoServerSelectionError, :862-888 updateServers clears the pool, :1082-1089 a waiting selection wakes each monitor`,
+			ref: `${AT$4}/sdam/topology.ts:559 the selection timeout, :568-572 and :635-664 MongoServerSelectionError, :862-888 updateServers clears the pool, :1082-1089 a waiting selection wakes each monitor`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/sdam/topology_description.ts:458-467 a primary that another primary replaces is Unknown, and nothing clears its pool`,
+			ref: `${AT$4}/sdam/topology_description.ts:458-467 a primary that another primary replaces is Unknown, and nothing clears its pool`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/cmap/connection_pool.ts:417-468 clear, :475-481 interruptInUseConnections: PoolClearedOnNetworkError, :584 a connection idle for maxIdleTimeMS is perished at the next check-out`,
+			ref: `${AT$4}/cmap/connection_pool.ts:417-468 clear, :475-481 interruptInUseConnections: PoolClearedOnNetworkError, :584 a connection idle for maxIdleTimeMS is perished at the next check-out`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/cmap/errors.ts:37-84 PoolClearedError and PoolClearedOnNetworkError, with the label PoolRequestedRetry`,
+			ref: `${AT$4}/cmap/errors.ts:37-84 PoolClearedError and PoolClearedOnNetworkError, with the label PoolRequestedRetry`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/operations/execute_operation.ts:252-279 two attempts for a retryable read or write, :375-380 the retry selects a server again, :442-445 canRetry`,
+			ref: `${AT$4}/operations/execute_operation.ts:252-279 two attempts for a retryable read or write, :375-380 the retry selects a server again, :442-445 canRetry`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/error.ts:1377-1394 the retryable codes, :1431-1436 isRetryableWriteError: RetryableWriteError or PoolRequestedRetry`,
+			ref: `${AT$4}/error.ts:1377-1394 the retryable codes, :1431-1436 isRetryableWriteError: RetryableWriteError or PoolRequestedRetry`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$3}/timeout.ts:362-372 the legacy timeout context: the selection timeout, and no check-out timeout at waitQueueTimeoutMS 0`,
+			ref: `${AT$4}/timeout.ts:362-372 the legacy timeout context: the selection timeout, and no check-out timeout at waitQueueTimeoutMS 0`,
 			rung: "implemented"
 		},
 		{
@@ -6308,7 +6308,7 @@ const HIKARICP_PGJDBC = machineSchema.parse({
 });
 //#endregion
 //#region src/pg/node-postgres.ts
-const AT$2 = "pg 8.23.1 lib";
+const AT$3 = "pg 8.23.1 lib";
 const POOL = "pg-pool 3.14.0";
 /**
 * This document is node-postgres 8.23.1 (the npm package pg) with pg-pool 3.14.0, for one client
@@ -6350,75 +6350,75 @@ const NODE_POSTGRES = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/defaults.js:42 max 10 and :46 idleTimeoutMillis 30000: no line of pg or pg-pool reads them, thus a pool does not use them`,
+			ref: `${AT$3}/defaults.js:42 max 10 and :46 idleTimeoutMillis 30000: no line of pg or pg-pool reads them, thus a pool does not use them`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/defaults.js:65, :69, :73 and :76 statement_timeout, lock_timeout, idle_in_transaction_session_timeout and query_timeout are false`,
+			ref: `${AT$3}/defaults.js:65, :69, :73 and :76 statement_timeout, lock_timeout, idle_in_transaction_session_timeout and query_timeout are false`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/defaults.js:63-76 the comments of pg: each of the four is in milliseconds, false is no limit, and query_timeout is on the client side`,
+			ref: `${AT$3}/defaults.js:63-76 the comments of pg: each of the four is in milliseconds, false is no limit, and query_timeout is on the client side`,
 			rung: "documented"
 		},
 		{
-			ref: `${AT$2}/connection-parameters.js:9-23 val: the config, else the default of pg, :121-124 the three timeouts of the server and query_timeout, with no environment variable`,
+			ref: `${AT$3}/connection-parameters.js:9-23 val: the config, else the default of pg, :121-124 the three timeouts of the server and query_timeout, with no environment variable`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:89-98 the Connection gets keepAlive false and keepAliveInitialDelayMillis 0 when the config does not give them, :116 connectionTimeoutMillis 0`,
+			ref: `${AT$3}/client.js:89-98 the Connection gets keepAlive false and keepAliveInitialDelayMillis 0 when the config does not give them, :116 connectionTimeoutMillis 0`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/stream.js:20-24 and :78-83 outside Cloudflare Workers, the socket is a new net.Socket with no option`,
+			ref: `${AT$3}/stream.js:20-24 and :78-83 outside Cloudflare Workers, the socket is a new net.Socket with no option`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/connection.js:40-52 setNoDelay(true) before the connect, and setKeepAlive(true, keepAliveInitialDelayMillis) at the connect only when keepAlive is true, :54-65 the error and the close of the socket`,
+			ref: `${AT$3}/connection.js:40-52 setNoDelay(true) before the connect, and setKeepAlive(true, keepAliveInitialDelayMillis) at the connect only when keepAlive is true, :54-65 the error and the close of the socket`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:167-176 and :702-737 are the only timers of the client, and connection.js has none: the client sends nothing by itself on an idle connection`,
+			ref: `${AT$3}/client.js:167-176 and :702-737 are the only timers of the client, and connection.js has none: the client sends nothing by itself on an idle connection`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:153-230 _connect: no second connect, the connect timer of the client ('timeout expired'), and 'Connection terminated unexpectedly' for an end that the client did not ask for`,
+			ref: `${AT$3}/client.js:153-230 _connect: no second connect, the connect timer of the client ('timeout expired'), and 'Connection terminated unexpectedly' for an end that the client did not ask for`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:373-387 the first ReadyForQuery ends the connect and clears the timer, :398-423 an error before it goes to the connect callback, and an error after it makes the client unqueryable`,
+			ref: `${AT$3}/client.js:373-387 the first ReadyForQuery ends the connect and clears the timer, :398-423 an error before it goes to the connect callback, and an error after it makes the client unqueryable`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:426-442 an ErrorResponse fails the active query only, and with no active query it is an error of the client`,
+			ref: `${AT$3}/client.js:426-442 an ErrorResponse fails the active query only, and with no active query it is an error of the client`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/connection.js:137-145 and pg-protocol 1.16.1 dist/parser.js:142-144, :296-323 an ErrorResponse is a DatabaseError, with the severity and the code that the server gives`,
+			ref: `${AT$3}/connection.js:137-145 and pg-protocol 1.16.1 dist/parser.js:142-144, :296-323 an ErrorResponse is a DatabaseError, with the severity and the code that the server gives`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:133-151 _errorAllQueries: each query of the client fails with the same error, on the next tick`,
+			ref: `${AT$3}/client.js:133-151 _errorAllQueries: each query of the client fails with the same error, on the next tick`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/query.js:122-150 a query gives its error or its result to its callback, at the error or at the ReadyForQuery`,
+			ref: `${AT$3}/query.js:122-150 a query gives its error or its result to its callback, at the error or at the ReadyForQuery`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:702-737 query_timeout: a Node timer for each query, 'Query read timeout'. The client sends no cancel, and it keeps the active query`,
+			ref: `${AT$3}/client.js:702-737 query_timeout: a Node timer for each query, 'Query read timeout'. The client sends no cancel, and it keeps the active query`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:616-641 the next query goes only after a ReadyForQuery, :765-777 a query on an unqueryable or ended client fails at once`,
+			ref: `${AT$3}/client.js:616-641 the next query goes only after a ReadyForQuery, :765-777 a query on an unqueryable or ended client fails at once`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:799-836 end: a dead socket or an active query destroys the socket, else connection.js:217-227 sends Terminate and ends the socket`,
+			ref: `${AT$3}/client.js:799-836 end: a dead socket or an active query destroys the socket, else connection.js:217-227 sends Terminate and ends the socket`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$2}/client.js:543-572 getStartupConf: statement_timeout, lock_timeout and idle_in_transaction_session_timeout go to the server only when they are set`,
+			ref: `${AT$3}/client.js:543-572 getStartupConf: statement_timeout, lock_timeout and idle_in_transaction_session_timeout go to the server only when they are set`,
 			rung: "implemented"
 		},
 		{
@@ -8814,7 +8814,7 @@ const PGPOOL_SESSION = machineSchema.parse({
 });
 //#endregion
 //#region src/pg/postgres-session.ts
-const AT$1 = "postgresql REL_17_11 src";
+const AT$2 = "postgresql REL_17_11 src";
 const DOC = "postgresql REL_17_11 doc/src/sgml";
 /**
 * This document is the hold of a PostgreSQL 17.11 backend on one client connection, over its TCP
@@ -8854,163 +8854,163 @@ const POSTGRES_SESSION = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/backend_startup.c:157-161 BackendInitialize calls pq_init in the backend, before the startup packet`,
+			ref: `${AT$2}/backend/tcop/backend_startup.c:157-161 BackendInitialize calls pq_init in the backend, before the startup packet`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:793-817 AcceptConnection in the postmaster, :180 the Port starts at zeros, :195-220 TCP_NODELAY and SO_KEEPALIVE on each socket that is not AF_UNIX, a failure is FATAL, :264-274 then the four TCP GUCs, a failure is a LOG only`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:793-817 AcceptConnection in the postmaster, :180 the Port starts at zeros, :195-220 TCP_NODELAY and SO_KEEPALIVE on each socket that is not AF_UNIX, a failure is FATAL, :264-274 then the four TCP GUCs, a failure is a LOG only`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:1663-1711 pq_setkeepalivesidle: no call at a value equal to the Port's, and 0 sets the value that getsockopt read first; :1748-1795, :1827-1870 and :1902-1945 the same for TCP_KEEPINTVL, TCP_KEEPCNT and TCP_USER_TIMEOUT`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:1663-1711 pq_setkeepalivesidle: no call at a value equal to the Port's, and 0 sets the value that getsockopt read first; :1748-1795, :1827-1870 and :1902-1945 the same for TCP_KEEPINTVL, TCP_KEEPCNT and TCP_USER_TIMEOUT`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:87-90 TCP_KEEPIDLE on Linux, :1947-2047 an assign hook sets the socket of the session at once, and a show hook reads the kernel`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:87-90 TCP_KEEPIDLE on Linux, :1947-2047 an assign hook sets the socket of the session at once, and a show hook reads the kernel`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/misc/guc_tables.c:3452-3461 tcp_keepalives_idle 0 s, :3463-3472 tcp_keepalives_interval 0 s, :3485-3495 tcp_keepalives_count 0, :3587-3596 tcp_user_timeout 0 ms: each PGC_USERSET, 0 to INT_MAX, 0 is the system default`,
+			ref: `${AT$2}/backend/utils/misc/guc_tables.c:3452-3461 tcp_keepalives_idle 0 s, :3463-3472 tcp_keepalives_interval 0 s, :3485-3495 tcp_keepalives_count 0, :3587-3596 tcp_user_timeout 0 ms: each PGC_USERSET, 0 to INT_MAX, 0 is the system default`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/misc/guc_tables.c:2611-2620 statement_timeout, :2622-2631 lock_timeout, :2633-2642 idle_in_transaction_session_timeout, :2644-2653 transaction_timeout, :2655-2664 idle_session_timeout: each 0 ms, 0 to INT_MAX, PGC_USERSET, 0 turns it off`,
+			ref: `${AT$2}/backend/utils/misc/guc_tables.c:2611-2620 statement_timeout, :2622-2631 lock_timeout, :2633-2642 idle_in_transaction_session_timeout, :2644-2653 transaction_timeout, :2655-2664 idle_session_timeout: each 0 ms, 0 to INT_MAX, PGC_USERSET, 0 turns it off`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/misc/guc_tables.c:2774-2783 authentication_timeout 60 s, 1 to 600, PGC_SIGHUP; :3632-3641 client_connection_check_interval 0 ms, 0 to INT_MAX, PGC_USERSET`,
+			ref: `${AT$2}/backend/utils/misc/guc_tables.c:2774-2783 authentication_timeout 60 s, 1 to 600, PGC_SIGHUP; :3632-3641 client_connection_check_interval 0 ms, 0 to INT_MAX, PGC_USERSET`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/storage/lmgr/proc.c:58-62, backend/tcop/postgres.c:106 and backend/postmaster/postmaster.c:228 the C defaults agree: 0 ms for each timeout, 0 ms for the client check, 60 s for authentication`,
+			ref: `${AT$2}/backend/storage/lmgr/proc.c:58-62, backend/tcop/postgres.c:106 and backend/postmaster/postmaster.c:228 the C defaults agree: 0 ms for each timeout, 0 ms for the client check, 60 s for authentication`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/include/utils/timeout.h:3-4 and :23-43 one SIGALRM for each timeout id, STARTUP_PACKET_TIMEOUT to CLIENT_CONNECTION_CHECK_TIMEOUT`,
+			ref: `${AT$2}/include/utils/timeout.h:3-4 and :23-43 one SIGALRM for each timeout id, STARTUP_PACKET_TIMEOUT to CLIENT_CONNECTION_CHECK_TIMEOUT`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/misc/timeout.c:559-575 enable_timeout_after: the deadline is the current time + the delay in ms, :209-350 schedule_alarm: setitimer(ITIMER_REAL) for the nearest deadline, :363-453 handle_sig_alarm sets the latch and calls each handler that is due`,
+			ref: `${AT$2}/backend/utils/misc/timeout.c:559-575 enable_timeout_after: the deadline is the current time + the delay in ms, :209-350 schedule_alarm: setitimer(ITIMER_REAL) for the nearest deadline, :363-453 handle_sig_alarm sets the latch and calls each handler that is due`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/init/postinit.c:770-782 the handlers of a backend, :1374-1407 the statement timer sends SIGINT, or SIGTERM in authentication, and the lock timer sends SIGINT, :1409-1447 each other handler sets a flag and the latch`,
+			ref: `${AT$2}/backend/utils/init/postinit.c:770-782 the handlers of a backend, :1374-1407 the statement timer sends SIGINT, or SIGTERM in authentication, and the lock timer sends SIGINT, :1409-1447 each other handler sets a flag and the latch`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:2999-3023 die (SIGTERM) sets ProcDiePending, :3029-3043 StatementCancelHandler (SIGINT) sets QueryCancelPending, :4292-4294 the two handlers`,
+			ref: `${AT$2}/backend/tcop/postgres.c:2999-3023 die (SIGTERM) sets ProcDiePending, :3029-3043 StatementCancelHandler (SIGINT) sets QueryCancelPending, :4292-4294 the two handlers`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:3271-3319 ProcessInterrupts acts on a die request first: FATAL 57014 "canceling authentication due to timeout" in authentication, else FATAL 57P01 "terminating connection due to administrator command"`,
+			ref: `${AT$2}/backend/tcop/postgres.c:3271-3319 ProcessInterrupts acts on a die request first: FATAL 57014 "canceling authentication due to timeout" in authentication, else FATAL 57P01 "terminating connection due to administrator command"`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:3321-3350 then the client check, then a lost connection: FATAL 08006 "connection to client lost", with no message to the client`,
+			ref: `${AT$2}/backend/tcop/postgres.c:3321-3350 then the client check, then a lost connection: FATAL 08006 "connection to client lost", with no message to the client`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:3372-3430 a cancel: ERROR 55P03 "canceling statement due to lock timeout", ERROR 57014 "canceling statement due to statement timeout"`,
+			ref: `${AT$2}/backend/tcop/postgres.c:3372-3430 a cancel: ERROR 55P03 "canceling statement due to lock timeout", ERROR 57014 "canceling statement due to statement timeout"`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:3435-3477 FATAL 25P03 "terminating connection due to idle-in-transaction timeout", FATAL 25P04 "terminating connection due to transaction timeout", FATAL 57P05 "terminating connection due to idle-session timeout"`,
+			ref: `${AT$2}/backend/tcop/postgres.c:3435-3477 FATAL 25P03 "terminating connection due to idle-in-transaction timeout", FATAL 25P04 "terminating connection due to transaction timeout", FATAL 57P05 "terminating connection due to idle-session timeout"`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/errcodes.txt:106-107 08003 and 08006, :111 08P01, :254-255 25P03 and 25P04, :421 55P03, :428-429 57014 and 57P01, :433 57P05`,
+			ref: `${AT$2}/backend/utils/errcodes.txt:106-107 08003 and 08006, :111 08P01, :254-255 25P03 and 25P04, :421 55P03, :428-429 57014 and 57P01, :433 57P05`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:4618-4706 at ReadyForQuery the backend arms idle_in_transaction_session_timeout in a transaction block, open or aborted, and idle_session_timeout outside one; :4714-4750 after a message it disarms them, then checks for interrupts`,
+			ref: `${AT$2}/backend/tcop/postgres.c:4618-4706 at ReadyForQuery the backend arms idle_in_transaction_session_timeout in a transaction block, open or aborted, and idle_session_timeout outside one; :4714-4750 after a message it disarms them, then checks for interrupts`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:2770-2796 start_xact_command arms statement_timeout and the client check, each only when not active, :2798-2802 finish_xact_command disarms statement_timeout, :5251-5278 no statement timer when statement_timeout >= transaction_timeout > 0`,
+			ref: `${AT$2}/backend/tcop/postgres.c:2770-2796 start_xact_command arms statement_timeout and the client check, each only when not active, :2798-2802 finish_xact_command disarms statement_timeout, :5251-5278 no statement timer when statement_timeout >= transaction_timeout > 0`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/adt/misc.c:391-412 pg_sleep: CHECK_FOR_INTERRUPTS before each WaitLatch on the latch of the backend, thus the SIGALRM of a timeout ends its wait`,
+			ref: `${AT$2}/backend/utils/adt/misc.c:391-412 pg_sleep: CHECK_FOR_INTERRUPTS before each WaitLatch on the latch of the backend, thus the SIGALRM of a timeout ends its wait`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:4446-4502 an ERROR: disable_all_timeouts, the error to the client, AbortCurrentTransaction; :4562-4563 then ReadyForQuery`,
+			ref: `${AT$2}/backend/tcop/postgres.c:4446-4502 an ERROR: disable_all_timeouts, the error to the client, AbortCurrentTransaction; :4562-4563 then ReadyForQuery`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/access/transam/xact.c:2174-2176 StartTransaction arms transaction_timeout, :2315-2317, :2592-2594 and :2768-2770 commit, prepare and abort disarm it, :3472-3477 an error in a transaction block aborts the transaction and keeps the block`,
+			ref: `${AT$2}/backend/access/transam/xact.c:2174-2176 StartTransaction arms transaction_timeout, :2315-2317, :2592-2594 and :2768-2770 commit, prepare and abort disarm it, :3472-3477 an error in a transaction block aborts the transaction and keeps the block`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/storage/lmgr/proc.c:1292-1307 ProcSleep arms lock_timeout with the deadlock timer, :1652-1666 and disarms it after the wait`,
+			ref: `${AT$2}/backend/storage/lmgr/proc.c:1292-1307 ProcSleep arms lock_timeout with the deadlock timer, :1652-1666 and disarms it after the wait`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:3652-3661 a client_connection_check_interval above 0 needs a wait set that reports a close`,
+			ref: `${AT$2}/backend/tcop/postgres.c:3652-3661 a client_connection_check_interval above 0 needs a wait set that reports a close`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:2049-2084 pq_check_connection: a wait of 0 ms for WL_SOCKET_CLOSED`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:2049-2084 pq_check_connection: a wait of 0 ms for WL_SOCKET_CLOSED`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/storage/ipc/latch.c:72-85 epoll where sys/epoll.h exists, :1131-1156 WL_SOCKET_CLOSED adds EPOLLRDHUP, and EPOLLERR and EPOLLHUP are always on, :1661-1680 EPOLLERR or EPOLLHUP make the socket readable, writable and closed, :2253-2263 epoll can report a close`,
+			ref: `${AT$2}/backend/storage/ipc/latch.c:72-85 epoll where sys/epoll.h exists, :1131-1156 WL_SOCKET_CLOSED adds EPOLLRDHUP, and EPOLLERR and EPOLLHUP are always on, :1661-1680 EPOLLERR or EPOLLHUP make the socket readable, writable and closed, :2253-2263 epoll can report a close`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/be-secure.c:174-261 secure_read and :300-370 secure_write: a wait for the socket or the latch with no timeout; at the latch, ProcessClientReadInterrupt or ProcessClientWriteInterrupt; :234-237 and :343-346 FATAL 57P01 at the death of the postmaster`,
+			ref: `${AT$2}/backend/libpq/be-secure.c:174-261 secure_read and :300-370 secure_write: a wait for the socket or the latch with no timeout; at the latch, ProcessClientReadInterrupt or ProcessClientWriteInterrupt; :234-237 and :343-346 FATAL 57P01 at the death of the postmaster`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:513-548 ProcessClientReadInterrupt: each interrupt in the wait for a command, a die request in another read; :559-600 ProcessClientWriteInterrupt: a die request only, with no message to the client`,
+			ref: `${AT$2}/backend/tcop/postgres.c:513-548 ProcessClientReadInterrupt: each interrupt in the wait for a command, a die request in another read; :559-600 ProcessClientWriteInterrupt: a die request only, with no message to the client`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:287-297 the socket has O_NONBLOCK, and the latch gives the waits; :896-956 pq_recvbuf: 0 bytes or an error is EOF, and an error logs COMMERROR "could not receive data from client: %m"`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:287-297 the socket has O_NONBLOCK, and the latch gives the waits; :896-956 pq_recvbuf: 0 bytes or an error is EOF, and an error logs COMMERROR "could not receive data from client: %m"`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:364-396 SocketBackend: EOF in a transaction logs COMMERROR 08006 "unexpected EOF on client connection with an open transaction", else DEBUG1 08003; :4988-5016 EOF or Terminate: proc_exit(0)`,
+			ref: `${AT$2}/backend/tcop/postgres.c:364-396 SocketBackend: EOF in a transaction logs COMMERROR 08006 "unexpected EOF on client connection with an open transaction", else DEBUG1 08003; :4988-5016 EOF or Terminate: proc_exit(0)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/access/transam/xact.c:383-396 IsTransactionState is TRANS_INPROGRESS only; backend/utils/init/postinit.c:1360-1371 ShutdownPostgres aborts the transaction at exit`,
+			ref: `${AT$2}/backend/access/transam/xact.c:383-396 IsTransactionState is TRANS_INPROGRESS only; backend/utils/init/postinit.c:1360-1371 ShutdownPostgres aborts the transaction at exit`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:1275-1336 a full buffer flushes, and the flush waits for the socket, :1358-1423 internal_flush_buffer: an error logs COMMERROR "could not send data to client: %m" once for each errno, drops the buffer and sets ClientConnectionLost`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:1275-1336 a full buffer flushes, and the flush waits for the socket, :1358-1423 internal_flush_buffer: an error logs COMMERROR "could not send data to client: %m" once for each errno, drops the buffer and sets ClientConnectionLost`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/postgres.c:4310-4316 the backend ignores SIGPIPE`,
+			ref: `${AT$2}/backend/tcop/postgres.c:4310-4316 the backend ignores SIGPIPE`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/include/utils/elog.h:31-38 COMMERROR is LOG_SERVER_ONLY; backend/utils/error/elog.c:205-228 it goes to the log at log_min_messages WARNING (guc_tables.c:534), and DEBUG1 does not`,
+			ref: `${AT$2}/include/utils/elog.h:31-38 COMMERROR is LOG_SERVER_ONLY; backend/utils/error/elog.c:205-228 it goes to the log at log_min_messages WARNING (guc_tables.c:534), and DEBUG1 does not`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/error/elog.c:245-262 and :1726-1732 an error goes to the client while the output is DestRemote, :3643-3651 the backend flushes it, :559-590 FATAL ends the process with proc_exit(1)`,
+			ref: `${AT$2}/backend/utils/error/elog.c:245-262 and :1726-1732 an error goes to the client while the output is DestRemote, :3643-3651 the backend flushes it, :559-590 FATAL ends the process with proc_exit(1)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/pqcomm.c:347-392 socket_close keeps the socket open until the process exits`,
+			ref: `${AT$2}/backend/libpq/pqcomm.c:347-392 socket_close keeps the socket open until the process exits`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/backend_startup.c:237-253 the startup timer: authentication_timeout, after the DNS lookup, :311-314 the end of the startup packet disarms it, :895-922 its handler and SIGTERM call _exit(1), with no log and no message`,
+			ref: `${AT$2}/backend/tcop/backend_startup.c:237-253 the startup timer: authentication_timeout, after the DNS lookup, :311-314 the end of the startup packet disarms it, :895-922 its handler and SIGTERM call _exit(1), with no log and no message`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/tcop/backend_startup.c:460-519 ProcessStartupPacket: no byte is a silent end, a part of a packet logs COMMERROR 08P01 "incomplete startup packet"; :328-333 proc_exit(0)`,
+			ref: `${AT$2}/backend/tcop/backend_startup.c:460-519 ProcessStartupPacket: no byte is a silent end, a part of a packet logs COMMERROR 08P01 "incomplete startup packet"; :328-333 proc_exit(0)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/utils/init/postinit.c:235-251 PerformAuthentication arms the statement timer at authentication_timeout * 1000 ms, :305 ClientAuthInProgress ends after it, :1210-1215 the GUCs of the startup packet apply after it`,
+			ref: `${AT$2}/backend/utils/init/postinit.c:235-251 PerformAuthentication arms the statement timer at authentication_timeout * 1000 ms, :305 ClientAuthInProgress ends after it, :1210-1215 the GUCs of the startup packet apply after it`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$1}/backend/libpq/auth.c:260-271 an EOF from the client in authentication: proc_exit(0), with no log; :714-744 recv_password_packet gives an EOF as NULL`,
+			ref: `${AT$2}/backend/libpq/auth.c:260-271 an EOF from the client in authentication: proc_exit(0), with no log; :714-744 recv_password_packet gives an EOF as NULL`,
 			rung: "implemented"
 		},
 		{
@@ -11038,6 +11038,1447 @@ const PROCEDURES_WS_SERVER = machineSchema.parse({
 	}
 });
 //#endregion
+//#region src/rabbit/amqplib.ts
+const AT$1 = "amqplib 2.2.0 lib";
+/**
+* This document is amqplib 2.2.0 on Node, for one connection to a broker of AMQP 0-9-1 and one channel
+* on it. It gives the states of the connection, from its connect to its end, and the timers that act on
+* it.
+*
+* At the defaults, amqplib takes the heartbeat that the broker proposes: 60 s for RabbitMQ 4.3. Each 30 s
+* it sends a heartbeat frame when it sent nothing since the check before. Its own heartbeat counts as a
+* send, thus an idle connection sends one each 60 s. Each 60 s it checks that the broker sent
+* something, and after two checks with nothing it ends the connection: 'Heartbeat timeout'. That end
+* comes 2 to 3 heartbeats after the last data.
+*
+* amqplib sets TCP_NODELAY only when the caller asks for it, thus Nagle is on at the defaults. It sets no
+* keepalive and no connect timeout. An RPC of a channel has no timer. The package does not connect again
+* by itself. Its recovery is a wrapper that this document does not hold.
+*/
+const AMQPLIB = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "amqplib",
+	title: "amqplib 2.2.0: one connection to an AMQP 0-9-1 broker, its heartbeat and an RPC of its channel",
+	layer: "driver",
+	version: "2.2.0",
+	conditions: {
+		amqplib: "2.2.0",
+		node: "24.21.0",
+		client: "amqplib.connect with a URL of amqp: and the socket options of the caller, and one channel of the promise API",
+		transport: "TCP to a host and port, with no TLS",
+		broker: "a broker that proposes a heartbeat in connection.tune: 60 s for RabbitMQ 4.3"
+	},
+	sources: [
+		{
+			ref: `${AT$1}/connect.js:62 the heartbeat of the URL query: null when the URL has none`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connect.js:90-94 the socket options: noDelay and keepAlive are false and timeout is undefined unless the caller gives them, and keepAliveDelay is 0`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connect.js:150-153 at the connect, setNoDelay(noDelay), thus false at the defaults, and setKeepAlive only when keepAlive is true`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connect.js:155-160 and :179-185 a timeout of the caller bounds the connect and the handshake ('connect ETIMEDOUT'), and the open turns it off`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:150-176 connection.tune: with no heartbeat of the caller, the heartbeat of the broker; with 0, no heartbeat; else the smaller of the two`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:189-198 open-ok starts the heartbeat with the tuned value, and 0 starts none (:367-368)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:203-216 an end or an error of the socket in the handshake fails the connect ('Socket closed abruptly during opening handshake'). After the open, an error of the socket is an error of the connection, and an end of the socket is 'Unexpected close'`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:296-303 onSocketError emits error one time, then the connection goes to closed`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:341-354 toClosed stops the heartbeat, ends the socket (stream.end: a FIN, not a reset) and emits close`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:367-381 the heartbeat: on timeout, error 'Heartbeat timeout' and then closed; on beat, a heartbeat frame`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/heartbeat.js:56-77 each interval / 2 the send check sends a heartbeat when nothing went out since the check before. Each interval the receive check counts a miss when nothing came in, and two misses in a row are a timeout`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/heartbeat.js:19-25 the comment of amqplib: the timeout comes between two and three intervals after the activity stops`,
+			rung: "documented"
+		},
+		{
+			ref: `${AT$1}/connection.js:452-471 checkSend and checkRecv read and clear a flag. Each send sets the send flag, a heartbeat too: an idle connection sends one heartbeat each interval`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:540-551 each read of bytes from the socket sets the receive flag: a heartbeat frame of the broker counts as activity (:585)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/connection.js:587-600 a connection.close of the broker: close-ok, then closed with 'Connection closed: <code>'. Only a fatal code is an error too, and 320 CONNECTION_FORCED is not (:645-653)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/channel.js:97-123 an RPC of a channel has no timer: it waits for its reply, or for the end of the channel`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$1}/channel.js:155-159 the end of the channel fails the RPC in flight: 'Channel ended, no reply will be forthcoming'`,
+			rung: "implemented"
+		},
+		{
+			ref: "node v24.21.0 lib/net.js:589 (a socket has no timeout until setTimeout), :828-843 (setNoDelay)",
+			rung: "implemented"
+		},
+		{
+			ref: "node v24.21.0 lib/events.js:489-506 an error event with no listener throws",
+			rung: "implemented"
+		},
+		{
+			ref: "node v24.21.0 lib/internal/timers.js:675-692 a repeating timer counts its next interval from the time that its callback runs: the lateness of each firing carries into the next",
+			rung: "implemented"
+		}
+	],
+	states: {
+		"[none]": {
+			initial: true,
+			pseudo: true,
+			note: "Before amqplib.connect"
+		},
+		connecting: { note: "The TCP connect, with no TCP_NODELAY and no keepalive at the defaults (connect.js:150-153)" },
+		opening: { note: "The handshake of AMQP: the protocol header, start, tune and open, until open-ok (connection.js:85-223)" },
+		idle: { note: "An open connection with no RPC in flight. The two heartbeat checks run" },
+		waiting: { note: "An RPC of the channel in flight: the channel waits for its reply, with no timer. The two heartbeat checks run" },
+		ended: {
+			final: true,
+			note: "The connection closed. amqplib does not connect again, and each RPC fails at once"
+		}
+	},
+	events: {
+		"app.connect": {
+			kind: "app",
+			note: "The application calls amqplib.connect"
+		},
+		"socket.connect": {
+			kind: "local",
+			note: "The TCP connect ends, and amqplib sends the protocol header"
+		},
+		"local.opened": {
+			kind: "local",
+			note: "open-ok: the end of the handshake, and the start of the heartbeat"
+		},
+		"app.rpc": {
+			kind: "app",
+			note: "An RPC of the channel goes out, for example a passive queue.declare"
+		},
+		"rx.reply": {
+			kind: "rx",
+			note: "The method that answers the RPC"
+		},
+		"rx.frame": {
+			kind: "rx",
+			note: "Bytes from the broker: a frame of a channel or a heartbeat frame. The receive check counts them as activity"
+		},
+		"rx.connection-close": {
+			kind: "rx",
+			note: "A connection.close of the broker, with its reply code and its text"
+		},
+		"peer.fin": {
+			kind: "peer",
+			note: "The broker or a middlebox ends the connection: an end of the socket"
+		},
+		"peer.rst": {
+			kind: "peer",
+			note: "A reset of the connection: the socket fails with ECONNRESET"
+		},
+		"socket.error": {
+			kind: "local",
+			note: "The socket fails with its own error: a reset, or a give-up of the kernel (ETIMEDOUT)"
+		},
+		"timer.connect": {
+			kind: "timer",
+			note: "The timeout of the socket fires before open-ok: 'connect ETIMEDOUT'"
+		},
+		"timer.beat": {
+			kind: "timer",
+			note: "The send check finds that nothing went out since the check before"
+		},
+		"timer.heartbeat": {
+			kind: "timer",
+			note: "The receive check finds nothing for the second time in a row"
+		},
+		"tx.heartbeat": {
+			kind: "tx",
+			note: "A heartbeat frame: 8 bytes (connection.js:469-471)"
+		},
+		"tx.fin": {
+			kind: "tx",
+			note: "The end of the socket of amqplib (stream.end): its FIN"
+		}
+	},
+	knobs: {
+		heartbeat: {
+			key: "amqplib heartbeat, the tuned value",
+			scope: "client",
+			unit: "s",
+			default: 60,
+			off: 0,
+			note: "connection.js:158-168: with no heartbeat in the URL, amqplib takes the value of the broker, 60 s for RabbitMQ 4.3 (rabbit Makefile:29). With a value of the caller, the smaller of the two. 0 is no heartbeat (2.0.0)"
+		},
+		timeout: {
+			key: "amqplib socketOptions.timeout",
+			scope: "client",
+			unit: "ms",
+			default: 0,
+			off: 0,
+			note: "connect.js:91, :179-185: undefined at the defaults, thus no timer for the connect and the handshake"
+		},
+		noDelay: {
+			key: "amqplib socketOptions.noDelay",
+			scope: "client",
+			unit: null,
+			default: 0,
+			note: "connect.js:90, :152: false at the defaults, thus Nagle is on"
+		},
+		keepAlive: {
+			key: "amqplib socketOptions.keepAlive",
+			scope: "client",
+			unit: null,
+			default: 0,
+			note: "connect.js:92, :153: false at the defaults, thus the socket has no keepalive"
+		},
+		keepAliveDelay: {
+			key: "amqplib socketOptions.keepAliveDelay",
+			scope: "client",
+			unit: "ms",
+			default: 0,
+			note: "connect.js:94: the delay that setKeepAlive gets when keepAlive is true"
+		},
+		slack: {
+			key: "the lateness of the event loop of Node for one step",
+			scope: "process",
+			unit: "s",
+			default: .01,
+			note: "An assumption of this document, not a value of amqplib: a timer or a callback of Node that comes late. In seconds, as the heartbeat"
+		},
+		hz: {
+			key: "CONFIG_HZ",
+			scope: "global",
+			unit: "Hz",
+			default: null,
+			note: "The build option of the kernel"
+		}
+	},
+	timers: {
+		connect_timeout: {
+			duration: {
+				knob: "timeout",
+				unit: "ms"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "ms"
+			},
+			arms: ["enter:connecting", "enter:opening"],
+			cancels: [
+				"local.opened",
+				"socket.error",
+				"peer.rst",
+				"peer.fin"
+			],
+			fires: "timer.connect",
+			note: "connect.js:179-185: one timeout of the socket for the connect and the handshake, which the open turns off. No bound at the defaults"
+		},
+		beat: {
+			duration: {
+				expr: "heartbeat / 2",
+				unit: "s"
+			},
+			lateness: {
+				expr: "heartbeat / 2 + 2 * slack",
+				unit: "s"
+			},
+			arms: ["local.opened", "timer.beat"],
+			fires: "timer.beat",
+			note: "heartbeat.js:60: the send check each interval / 2. A send since the check before skips it, and the heartbeat counts as a send: thus an idle connection sends one each interval. The next frame of the client comes from interval / 2 to one interval after its last send"
+		},
+		heartbeat: {
+			duration: {
+				expr: "2 * heartbeat",
+				unit: "s"
+			},
+			lateness: {
+				expr: "heartbeat + 3 * slack",
+				unit: "s"
+			},
+			arms: [
+				"local.opened",
+				"enter:idle",
+				"enter:waiting",
+				"rx.frame"
+			],
+			cancels: [
+				"socket.error",
+				"peer.rst",
+				"peer.fin",
+				"rx.connection-close"
+			],
+			fires: "timer.heartbeat",
+			note: "heartbeat.js:64-71: the receive check each interval, and a timeout at the second miss in a row. The timer runs at a phase from the open, thus the timeout comes 2 to 3 intervals after the last bytes of the broker. The timeout is the third firing at most after those bytes, and each firing can be one slack late (node lib/internal/timers.js:675-692). It runs in each state of an open connection: the entry to a state names it here, but only bytes of the broker start it again"
+		}
+	},
+	realizes: {
+		"systems.mechanism.connect-bound": { timer: "connect_timeout" },
+		"systems.mechanism.heartbeat-detection-time": { timer: "heartbeat" },
+		"systems.mechanism.heartbeat-interval": { timer: "beat" },
+		"systems.mechanism.idle-refresh-interval": {
+			duration: {
+				expr: "heartbeat / 2",
+				unit: "s"
+			},
+			lateness: {
+				expr: "heartbeat / 2 + 2 * slack",
+				unit: "s"
+			},
+			note: "The heartbeat frames of the client on an idle connection: one each interval. The broker sends its own each interval / 2"
+		}
+	},
+	transitions: [
+		{
+			id: "aq.connect",
+			from: "[none]",
+			to: "connecting",
+			on: "app.connect",
+			timer: "connect_timeout",
+			source: "connect.js:166-172"
+		},
+		{
+			id: "aq.connected",
+			from: "connecting",
+			to: "opening",
+			on: "socket.connect",
+			note: "amqplib sends the protocol header at once",
+			source: "connect.js:150-172, connection.js:221-223"
+		},
+		{
+			id: "aq.opened",
+			from: "opening",
+			to: "idle",
+			on: "local.opened",
+			note: "The heartbeat starts with the tuned value",
+			source: "connection.js:189-198"
+		},
+		{
+			id: "aq.connect-timed-out",
+			from: ["connecting", "opening"],
+			to: "ended",
+			on: "timer.connect",
+			timer: "connect_timeout",
+			errno: "connect ETIMEDOUT",
+			source: "connect.js:179-185"
+		},
+		{
+			id: "aq.connect-failed",
+			from: ["connecting", "opening"],
+			to: "ended",
+			on: [
+				"socket.error",
+				"peer.rst",
+				"peer.fin",
+				"rx.connection-close"
+			],
+			note: "The connect fails with the error of the socket, 'Socket closed abruptly during opening handshake', or 'Handshake terminated by server'",
+			source: "connect.js:187-189, connection.js:150-157, :203-209"
+		},
+		{
+			id: "aq.rpc",
+			from: "idle",
+			to: "waiting",
+			on: "app.rpc",
+			note: "The RPC has no timer",
+			source: "channel.js:97-123"
+		},
+		{
+			id: "aq.replied",
+			from: "waiting",
+			to: "idle",
+			on: "rx.reply",
+			source: "channel.js:100-103"
+		},
+		{
+			id: "aq.beat-idle",
+			from: "idle",
+			to: "idle",
+			on: "timer.beat",
+			timer: "beat",
+			emits: ["tx.heartbeat"],
+			source: "connection.js:378-380, :469-471"
+		},
+		{
+			id: "aq.beat-waiting",
+			from: "waiting",
+			to: "waiting",
+			on: "timer.beat",
+			timer: "beat",
+			emits: ["tx.heartbeat"],
+			source: "connection.js:378-380, :469-471"
+		},
+		{
+			id: "aq.heartbeat-timeout",
+			from: ["idle", "waiting"],
+			to: "ended",
+			on: "timer.heartbeat",
+			timer: "heartbeat",
+			errno: "Heartbeat timeout",
+			emits: ["tx.fin"],
+			note: "The connection emits error, ends its socket with a FIN and emits close. An RPC in flight fails with 'Channel ended, no reply will be forthcoming'",
+			source: "connection.js:370-376, :341-354, channel.js:155-159"
+		},
+		{
+			id: "aq.reset",
+			from: ["idle", "waiting"],
+			to: "ended",
+			on: ["socket.error", "peer.rst"],
+			errno: "ECONNRESET",
+			note: "The error of the socket, with its own code: ECONNRESET for a reset, ETIMEDOUT for a give-up of the kernel. The connection emits it, then its close",
+			source: "connection.js:213-214, :296-303"
+		},
+		{
+			id: "aq.closed",
+			from: ["idle", "waiting"],
+			to: "ended",
+			on: "peer.fin",
+			errno: "Unexpected close",
+			emits: ["tx.fin"],
+			note: "The end of the socket is an error of the connection, and amqplib ends its side too",
+			source: "connection.js:215, :296-303, :341-354"
+		},
+		{
+			id: "aq.closed-by-broker",
+			from: ["idle", "waiting"],
+			to: "ended",
+			on: "rx.connection-close",
+			errno: "Connection closed",
+			emits: ["tx.fin"],
+			note: "close-ok, then the end. The close has the reply code of the broker. For 320 (CONNECTION_FORCED) amqplib emits no error, only its close",
+			source: "connection.js:587-600, :645-653"
+		}
+	],
+	over: {
+		machine: "systems.machine.linux-tcp",
+		states: {
+			connecting: "SYN_SENT",
+			opening: "ESTABLISHED",
+			idle: "ESTABLISHED",
+			waiting: "ESTABLISHED"
+		},
+		sets: {},
+		ends: "socket.error",
+		note: "The socket of the connection: a Linux TCP socket with Nagle on and no keepalive at the defaults. Thus the kernel ends a send with no ACK only at the give-up of its retransmissions"
+	}
+});
+//#endregion
+//#region src/rabbit/aten.ts
+const ATEN = "aten 0.6.0";
+/**
+* This document is aten 0.6.0, the failure detector between the nodes of RabbitMQ 4.3.6. It gives one
+* node that another node watches: up or down, as the detector of the watching node sees it.
+*
+* Each node sends a heartbeat to each connected node each 100 ms. The sink of the watching node keeps
+* the gaps between the heartbeats of each node. Its detector polls each 5000 ms: aten polls each 1000 ms
+* by its own default, and RabbitMQ sets 5000 ms, for fewer false elections.
+*
+* At a poll, the probability of a failure is a share of the gaps. A gap counts when 1.5 times the gap
+* is not longer than the time since the last heartbeat. The node is down when that share reaches 0.99.
+* With gaps of approximately 100 ms, that is approximately 150 ms after the last heartbeat, at the first
+* poll after it. Thus a silent node is down 150 ms to approximately 5.2 s after its last heartbeat,
+* long before the tick of the distribution.
+*
+* A closed connection of the distribution (a stopped node) removes the data of the node from the
+* sink. The next poll then reports the node down.
+*/
+const ATEN_DETECTOR = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "aten",
+	title: "aten 0.6.0: one node that the failure detector of another node of RabbitMQ watches, up or down",
+	layer: "server",
+	version: "0.6.0",
+	conditions: {
+		aten: "0.6.0",
+		ra: "3.1.10",
+		rabbitmq: "4.3.6",
+		nodes: "two nodes of one cluster, connected by the Erlang distribution"
+	},
+	sources: [
+		{
+			ref: `${ATEN} src/aten.app.src: the defaults poll_interval 1000, scaling_factor 1.5, heartbeat_interval 100, detection_threshold 0.99`,
+			rung: "implemented"
+		},
+		{
+			ref: "rabbitmq v4.3.6 deps/rabbitmq_prelaunch/src/rabbit_prelaunch_conf.erl:112-120 RabbitMQ sets the poll interval of aten to 5000 ms, for fewer false elections of quorum queues",
+			rung: "implemented"
+		},
+		{
+			ref: "run 39218896659 of github.com/mark1russell7/systems: after a freeze and a black hole of the node of the leader, the new leader came 6.1 s to 10.4 s later, and not 1 s to 4 s",
+			rung: "observed"
+		},
+		{
+			ref: `${ATEN} src/aten_emitter.erl:49-54 and :95-98 the emitter arms its next send heartbeat_interval after it sends to each node, :63-82 it sends to each node in nodes() with noconnect and nosuspend`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ATEN} src/aten_sink.erl:69-79 a heartbeat adds a sample to the state of its node, :81-87 nodedown removes the state of the node`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ATEN} src/aten_detect.erl:17 a window of 1000 samples, :44-52 a sample is the gap since the heartbeat before it, :54-68 the probability is the share of the gaps S with S × factor ≤ the time since the last heartbeat`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ATEN} src/aten_detector.erl:53-59 the threshold and the poll interval, :105-113 each poll arms the next poll first, then reads the probabilities, :148-186 a node goes down when its probability crosses the threshold between two polls, or when it leaves the sink`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ATEN} src/aten_detector.erl:134-146 the detector sends {node_event, Node, down} or up to each process that watches the node`,
+			rung: "implemented"
+		},
+		{
+			ref: "rabbitmq v4.3.6 deps/rabbit/priv/schema/rabbit.schema:2540-2589 raft.adaptive_failure_detector.poll_interval, scaling_factor, heartbeat_interval and detection_threshold map to aten",
+			rung: "implemented"
+		}
+	],
+	states: {
+		up: {
+			initial: true,
+			note: "the probability of the node is below the threshold at the last poll"
+		},
+		down: { note: "{node_event, Node, down}: the probability crossed the threshold, or the node left the sink" }
+	},
+	events: {
+		"rx.heartbeat": {
+			kind: "rx",
+			note: "a heartbeat of the node reaches the sink of the watching node"
+		},
+		"rx.nodedown": {
+			kind: "rx",
+			note: "the connection of the distribution to the node closed: the sink removes the node"
+		},
+		"timer.detect": {
+			kind: "timer",
+			note: "the first poll at which the share of the gaps reaches the threshold"
+		},
+		"timer.left": {
+			kind: "timer",
+			note: "the first poll after the node left the sink"
+		}
+	},
+	knobs: {
+		heartbeat_interval: {
+			key: "raft.adaptive_failure_detector.heartbeat_interval (aten heartbeat_interval)",
+			scope: "node",
+			unit: "ms",
+			default: 100,
+			note: "aten.app.src"
+		},
+		poll_interval: {
+			key: "raft.adaptive_failure_detector.poll_interval (aten poll_interval)",
+			scope: "node",
+			unit: "ms",
+			default: 5e3,
+			note: "RabbitMQ sets 5000 (rabbit_prelaunch_conf.erl:112-120). The default of aten itself is 1000 (aten.app.src)"
+		},
+		scaling_factor: {
+			key: "raft.adaptive_failure_detector.scaling_factor (aten scaling_factor)",
+			scope: "node",
+			unit: "count",
+			default: 1.5,
+			note: "aten.app.src"
+		},
+		detection_threshold: {
+			key: "raft.adaptive_failure_detector.detection_threshold (aten detection_threshold)",
+			scope: "node",
+			unit: "count",
+			default: .99,
+			note: "aten.app.src: the share of the gaps that the time since the last heartbeat must reach"
+		},
+		gap_slack: {
+			key: "how much longer than heartbeat_interval the 99th percentile gap is",
+			scope: "node",
+			unit: "ms",
+			default: 10,
+			note: "an assumption of this document, not a value of aten: the emitter arms its next send after its sends (aten_emitter.erl:95-98), and the BEAM schedules it a little late"
+		},
+		slack: {
+			key: "the lateness of a timer of the BEAM for one step",
+			scope: "node",
+			unit: "ms",
+			default: 10,
+			note: "an assumption of this document, not a value of aten: a send_after that fires late"
+		}
+	},
+	timers: {
+		detect: {
+			duration: {
+				expr: "scaling_factor * heartbeat_interval",
+				unit: "ms"
+			},
+			lateness: {
+				expr: "scaling_factor * gap_slack + poll_interval + slack",
+				unit: "ms"
+			},
+			arms: ["rx.heartbeat"],
+			fires: "timer.detect",
+			note: "150 ms after the last heartbeat at the defaults, and up to one poll of 5 s later"
+		},
+		nodedown_poll: {
+			duration: {
+				const: 0,
+				unit: "ms"
+			},
+			lateness: {
+				expr: "poll_interval + slack",
+				unit: "ms"
+			},
+			arms: ["rx.nodedown"],
+			fires: "timer.left"
+		}
+	},
+	realizes: {
+		"systems.mechanism.heartbeat-detection-time": { timer: "detect" },
+		"systems.mechanism.heartbeat-interval": {
+			duration: {
+				knob: "heartbeat_interval",
+				unit: "ms"
+			},
+			lateness: {
+				knob: "gap_slack",
+				unit: "ms"
+			},
+			note: "each node sends a heartbeat to each connected node at this interval (aten_emitter.erl:95-98)"
+		}
+	},
+	transitions: [
+		{
+			id: "aten.heartbeat",
+			from: "up",
+			to: "up",
+			on: "rx.heartbeat",
+			note: "a new sample of the gap",
+			source: "aten_sink.erl:69-79"
+		},
+		{
+			id: "aten.down",
+			from: "up",
+			to: "down",
+			on: "timer.detect",
+			timer: "detect",
+			emits: ["node_event down"],
+			source: "aten_detector.erl:148-186"
+		},
+		{
+			id: "aten.left",
+			from: "up",
+			to: "down",
+			on: "timer.left",
+			timer: "nodedown_poll",
+			emits: ["node_event down"],
+			source: "aten_detector.erl:159-175"
+		},
+		{
+			id: "aten.up",
+			from: "down",
+			to: "up",
+			on: "rx.heartbeat",
+			emits: ["node_event up"],
+			note: "at the next poll the share is below the threshold again",
+			source: "aten_detector.erl:153-155"
+		}
+	]
+});
+//#endregion
+//#region src/rabbit/ra-member.ts
+const RA = "ra 3.1.10 src";
+const RMQ$1 = "rabbitmq v4.3.6 deps/rabbit/src";
+/**
+* This document is ra 3.1.10, for one member of the Raft cluster of a quorum queue of RabbitMQ 4.3.6.
+* It gives the roles of the member, the election timers, and the change of leader.
+*
+* A follower watches the node of its leader with aten. When aten reports that node down, the follower
+* arms a long election timeout. The timeout is the poll interval of aten, 5 s in RabbitMQ, and a random
+* part up to 1 s. A valid message of the leader cancels it. When the timeout fires, the follower asks for pre-votes in
+* its term.
+*
+* A member grants a pre-vote when the log of the candidate is not behind its own. A member that is
+* still a follower of a live leader grants it too. A majority of pre-votes makes a candidate. The
+* candidate starts a new term and asks for votes, and a majority makes it the leader. The new leader
+* of the queue tells each publisher of the queue. Then the channel of each publisher sends its pending
+* publishes again to the new leader.
+*
+* A leader ignores the events of aten. Thus a leader that loses the majority stays the leader in its
+* minority, and it commits nothing, until it sees a higher term.
+*/
+const RA_MEMBER = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "ra-member",
+	title: "ra 3.1.10: one member of the Raft cluster of a quorum queue of RabbitMQ 4.3.6, its elections and its leader",
+	layer: "server",
+	version: "3.1.10",
+	conditions: {
+		ra: "3.1.10",
+		aten: "0.6.0",
+		rabbitmq: "4.3.6",
+		queue: "a quorum queue of three members, one on each node of the cluster, each one a voter"
+	},
+	sources: [
+		{
+			ref: "rabbitmq v4.3.6 rabbitmq-components.mk:58 dep_ra = hex 3.1.10",
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:66-68 DEFAULT_BROADCAST_TIME 100, DEFAULT_ELECTION_MULT 5, TICK_INTERVAL_MS 1000`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:384 the member reads the poll interval of aten: 1000 ms by default, and 5000 ms in RabbitMQ (rabbit_prelaunch_conf.erl:112-120)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:1931-1950 the election timeouts: really_short rand(broadcast), short rand(5 × broadcast) + broadcast, medium rand(poll) + broadcast, long rand(10 × broadcast) + poll`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:2350-2357 an election timeout that is set is not set again, and :2359-2367 each change of role cancels it`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:802-825 a follower that is not new arms a long timeout when it enters the role`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:1844-1851 a valid message of the leader cancels the election timeout of a follower`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:899-919 aten reports the node of the leader down: a long timeout; up again: the timeout stops`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:869-896 the monitor of the leader goes down: short for noconnection, really_short for each other reason`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:1958-1981 a follower watches the node of a new leader with aten, and logs the new leader`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:1625-1626 the election timeout of a follower asks for pre-votes, and :2900-2923 a pre-vote round is in the current term`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:739-743 a member in pre-vote arms a long timeout, and ra_server.erl:1255-1256 its timeout asks again`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:2925-2985 a member grants a pre-vote when the term is not lower and the log of the candidate is not behind; a follower that declines arms its own long timeout`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:1229-1245 a majority of pre-votes makes a candidate, and :2880-2899 the candidate starts a new term and asks for votes`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:674-677 a candidate arms a short timeout, and ra_server.erl:1161-1162 its timeout starts a new election`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:1045-1061 a majority of votes makes the leader`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:1742-1755 each vote request is a call with the poll interval of aten as its timeout`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:597-598 a leader ignores the events of aten`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:928-942 and :946-960 a leader that sees a vote request or a pre-vote request of a higher term becomes a follower`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server.erl:1008-1032 a transfer of leadership: the leader waits, and it sends an election timeout to the member that gets the leadership`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:683-687 and :749-753 a candidate and a member in pre-vote reject a command`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RA}/ra_server_proc.erl:1336-1345 each change from or to leader is a NOTICE in the log, and each other change is DEBUG`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ$1}/rabbit_fifo.erl:1111-1123 a new leader of the queue sends leader_change to each publisher`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ$1}/rabbit_fifo_client.erl:738-760 the channel sends each pending publish again to the new leader, on leader_change or on a rejection`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ$1}/rabbit_quorum_queue.erl:175 and :2427-2441 the tick of a member is quorum_tick_interval, 5000 ms; RabbitMQ sets no broadcast time`,
+			rung: "implemented"
+		}
+	],
+	states: {
+		follower: {
+			initial: true,
+			note: "it follows the leader, and its election timeout runs when no valid message of the leader cancels it"
+		},
+		pre_vote: { note: "it asks for pre-votes in its term, and it rejects each command" },
+		candidate: { note: "a new term, its vote for itself, and a vote request to each member. A round with no majority before the timeout starts a new election after a medium timeout (101 ms to 1.1 s)" },
+		leader: { note: "it commits with a majority. It ignores aten: without a majority it stays the leader and commits nothing" }
+	},
+	events: {
+		"local.leader-node-down": {
+			kind: "local",
+			note: "{node_event, Node, down}: aten reports the node of the leader down"
+		},
+		"local.leader-node-up": {
+			kind: "local",
+			note: "{node_event, Node, up}: aten reports the node of the leader up again"
+		},
+		"rx.leader-noconnection": {
+			kind: "rx",
+			note: "the monitor of the leader goes down with noconnection: the distribution to its node closed"
+		},
+		"rx.leader-exit": {
+			kind: "rx",
+			note: "the monitor of the leader goes down with another reason: the process of the leader is gone"
+		},
+		"rx.leader-message": {
+			kind: "rx",
+			note: "a valid append_entries or heartbeat of the leader (record_leader_msg)"
+		},
+		"timer.election": {
+			kind: "timer",
+			note: "the state timeout election_timeout"
+		},
+		"rx.pre-votes": {
+			kind: "rx",
+			note: "a majority of granted pre-votes, its own one too"
+		},
+		"rx.pre-vote-declined": {
+			kind: "rx",
+			note: "a pre-vote request whose candidate has a log behind this member: it declines and arms its own timeout"
+		},
+		"rx.votes": {
+			kind: "rx",
+			note: "a majority of votes, its own one too"
+		},
+		"rx.higher-term": {
+			kind: "rx",
+			note: "a message of a term that is not lower: a leader of that term, or a vote request of a higher term"
+		},
+		"app.transfer": {
+			kind: "app",
+			note: "the leader sends election_timeout to the member that gets the leadership (rabbitmq-queues transfer_leadership)"
+		}
+	},
+	knobs: {
+		broadcast_time: {
+			key: "broadcast_time of the ra server",
+			scope: "queue",
+			unit: "ms",
+			default: 100,
+			note: "ra_server_proc.erl:66: RabbitMQ sets none"
+		},
+		election_mult: {
+			key: "DEFAULT_ELECTION_MULT",
+			scope: "build",
+			unit: "count",
+			default: 5,
+			note: "ra_server_proc.erl:67"
+		},
+		aten_poll_interval: {
+			key: "raft.adaptive_failure_detector.poll_interval (aten poll_interval)",
+			scope: "node",
+			unit: "ms",
+			default: 5e3,
+			note: "ra_server_proc.erl:384 reads it. RabbitMQ sets 5000 (rabbit_prelaunch_conf.erl:112-120)"
+		},
+		tick_timeout: {
+			key: "quorum_tick_interval",
+			scope: "node",
+			unit: "ms",
+			default: 5e3,
+			note: "rabbit_quorum_queue.erl:175, :2435-2441"
+		},
+		slack: {
+			key: "the lateness of a timer of the BEAM for one step",
+			scope: "node",
+			unit: "ms",
+			default: 10,
+			note: "an assumption of this document, not a value of ra: a state timeout that fires late"
+		},
+		commit_work: {
+			key: "the local work of one command: the writes and the fsyncs of the logs of a leader and a follower, and the apply",
+			scope: "node",
+			unit: "ms",
+			default: 50,
+			note: "an assumption of this document, not a value of ra: the WAL writes each batch and syncs it with fdatasync before the commit (ra_log_wal.erl:89, :772-798)"
+		},
+		rtt: {
+			key: "the round trip between members",
+			scope: "path",
+			unit: "ms",
+			default: null
+		}
+	},
+	timers: {
+		election_long: {
+			duration: {
+				expr: "aten_poll_interval + 1",
+				unit: "ms"
+			},
+			lateness: {
+				expr: "broadcast_time * election_mult * 2 - 1 + slack",
+				unit: "ms"
+			},
+			arms: [
+				"enter:follower",
+				"enter:pre_vote",
+				"local.leader-node-down",
+				"rx.pre-vote-declined"
+			],
+			cancels: ["rx.leader-message", "local.leader-node-up"],
+			fires: "timer.election",
+			note: "longer than one poll of aten, thus a false report of aten can end before an election (ra_server_proc.erl:1944-1949)"
+		},
+		election_short: {
+			duration: {
+				expr: "broadcast_time + 1",
+				unit: "ms"
+			},
+			lateness: {
+				expr: "broadcast_time * election_mult - 1 + slack",
+				unit: "ms"
+			},
+			arms: ["enter:candidate", "rx.leader-noconnection"],
+			cancels: ["rx.leader-message"],
+			fires: "timer.election"
+		},
+		election_really_short: {
+			duration: {
+				const: 1,
+				unit: "ms"
+			},
+			lateness: {
+				expr: "broadcast_time - 1 + slack",
+				unit: "ms"
+			},
+			arms: ["rx.leader-exit"],
+			cancels: ["rx.leader-message"],
+			fires: "timer.election"
+		}
+	},
+	realizes: { "systems.mechanism.election-timeout": { timer: "election_long" } },
+	transitions: [
+		{
+			id: "ra.leader-message",
+			from: "follower",
+			to: "follower",
+			on: "rx.leader-message",
+			note: "the election timeout stops",
+			source: "ra_server_proc.erl:1844-1851"
+		},
+		{
+			id: "ra.leader-node-down",
+			from: "follower",
+			to: "follower",
+			on: "local.leader-node-down",
+			note: "the long election timeout starts",
+			source: "ra_server_proc.erl:899-908"
+		},
+		{
+			id: "ra.pre-vote",
+			from: "follower",
+			to: "pre_vote",
+			on: ["timer.election", "app.transfer"],
+			source: "ra_server.erl:1625-1626, :2900-2923"
+		},
+		{
+			id: "ra.pre-vote-again",
+			from: "pre_vote",
+			to: "pre_vote",
+			on: "timer.election",
+			timer: "election_long",
+			source: "ra_server.erl:1255-1256"
+		},
+		{
+			id: "ra.candidate",
+			from: "pre_vote",
+			to: "candidate",
+			on: "rx.pre-votes",
+			source: "ra_server.erl:1229-1245, :2880-2899"
+		},
+		{
+			id: "ra.election-again",
+			from: "candidate",
+			to: "candidate",
+			on: "timer.election",
+			timer: "election_short",
+			source: "ra_server.erl:1161-1162"
+		},
+		{
+			id: "ra.leader",
+			from: "candidate",
+			to: "leader",
+			on: "rx.votes",
+			emits: ["candidate -> leader", "leader_change"],
+			note: "the NOTICE of the change, and leader_change to each publisher of the queue",
+			source: "ra_server.erl:1045-1061, ra_server_proc.erl:1336-1345, rabbit_fifo.erl:1111-1123"
+		},
+		{
+			id: "ra.follow",
+			from: ["pre_vote", "candidate"],
+			to: "follower",
+			on: "rx.higher-term",
+			source: "ra_server.erl:1062-1084"
+		},
+		{
+			id: "ra.abdicate",
+			from: "leader",
+			to: "follower",
+			on: "rx.higher-term",
+			emits: ["leader -> follower"],
+			source: "ra_server.erl:928-942, :946-960"
+		}
+	],
+	observe: { "rabbitmq-log": {
+		fidelity: "lossy",
+		states: {
+			leader: "leader",
+			follower: "follower"
+		},
+		hides: ["pre_vote", "candidate"],
+		note: "at the default level the log has each change from or to leader (NOTICE), and the new leader that a follower detects (INFO). The elections are DEBUG"
+	} }
+});
+//#endregion
+//#region src/rabbit/rabbitmq-connection.ts
+const RMQ = "v4.3.6";
+/**
+* This document is RabbitMQ 4.3.6, for one connection of AMQP 0-9-1 on the broker. It gives the reader of
+* the connection, from the accept to the close, and the timers that act on it.
+*
+* At the defaults the broker proposes a heartbeat of 60 s, and it uses the value of the tune-ok of the
+* client. Each 30 s it sends a heartbeat frame when it sent nothing: its own heartbeat does not count,
+* thus an idle connection gets one each 30 s. Each 60 s it checks that the client sent something. After
+* two checks with nothing, it ends the connection, 2 to 3 heartbeats after the last data.
+*
+* Each socket of a listener has linger 0, thus each close of the broker is a reset, not a FIN. The
+* listener of ranch gives each socket a send timeout of 30 s. After it, the BEAM closes the socket, with
+* a reset too. A resource alarm blocks a connection that publishes: the reader stops to read
+* its socket, and the receive check pauses.
+*/
+const RABBITMQ_CONNECTION = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "rabbitmq-connection",
+	title: "RabbitMQ 4.3.6: one connection of AMQP 0-9-1 on the broker, its heartbeat, its send timeout and its close",
+	layer: "server",
+	version: "4.3.6",
+	conditions: {
+		rabbitmq: "4.3.6",
+		ranch: "2.3.0",
+		listener: "the AMQP listener of the broker with the default tcp_listen_options, and no TLS",
+		connection: "a connection of AMQP 0-9-1 that a client opens, with the heartbeat of its tune-ok"
+	},
+	sources: [
+		{
+			ref: `${RMQ} deps/rabbit/Makefile:29 the default heartbeat of the broker: 60 s`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/Makefile:57 handshake_timeout 10000 ms`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/Makefile:60-64 tcp_listen_options: backlog 128, nodelay true, linger {true, 0}, exit_on_close false`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/tcp_listener_sup.erl:40-53 the listener is a ranch listener, with tcp_listen_options as its socket options`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} rabbitmq-components.mk:59 ranch 2.3.0. ranch 2.3.0 src/ranch_tcp.erl:106-109: a listener sets send_timeout 30000 and send_timeout_close true unless its options give them, and tcp_listen_options gives neither`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:1292-1323 tune-ok: the heartbeat of the client is the timeout of the two heartbeaters`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit_common/src/rabbit_heartbeat.erl:73-78 the sender: each timeout / 2, a heartbeat frame when send_oct did not change`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit_common/src/rabbit_heartbeat.erl:150-158 after the handler of the sender, it reads send_oct again: its own heartbeat does not count as a send, thus an idle connection gets one each timeout / 2`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit_common/src/rabbit_heartbeat.erl:80-85 the receiver: each timeout, a miss when recv_oct did not change, and the end at the second miss in a row. The comment: the end comes between 2 and 3 intervals after the last data`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:650-655 heartbeat_timeout ends the reader, and :405-407 logs 'missed heartbeats from client, timeout: <T>s'`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:302-304, :644-649 a timer of handshake_timeout from the start of the reader. It ends a connection that is not open at that time`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:368-372 at the end of the reader, rabbit_net:fast_close and not gen_tcp:close, which waits for the output. deps/rabbit_common/src/rabbit_net.erl:182-184 fast_close is port_close`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:541-542 an end of the socket stops the reader: 'client unexpectedly closed TCP connection' (:410-446)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${RMQ} deps/rabbit/src/rabbit_reader.erl:480-481, :1803-1830 a resource alarm blocks a connection that publishes: the reader does not read its socket, and the receive check pauses until the unblock`,
+			rung: "implemented"
+		},
+		{
+			ref: "Linux: a close of a socket with SO_LINGER on and a linger time of 0 sends a reset and drops the send queue (tcp_close, net/ipv4/tcp.c). An assumption of this document about the kernel",
+			rung: "documented"
+		}
+	],
+	states: {
+		"[none]": {
+			initial: true,
+			pseudo: true,
+			note: "Before ranch accepts the connection"
+		},
+		handshake: { note: "The protocol header, start-ok, tune-ok and open, until open-ok. The handshake timer runs" },
+		running: { note: "An open connection: the reader reads each frame, and the two heartbeaters run" },
+		blocked: { note: "A resource alarm blocked the connection: the reader does not read its socket, and the receive check pauses" },
+		ended: {
+			final: true,
+			note: "The reader ended, and the broker closed the socket with linger 0: a reset"
+		}
+	},
+	events: {
+		"local.accept": {
+			kind: "local",
+			note: "ranch accepts the TCP connection"
+		},
+		"rx.opened": {
+			kind: "rx",
+			note: "connection.open of the client, then open-ok: the end of the handshake"
+		},
+		"rx.frame": {
+			kind: "rx",
+			note: "Bytes from the client: a frame of a channel or a heartbeat frame. recv_oct counts them"
+		},
+		"local.alarm": {
+			kind: "local",
+			note: "A resource alarm of memory or of disk, on a connection that publishes"
+		},
+		"local.alarm-cleared": {
+			kind: "local",
+			note: "The alarm clears"
+		},
+		"local.send-blocked": {
+			kind: "local",
+			note: "A write of the broker waits: the send buffer of the socket is full"
+		},
+		"local.send-drained": {
+			kind: "local",
+			note: "The write ends"
+		},
+		"peer.fin": {
+			kind: "peer",
+			note: "The client ends the connection: an end of the socket"
+		},
+		"peer.rst": {
+			kind: "peer",
+			note: "A reset of the connection"
+		},
+		"socket.error": {
+			kind: "local",
+			note: "The socket fails: a reset, or a give-up of the kernel"
+		},
+		"timer.handshake": {
+			kind: "timer",
+			note: "handshake_timeout before open-ok"
+		},
+		"timer.beat": {
+			kind: "timer",
+			note: "The sender finds that send_oct did not change for timeout / 2"
+		},
+		"timer.heartbeat": {
+			kind: "timer",
+			note: "The receiver finds that recv_oct did not change, for the second time in a row"
+		},
+		"timer.send": {
+			kind: "timer",
+			note: "A write waits send_timeout: the BEAM closes the socket"
+		},
+		"tx.heartbeat": {
+			kind: "tx",
+			note: "A heartbeat frame"
+		},
+		"tx.rst": {
+			kind: "tx",
+			note: "The close of the broker with linger 0: a reset to the client"
+		}
+	},
+	knobs: {
+		heartbeat: {
+			key: "rabbitmq heartbeat, the tuned value",
+			scope: "server",
+			unit: "s",
+			default: 60,
+			off: 0,
+			note: "Makefile:29 proposes 60 s, and the reader uses the value of the tune-ok of the client (rabbit_reader.erl:1292-1323). 0 is no heartbeat"
+		},
+		handshake_timeout: {
+			key: "rabbitmq handshake_timeout",
+			scope: "server",
+			unit: "ms",
+			default: 1e4,
+			note: "Makefile:57"
+		},
+		send_timeout: {
+			key: "the send_timeout of a socket of the listener",
+			scope: "server",
+			unit: "ms",
+			default: 3e4,
+			note: "ranch 2.3.0 src/ranch_tcp.erl:108-109: 30000, with send_timeout_close true. tcp_listen_options of RabbitMQ does not set it"
+		},
+		slack: {
+			key: "the lateness of the scheduler of the BEAM for one step",
+			scope: "process",
+			unit: "s",
+			default: .01,
+			note: "An assumption of this document, not a value of RabbitMQ: a timer of the BEAM that comes late. In seconds, as the heartbeat"
+		}
+	},
+	timers: {
+		handshake: {
+			duration: {
+				knob: "handshake_timeout",
+				unit: "ms"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "ms"
+			},
+			arms: ["local.accept"],
+			cancels: [
+				"rx.opened",
+				"peer.fin",
+				"peer.rst",
+				"socket.error"
+			],
+			fires: "timer.handshake",
+			note: "rabbit_reader.erl:302-304, :644-649: from the start of the reader. A running connection ignores it"
+		},
+		beat: {
+			duration: {
+				expr: "heartbeat / 2",
+				unit: "s"
+			},
+			lateness: {
+				expr: "heartbeat / 2 + 2 * slack",
+				unit: "s"
+			},
+			arms: ["rx.opened", "timer.beat"],
+			fires: "timer.beat",
+			note: "rabbit_heartbeat.erl:73-78, :150-158: the check each timeout / 2. Its own heartbeat does not count, thus an idle connection gets a frame each timeout / 2. After a frame of a channel, the next frame comes from timeout / 2 to one timeout later"
+		},
+		heartbeat: {
+			duration: {
+				expr: "2 * heartbeat",
+				unit: "s"
+			},
+			lateness: {
+				expr: "heartbeat + 3 * slack",
+				unit: "s"
+			},
+			arms: [
+				"rx.opened",
+				"enter:running",
+				"rx.frame",
+				"local.alarm-cleared"
+			],
+			cancels: [
+				"local.alarm",
+				"peer.fin",
+				"peer.rst",
+				"socket.error"
+			],
+			fires: "timer.heartbeat",
+			note: "rabbit_heartbeat.erl:80-85: the check each timeout, and the end at the second miss in a row: 2 to 3 timeouts after the last data. Each check arms the next one after it reads the stats (rabbit_heartbeat.erl:121-158), thus each one can be one slack late. A block pauses it, and the unblock starts it again (rabbit_reader.erl:1803-1830). The entry to running names it here, but only bytes of the client start it again"
+		},
+		send: {
+			duration: {
+				knob: "send_timeout",
+				unit: "ms"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "ms"
+			},
+			arms: ["local.send-blocked"],
+			cancels: ["local.send-drained"],
+			fires: "timer.send",
+			note: "ranch 2.3.0: send_timeout_close. A write that waits 30 s fails, and the BEAM closes the socket: with linger 0, a reset"
+		}
+	},
+	realizes: {
+		"systems.mechanism.heartbeat-detection-time": { timer: "heartbeat" },
+		"systems.mechanism.heartbeat-interval": { timer: "beat" },
+		"systems.mechanism.idle-refresh-interval": {
+			duration: {
+				expr: "heartbeat / 2",
+				unit: "s"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "s"
+			},
+			note: "The heartbeat frames of the broker on an idle connection: one each timeout / 2"
+		}
+	},
+	transitions: [
+		{
+			id: "rq.accept",
+			from: "[none]",
+			to: "handshake",
+			on: "local.accept",
+			timer: "handshake",
+			source: "rabbit_reader.erl:290-304"
+		},
+		{
+			id: "rq.opened",
+			from: "handshake",
+			to: "running",
+			on: "rx.opened",
+			note: "The two heartbeaters start with the value of the tune-ok",
+			source: "rabbit_reader.erl:1292-1328"
+		},
+		{
+			id: "rq.handshake-timed-out",
+			from: "handshake",
+			to: "ended",
+			on: "timer.handshake",
+			timer: "handshake",
+			errno: "handshake_timeout",
+			emits: ["tx.rst"],
+			source: "rabbit_reader.erl:644-649, :368-372"
+		},
+		{
+			id: "rq.beat-running",
+			from: "running",
+			to: "running",
+			on: "timer.beat",
+			timer: "beat",
+			emits: ["tx.heartbeat"],
+			source: "rabbit_reader.erl:1305-1318"
+		},
+		{
+			id: "rq.beat-blocked",
+			from: "blocked",
+			to: "blocked",
+			on: "timer.beat",
+			timer: "beat",
+			emits: ["tx.heartbeat"],
+			source: "rabbit_reader.erl:1305-1318"
+		},
+		{
+			id: "rq.heartbeat-timeout",
+			from: "running",
+			to: "ended",
+			on: "timer.heartbeat",
+			timer: "heartbeat",
+			errno: "missed heartbeats from client",
+			emits: ["tx.rst"],
+			source: "rabbit_reader.erl:650-655, :405-407, :368-372"
+		},
+		{
+			id: "rq.block",
+			from: "running",
+			to: "blocked",
+			on: "local.alarm",
+			note: "The reader sends connection.blocked when the client can take it",
+			source: "rabbit_reader.erl:1803-1815"
+		},
+		{
+			id: "rq.unblock",
+			from: "blocked",
+			to: "running",
+			on: "local.alarm-cleared",
+			source: "rabbit_reader.erl:1817-1825"
+		},
+		{
+			id: "rq.client-closed",
+			from: ["running", "blocked"],
+			to: "ended",
+			on: "peer.fin",
+			errno: "client unexpectedly closed TCP connection",
+			emits: ["tx.rst"],
+			note: "The end of the reader closes the socket with linger 0: a reset to the client, which closed already",
+			source: "rabbit_reader.erl:541-542, :410-446, :368-372"
+		},
+		{
+			id: "rq.reset",
+			from: ["running", "blocked"],
+			to: "ended",
+			on: ["peer.rst", "socket.error"],
+			errno: "ECONNRESET",
+			source: "rabbit_reader.erl:547-548"
+		},
+		{
+			id: "rq.send-timed-out",
+			from: ["running", "blocked"],
+			to: "ended",
+			on: "timer.send",
+			timer: "send",
+			errno: "timeout",
+			emits: ["tx.rst"],
+			note: "The BEAM closes the socket at the send timeout, with linger 0: a reset, short enough to pass an MTU black hole",
+			source: "ranch 2.3.0 src/ranch_tcp.erl:108-109"
+		}
+	],
+	over: {
+		machine: "systems.machine.linux-tcp",
+		states: {
+			handshake: "ESTABLISHED",
+			running: "ESTABLISHED",
+			blocked: "ESTABLISHED"
+		},
+		sets: {},
+		ends: "socket.error",
+		note: "The socket of the connection on the broker: TCP_NODELAY on, no keepalive, and SO_LINGER on with 0, thus each close of the broker is a reset"
+	}
+});
+//#endregion
 //#region src/sentinel.ts
 const AT = "valkey 9.1.2 src/sentinel.c";
 /**
@@ -11658,9 +13099,13 @@ const MACHINES = byId([
 	PGBOUNCER_SERVER,
 	PGPOOL_SESSION,
 	SUPAVISOR_CLIENT,
-	SUPAVISOR_SERVER
+	SUPAVISOR_SERVER,
+	AMQPLIB,
+	RABBITMQ_CONNECTION,
+	ATEN_DETECTOR,
+	RA_MEMBER
 ]);
 //#endregion
-export { GO_TRANSPORT, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, LINUX_TCP, MACHINES, MANIFESTATIONS, MONGODB_NODE, MONGOD_REPL, MONGOD_SESSION, NF_CONNTRACK_TCP, NODE_HTTP_AGENT, NODE_HTTP_SERVER, NODE_POSTGRES, NODE_TIMER_EARLY, PGBOUNCER_CLIENT, PGBOUNCER_SERVER, PGPOOL_SESSION, POSTGRES_SESSION, PROCEDURES_WS_CLIENT, PROCEDURES_WS_SERVER, REDIS_CLIENT, SENTINEL, SUPAVISOR_CLIENT, SUPAVISOR_SERVER, UNDICI_CLIENT, UNDICI_TICK_MS, goLateSeconds, goTimerLateness, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
+export { AMQPLIB, ATEN_DETECTOR, GO_TRANSPORT, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, LINUX_TCP, MACHINES, MANIFESTATIONS, MONGODB_NODE, MONGOD_REPL, MONGOD_SESSION, NF_CONNTRACK_TCP, NODE_HTTP_AGENT, NODE_HTTP_SERVER, NODE_POSTGRES, NODE_TIMER_EARLY, PGBOUNCER_CLIENT, PGBOUNCER_SERVER, PGPOOL_SESSION, POSTGRES_SESSION, PROCEDURES_WS_CLIENT, PROCEDURES_WS_SERVER, RABBITMQ_CONNECTION, RA_MEMBER, REDIS_CLIENT, SENTINEL, SUPAVISOR_CLIENT, SUPAVISOR_SERVER, UNDICI_CLIENT, UNDICI_TICK_MS, goLateSeconds, goTimerLateness, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
 
 //# sourceMappingURL=index.js.map