@mark1russell7/machines 0.3.32 → 0.3.33

package/build/index.js

@@ -1,6 +1,6 @@
 import { machineSchema } from "@mark1russell7/algebra/schema";
 import { z } from "zod";
-//#region src/call.ts
+// src/call.ts
 /**
 * This document is one call of a program on a socket of Linux TCP: a deadline for each try, and a
 * retry after each deadline. It is a generic client that the program configures, as the
@@ -127,8 +127,7 @@ const DEADLINE_CALL = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/grpc/grpc-go-server.ts
+// src/grpc/grpc-go-server.ts
 const AT$18 = "grpc-go v1.84.0";
 const GO = "go1.27.2 src/net";
 const ETCD = "etcd v3.6.15";
@@ -828,8 +827,7 @@ const ETCD_SERVER = serverOf({
 	setsUserTimeout: 0,
 	note: "keepalive_listener.go:68: SetKeepAlivePeriod(30 s) on each accepted connection"
 });
-//#endregion
-//#region src/grpc/grpc-js.ts
+// src/grpc/grpc-js.ts
 const AT$17 = "@grpc/grpc-js 1.14.6 src";
 /**
 * This document is grpc-js 1.14.6 on Node, for one channel to one server with no TLS, its transport
@@ -1364,8 +1362,7 @@ const GRPC_JS = machineSchema.parse({
 		note: "The socket of the transport: a Linux TCP socket with TCP_NODELAY and no keepalive. Thus the kernel ends a send with no ACK only at the give-up of its retransmissions, and an idle socket to a peer that is gone stays open"
 	}
 });
-//#endregion
-//#region src/http/timers.ts
+// src/http/timers.ts
 /**
 * This module gives the lateness of a timer in user space on Linux 6.6. A Node timer and a Go timer
 * both sleep in `epoll_wait` with a timeout in whole milliseconds. The kernel lets that sleep end
@@ -1415,15 +1412,19 @@ const COARSE_MS = "min(floor(hz / 1000), 1) * 1000 / hz";
 * arithmetic reads `ms` in milliseconds, and the knob `hz` in Hz.
 */
 const nodeTimerLateness = (ms) => ({
-	expr: `${slackMs(ms)} + 1 + ${COARSE_MS}`,
+	expr: nodeLateMs(ms),
 	unit: "ms"
 });
+/** This function gives the arithmetic of `nodeTimerLateness`, in ms, for a document that adds it to other terms. */
+const nodeLateMs = (ms) => `${slackMs(ms)} + 1 + ${COARSE_MS}`;
+/** This text is the arithmetic of `NODE_TIMER_EARLY`, in ms, for a document that adds it to other terms. */
+const NODE_EARLY_MS = `1 + ${COARSE_MS}`;
 /**
 * This expression is how early a Node timer can fire. It is 1 ms for the truncation of the loop
 * clock that stamps its start, and the step of the coarse clock.
 */
 const NODE_TIMER_EARLY = {
-	expr: `1 + ${COARSE_MS}`,
+	expr: NODE_EARLY_MS,
 	unit: "ms"
 };
 /** This function gives the lateness of a Go timer of `s` seconds: the slack of its sleep and 1 ms. The arithmetic reads `s` in seconds. */
@@ -1468,8 +1469,7 @@ const undiciFastLateness = (ms) => ({
 	expr: `ceil((${ms}) / 499) * 499 - (${ms}) + ceil((${ms}) / 499) * (${slackMs(String(499))} + 1 + ${COARSE_MS})`,
 	unit: "ms"
 });
-//#endregion
-//#region src/http/go-transport.ts
+// src/http/go-transport.ts
 /**
 * This document is one connection of the `http.Transport` of Go 1.27.2 at its defaults, over its
 * Linux TCP socket. Each fact comes from the source at the tag `go1.27.2`. The comments give the
@@ -1791,8 +1791,7 @@ const GO_TRANSPORT = machineSchema.parse({
 		note: "Go sets SO_KEEPALIVE with its own idle, interval and count on each dialed socket, rounded up to whole seconds. Thus the keepalive sysctls of the namespace do not reach it. A negative KeepAlive turns it off: a reader gives keepidle no bound."
 	}
 });
-//#endregion
-//#region src/http/node-agent.ts
+// src/http/node-agent.ts
 /**
 * This document is one socket of the `http.Agent` of Node v24.21.0, as its global agent sets it.
 * Its keep-alive is on, its free socket timeout is 5 s, and it is LIFO. It is over the Linux TCP socket. Each fact
@@ -2054,8 +2053,7 @@ const NODE_HTTP_AGENT = machineSchema.parse({
 		note: "The agent turns keepalive on at the connect (lib/_http_agent.js:474-478, lib/net.js:1991-1994) and again on each free socket. Node passes the delay in whole seconds and libuv sets 1 s and 10 probes. Thus the keepalive sysctls of the namespace do not reach it."
 	}
 });
-//#endregion
-//#region src/http/node-server.ts
+// src/http/node-server.ts
 /**
 * This document is one connection as the `http.Server` of Node v24.21.0 holds it, over the Linux
 * TCP socket of the connection. Each fact comes from the source at the tag `v24.21.0`. The comments
@@ -2387,8 +2385,7 @@ const NODE_HTTP_SERVER = machineSchema.parse({
 		note: "http.Server passes keepAlive to net.Server, and its default is off (lib/_http_server.js:646-651, lib/net.js:2753-2756). Thus an accepted socket has no SO_KEEPALIVE, and a reader gives the keepalive of the kernel no bound."
 	}
 });
-//#endregion
-//#region src/http/undici.ts
+// src/http/undici.ts
 /**
 * This document is the socket of an HTTP/1.1 `Client` of undici 8.12.2, over its Linux TCP socket.
 * Each fact comes from the published package at 8.12.2, with the file and the line.
@@ -2712,8 +2709,7 @@ const UNDICI_CLIENT = machineSchema.parse({
 		note: "The connector turns keepalive on with a delay of 60 s, and Node and libuv add 1 s and 10 probes (src/tcp_wrap.cc:215-216). Thus the keepalive sysctls of the namespace do not reach it."
 	}
 });
-//#endregion
-//#region src/http/undici-retry.ts
+// src/http/undici-retry.ts
 const AT$16 = "undici 8.12.2 lib/handler/retry-handler.js";
 /**
 * This document is one request through a `RetryAgent` of undici 8.12.2: the retries of a reply
@@ -2928,8 +2924,7 @@ const UNDICI_RETRY = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/ioredis-sentinel.ts
+// src/ioredis-sentinel.ts
 const AT$15 = "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
@@ -3286,8 +3281,7 @@ const IOREDIS_SENTINEL = machineSchema.parse({
 		note: "the socket of the primary is a Linux TCP socket with keepalive at keepAlive. A write in flight to a black hole waits for the retransmissions of the kernel"
 	}
 });
-//#endregion
-//#region src/ioredis-status.json
+// src/ioredis-status.json
 var ioredis_status_default = {
 	format: "mark1russell7.machine/1",
 	id: "ioredis-status",
@@ -3550,8 +3544,7 @@ var ioredis_status_default = {
 		"note": "ioredis's socket is a Linux TCP socket. Once it connects, ioredis calls setKeepAlive(true, keepAlive), and Node gives libuv the delay in whole seconds with its own interval and count, so the namespace's keepalive sysctls never reach it. A delay under a second is 0 s, which libuv refuses with EINVAL. When the socket ends, ioredis hears stream.close."
 	}
 };
-//#endregion
-//#region src/linux-tcp.json
+// src/linux-tcp.json
 var linux_tcp_default = {
 	format: "mark1russell7.machine/1",
 	id: "linux-tcp",
@@ -4292,14 +4285,12 @@ var linux_tcp_default = {
 		}
 	}
 };
-//#endregion
-//#region src/manifestations.json
+// src/manifestations.json
 var manifestations_default = {
 	blackhole: [],
 	"freeze-process": ["rx.ack"]
 };
-//#endregion
-//#region src/nf-conntrack-tcp.json
+// src/nf-conntrack-tcp.json
 var nf_conntrack_tcp_default = {
 	format: "mark1russell7.machine/1",
 	id: "nf-conntrack-tcp",
@@ -4923,8 +4914,7 @@ var nf_conntrack_tcp_default = {
 		"note": "events are cached per packet and delivered at confirm: a change caused by a packet dropped before POSTROUTING is never reported (observed: a1, a2); netlink overruns drop events (ENOBUFS); DESTROY lags expiry by the GC"
 	} }
 };
-//#endregion
-//#region src/redis-client.json
+// src/redis-client.json
 var redis_client_default = {
 	format: "mark1russell7.machine/1",
 	id: "redis-client",
@@ -5172,8 +5162,7 @@ var redis_client_default = {
 		"note": "Redis holds each client on a Linux TCP socket, and anetKeepAlive sets its keepalive from tcp-keepalive alone: the idle time, a third of it in whole seconds and at least 1, and 3 probes. So its detection of a dead client is the kernel's keepalive, or its retransmissions when a reply is unacknowledged, and either reaches Redis as a read error."
 	}
 };
-//#endregion
-//#region src/json.ts
+// src/json.ts
 /** This document is TCP as Linux 6.6 implements it: one full socket, from the source of the kernel and the RFCs. */
 const LINUX_TCP = machineSchema.parse(linux_tcp_default);
 /** This document is the TCP state machine of conntrack on Linux 6.6.87.2: the state of a router or a NAT for one flow. */
@@ -5188,8 +5177,7 @@ const IOREDIS_STATUS = machineSchema.parse(ioredis_status_default);
 * process continues to send ACKs, thus `rx.ack` arrives.
 */
 const MANIFESTATIONS = z.record(z.string(), z.array(z.string())).parse(manifestations_default);
-//#endregion
-//#region src/k8s/kubelet-readiness.ts
+// src/k8s/kubelet-readiness.ts
 const AT$14 = "kubernetes v1.37.0";
 const WORKER = `${AT$14} pkg/kubelet/prober/worker.go`;
 /**
@@ -5341,8 +5329,7 @@ const KUBELET_READINESS = machineSchema.parse({
 		source: "worker.go:366-379"
 	}]
 });
-//#endregion
-//#region src/kafka/group.ts
+// src/kafka/group.ts
 const GROUP = "kafka 4.3.2 group-coordinator/src/main/java/org/apache/kafka/coordinator/group";
 const INTERNALS = "kafka 4.3.2 clients/src/main/java/org/apache/kafka/clients/consumer/internals";
 /**
@@ -5634,8 +5621,7 @@ const KAFKA_CONSUMER_GROUP = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/kafka/partition.ts
+// src/kafka/partition.ts
 const CORE = "kafka 4.3.2 core/src/main/scala/kafka";
 const SERVER = "kafka 4.3.2 server/src/main/java/org/apache/kafka/server";
 const STORAGE = "kafka 4.3.2 storage/src/main/java/org/apache/kafka/storage/internals/log";
@@ -6055,8 +6041,7 @@ const KAFKA_PARTITION = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/mongo/mongod-replication.ts
+// src/mongo/mongod-replication.ts
 const AT$13 = "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
@@ -6813,8 +6798,7 @@ const MONGOD_REPL = machineSchema.parse({
 		}
 	} }
 });
-//#endregion
-//#region src/mongo/mongod-session.ts
+// src/mongo/mongod-session.ts
 const AT$12 = "mongodb r9.0.4 src/mongo";
 /**
 * This document is the hold of mongod 9.0.4 on one client connection, over its socket. `mongod`
@@ -7022,8 +7006,7 @@ const MONGOD_SESSION = machineSchema.parse({
 		note: "at the Linux defaults the window is 300 s + 9 × 1 s = 309 s, not 300 s + 9 × 75 s: the interval has a maximum too"
 	}
 });
-//#endregion
-//#region src/mongo/mongodb-node.ts
+// src/mongo/mongodb-node.ts
 const AT$11 = "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
@@ -7662,8 +7645,7 @@ const MONGODB_NODE = machineSchema.parse({
 		note: "each socket of the driver is a Linux TCP socket. makeSocket calls setKeepAlive(true, keepAliveInitialDelay), and Node gives libuv the delay in whole seconds with its own interval and count. Thus the keepalive sysctls of the namespace never reach these sockets"
 	}
 });
-//#endregion
-//#region src/pg/hikaricp-pgjdbc.ts
+// src/pg/hikaricp-pgjdbc.ts
 const HK = "HikariCP-7.1.0 src/main/java/com/zaxxer/hikari";
 const PG = "pgjdbc REL42.7.13 pgjdbc/src/main/java/org/postgresql";
 /**
@@ -8797,8 +8779,7 @@ const HIKARICP_PGJDBC = machineSchema.parse({
 		note: "Each socket of pgjdbc is a Linux TCP socket with TCP_NODELAY. At the defaults no socket has keepalive, thus keepidle has no bound. With tcpKeepAlive on, pgjdbc sets SO_KEEPALIVE only, thus the interval and the count of the namespace apply"
 	}
 });
-//#endregion
-//#region src/pg/node-postgres.ts
+// src/pg/node-postgres.ts
 const AT$10 = "pg 8.23.1 lib";
 const POOL = "pg-pool 3.14.0";
 /**
@@ -9613,8 +9594,7 @@ const NODE_POSTGRES = machineSchema.parse({
 		note: "Each socket of pg is a Linux TCP socket with TCP_NODELAY. At the defaults pg turns keepalive on for no socket, thus keepidle has no bound. With keepAlive on and a delay of 1 s or more, Node gives libuv the delay in whole seconds, with 1 s and 10 probes. With a delay below 1 s, libuv sets SO_KEEPALIVE and no other option, thus the three keepalive sysctls of the namespace apply"
 	}
 });
-//#endregion
-//#region src/pg/pgbouncer.ts
+// src/pg/pgbouncer.ts
 const PB = "pgbouncer_1_26_1";
 /** These are the sources of both documents: the defaults, the janitor and its clock. */
 const PB_COMMON = [
@@ -10271,8 +10251,7 @@ const PGBOUNCER_CLIENT = machineSchema.parse({
 		note: "Each socket has TCP_NODELAY and SO_KEEPALIVE. At the defaults PgBouncer sets no time of the keepalive, thus the keepidle, the interval and the count of the namespace apply. A waiting client is not read: the kernel takes its FIN, and PgBouncer does not see it"
 	}
 });
-//#endregion
-//#region src/pg/pgbouncer-server.ts
+// src/pg/pgbouncer-server.ts
 /**
 * This document is PgBouncer 1.26.1 in transaction pooling, for one server connection of a pool:
 * from its launch to its close. It also gives the wait of the pool before its next connection after
@@ -10896,8 +10875,7 @@ const PGBOUNCER_SERVER = machineSchema.parse({
 		note: "As for the client: TCP_NODELAY and SO_KEEPALIVE, with the times of the keepalive of the namespace at the defaults. PgBouncer reads each server socket, thus the kernel's end of a socket reaches it at once"
 	}
 });
-//#endregion
-//#region src/pg/pgpool.ts
+// src/pg/pgpool.ts
 const PP = "V4_7_3";
 /**
 * This document is Pgpool-II 4.7.3 with one backend, for one session of a client. It gives the states
@@ -11322,8 +11300,7 @@ const PGPOOL_SESSION = machineSchema.parse({
 		note: "The socket of the client. It has TCP_NODELAY and no SO_KEEPALIVE. In a wait the child does not read it: the kernel takes its FIN, and Pgpool-II finds it at the next write"
 	}
 });
-//#endregion
-//#region src/pg/postgres-session.ts
+// src/pg/postgres-session.ts
 const AT$9 = "postgresql REL_17_11 src";
 const DOC = "postgresql REL_17_11 doc/src/sgml";
 /**
@@ -12133,8 +12110,7 @@ const POSTGRES_SESSION = machineSchema.parse({
 		note: "These sets hold at the GUC defaults: the backend turns on SO_KEEPALIVE and keeps each keepalive option of the namespace. A keepalive GUC above 0 replaces its sysctl here. In SENDING no timer of PostgreSQL acts. Thus the timers of the machine below end a send to a lost client, or SIGTERM does"
 	}
 });
-//#endregion
-//#region src/pg/supavisor-client.ts
+// src/pg/supavisor-client.ts
 const SV = "v2.9.13";
 /**
 * This document is Supavisor 2.9.13 in transaction mode, for one client connection. It gives the
@@ -12557,8 +12533,7 @@ const SUPAVISOR_CLIENT = machineSchema.parse({
 		note: "The socket of the client. ranch sets SO_KEEPALIVE and no other keepalive option, thus the three keepalive sysctls of the namespace apply. It also sets a send timeout of 30 s that closes the socket. That close has no timer here: the kernel sends the FIN only after the data before it, an assumption of this document"
 	}
 });
-//#endregion
-//#region src/pg/supavisor-server.ts
+// src/pg/supavisor-server.ts
 /**
 * This document is Supavisor 2.9.13 in transaction mode, for one server connection of the pool of a
 * tenant. It is one DbHandler, a gen_statem, from its start by the pool to its end.
@@ -12915,8 +12890,7 @@ const SUPAVISOR_SERVER = machineSchema.parse({
 		note: "The server socket, with TCP_NODELAY and no SO_KEEPALIVE. The DbHandler reads it in each state, thus the end of the socket reaches it at once"
 	}
 });
-//#endregion
-//#region src/procedures-ws.ts
+// src/procedures-ws.ts
 /**
 * This module holds the machine documents of the WebSocket transport of `@procedures/client` at
 * commit 2408cea of the client repository: 0.22.0 and two PATCHes after it. The WS and WST cells
@@ -12936,17 +12910,8 @@ const CT = `${AT$8}/client/transport.ts`;
 const ST$1 = `${AT$8}/server/transport.ts`;
 /** This text is the source of the version of the service that the lock of the client gives (pnpm-lock.yaml:443-454). */
 const SERVICE = "@mark1russell7/service 0.5.8 (systems 571e9e5) packages/service/src";
-/** This function gives the arithmetic of a duration in ms. */
-const arithmetic = (duration) => {
-	if (!("expr" in duration) || duration.unit !== "ms") throw new Error("not arithmetic in ms");
-	return duration.expr;
-};
 /** This text is the backoff of try n + 1 of the reconnect, in ms: `fired` is n. It reads the arithmetic of `backoffDelay`. */
-const RECONNECT_WAIT = "min(reconnect_initial_delay * pow(reconnect_backoff_multiplier, fired), reconnect_max_delay)";
-/** This text is the late bound of one Node timer, in ms, for a time in ms. */
-const late = (ms) => arithmetic(nodeTimerLateness(ms));
-/** This text is the early bound of one Node timer, in ms. */
-const EARLY = arithmetic(NODE_TIMER_EARLY);
+const RECONNECT_WAIT$1 = "min(reconnect_initial_delay * pow(reconnect_backoff_multiplier, fired), reconnect_max_delay)";
 /**
 * This document is the connection of the WebSocket client of `@procedures/client` 0.22.0 at
 * commit 2408cea (`WebSocketTransport`), over its socket class and its Linux TCP socket. The
@@ -13174,11 +13139,11 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
 				unit: "ms"
 			},
 			lateness: {
-				expr: `(heartbeat_misses - 1) * (${late("heartbeat_interval")}) + ${late("heartbeat_timeout")}`,
+				expr: `(heartbeat_misses - 1) * (${nodeLateMs("heartbeat_interval")}) + ${nodeLateMs("heartbeat_timeout")}`,
 				unit: "ms"
 			},
 			early: {
-				expr: `heartbeat_misses * (${EARLY})`,
+				expr: `heartbeat_misses * (${NODE_EARLY_MS})`,
 				unit: "ms"
 			},
 			arms: ["enter:AWAITING_PONG"],
@@ -13192,12 +13157,12 @@ const PROCEDURES_WS_CLIENT = machineSchema.parse({
 		},
 		reconnect: {
 			duration: {
-				expr: RECONNECT_WAIT,
+				expr: RECONNECT_WAIT$1,
 				unit: "ms"
 			},
-			lateness: nodeTimerLateness(RECONNECT_WAIT),
+			lateness: nodeTimerLateness(RECONNECT_WAIT$1),
 			early: {
-				expr: `reconnect_jitter * ${RECONNECT_WAIT} + ${EARLY}`,
+				expr: `reconnect_jitter * ${RECONNECT_WAIT$1} + ${NODE_EARLY_MS}`,
 				unit: "ms"
 			},
 			arms: ["enter:RECONNECTING"],
@@ -13501,11 +13466,11 @@ const PROCEDURES_WS_SERVER = machineSchema.parse({
 			unit: "ms"
 		},
 		lateness: {
-			expr: `heartbeat_misses * (${late("heartbeat_interval")})`,
+			expr: `heartbeat_misses * (${nodeLateMs("heartbeat_interval")})`,
 			unit: "ms"
 		},
 		early: {
-			expr: `heartbeat_misses * (${EARLY})`,
+			expr: `heartbeat_misses * (${NODE_EARLY_MS})`,
 			unit: "ms"
 		},
 		arms: ["enter:MISSING"],
@@ -13575,8 +13540,7 @@ const PROCEDURES_WS_SERVER = machineSchema.parse({
 		ends: "socket.error"
 	}
 });
-//#endregion
-//#region src/proxy/caddy.ts
+// src/proxy/caddy.ts
 const AT$7 = "caddy v2.11.7";
 const XNET = "x/net v0.59.0";
 /**
@@ -13936,8 +13900,7 @@ const CADDY_HTTP2 = machineSchema.parse({
 		note: "The socket toward the client: a Linux TCP socket with the keepalive of Go. The socket toward the upstream has 15 s, 30 s and 9 probes"
 	}
 });
-//#endregion
-//#region src/proxy/envoy.ts
+// src/proxy/envoy.ts
 const AT$6 = "envoy v1.39.4";
 /**
 * This document is Envoy 1.39.4 as an HTTP/2 proxy of gRPC, for one connection of a client. Its static
@@ -14382,11 +14345,10 @@ const ENVOY_HTTP2 = machineSchema.parse({
 		note: "The socket toward the client: a Linux TCP socket with TCP_NODELAY and no keepalive. The socket toward the cluster is the same"
 	}
 });
-//#endregion
-//#region src/proxy/haproxy.ts
+// src/proxy/haproxy.ts
 const AT$5 = "haproxy-3.2 v3.2.25";
 const ST = "src/stream.c";
-const SC = "src/stconn.c";
+const SC$1 = "src/stconn.c";
 /**
 * This document is one connection of HAProxy 3.2.25 in TCP mode, with the configuration of T02:
 * `mode tcp`, `timeout client`, `timeout server`, `option clitcpka` and `option srvtcpka`. It sets
@@ -14423,7 +14385,7 @@ const HAPROXY_TCP = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5} ${SC}:394-398 the attach of the stream starts the timer of the client, and ${ST}:980 the connect starts the timer of the server`,
+			ref: `${AT$5} ${SC$1}:394-398 the attach of the stream starts the timer of the client, and ${ST}:980 the connect starts the timer of the server`,
 			rung: "implemented"
 		},
 		{
@@ -14431,11 +14393,11 @@ const HAPROXY_TCP = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5} include/haproxy/stconn.h:194-198 an activity is now_ms, and ${SC}:1538-1544 a read of bytes reports one`,
+			ref: `${AT$5} include/haproxy/stconn.h:194-198 an activity is now_ms, and ${SC$1}:1538-1544 a read of bytes reports one`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5} include/haproxy/stconn.h:206-223 and ${SC}:1801-1803, :1817 a send of bytes reports one, because no option independent-streams sets SC_FL_INDEP_STR (${ST}:485-489, src/proxy.c:2573-2575)`,
+			ref: `${AT$5} include/haproxy/stconn.h:206-223 and ${SC$1}:1801-1803, :1817 a send of bytes reports one, because no option independent-streams sets SC_FL_INDEP_STR (${ST}:485-489, src/proxy.c:2573-2575)`,
 			rung: "implemented"
 		},
 		{
@@ -14451,7 +14413,7 @@ const HAPROXY_TCP = machineSchema.parse({
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$5} ${SC}:750-772 an abort does no system call while the side is not shut, and ${SC}:782-837 a shut sends a FIN (:807-809), or closes the socket after an abort (:812)`,
+			ref: `${AT$5} ${SC$1}:750-772 an abort does no system call while the side is not shut, and ${SC$1}:782-837 a shut sends a FIN (:807-809), or closes the socket after an abort (:812)`,
 			rung: "implemented"
 		},
 		{
@@ -14716,8 +14678,7 @@ const HAPROXY_TCP = machineSchema.parse({
 		note: "Each socket of HAProxy, toward the client and toward the server: a Linux TCP socket with SO_KEEPALIVE and the keepalive sysctls of its namespace"
 	}
 });
-//#endregion
-//#region src/proxy/istio.ts
+// src/proxy/istio.ts
 const IS = "istio 1.31.3";
 const AT$4 = "envoy v1.39.4";
 /** These sources hold for both sides of a sidecar of Istio 1.31.3. */
@@ -15404,8 +15365,7 @@ const PILOT_AGENT = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/proxy/nginx.ts
+// src/proxy/nginx.ts
 const AT$3 = "nginx release-1.29.6";
 const V2 = "src/http/v2/ngx_http_v2.c";
 const UP = "src/http/ngx_http_upstream.c";
@@ -15792,8 +15752,7 @@ const NGINX_GRPC = machineSchema.parse({
 		note: "The socket toward the client: a Linux TCP socket with no keepalive (so_keepalive is off at the defaults). The lingering close sends a FIN with shutdown(SHUT_WR)"
 	}
 });
-//#endregion
-//#region src/proxy/traefik.ts
+// src/proxy/traefik.ts
 const AT$2 = "traefik v3.7.15";
 const H2 = "go1.26.9 src/net/http/h2_bundle.go";
 /**
@@ -16146,8 +16105,7 @@ const TRAEFIK_HTTP2 = machineSchema.parse({
 		note: "The socket toward the client: a Linux TCP socket. Its keepalive is the one of the listener of Go, which the source of this document does not name"
 	}
 });
-//#endregion
-//#region src/proxy/tcp-proxies.ts
+// src/proxy/tcp-proxies.ts
 const TOXI = "toxiproxy v2.12.0";
 const MOBY = "moby docker-v29.1.5";
 /** These are the facts of Go that both proxies share: the TCP keepalive of a socket that the caller does not set. */
@@ -16512,8 +16470,7 @@ const DOCKER_PROXY_LINK = machineSchema.parse({
 	],
 	over: overOf(["linked", "half-closed"])
 });
-//#endregion
-//#region src/proxy/ztunnel.ts
+// src/proxy/ztunnel.ts
 const Z = "ztunnel 1.31.3";
 const I = "istio 1.31.3";
 /**
@@ -17075,8 +17032,7 @@ const ZTUNNEL_HBONE = machineSchema.parse({
 		note: "The HBONE socket in the network namespace of the client pod: a Linux TCP socket with the keepalive of ztunnel and no TCP_USER_TIMEOUT. A peer that is gone ends it at 180 + 9 × 180 = 1800 s, after the PING"
 	}
 });
-//#endregion
-//#region src/rabbit/amqplib.ts
+// 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
@@ -17526,8 +17482,7 @@ const AMQPLIB = machineSchema.parse({
 		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
+// 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
@@ -17744,8 +17699,7 @@ const ATEN_DETECTOR = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/rabbit/ra-member.ts
+// src/rabbit/ra-member.ts
 const RA = "ra 3.1.10 src";
 const RMQ$1 = "rabbitmq v4.3.6 deps/rabbit/src";
 /**
@@ -18115,8 +18069,7 @@ const RA_MEMBER = machineSchema.parse({
 		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
+// 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
@@ -18516,8 +18469,7 @@ const RABBITMQ_CONNECTION = machineSchema.parse({
 		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
+// src/sentinel.ts
 const AT = "valkey 9.1.2 src/sentinel.c";
 /**
 * This document is the Sentinel of Valkey 9.1.2. It gives the view of one Sentinel on the primary
@@ -19099,8 +19051,545 @@ const SENTINEL = machineSchema.parse({
 		}
 	]
 });
-//#endregion
-//#region src/index.ts
+// src/socketio.ts
+/**
+* This module holds the machine documents of Socket.IO 4.8.4 on Node, with the WebSocket transport
+* only. The client is socket.io-client 4.8.4 on engine.io-client 6.6.7. The server is socket.io
+* 4.8.4 on engine.io 6.6.11. Both use ws 8.21.3. The Socket.IO cells (SYS-87) operate
+* them from the lockfile of `packages/cells/targets/socketio`. Each fact comes from the published
+* tarball of each version, or from Node v24.21.0. The comments and the sources give the file and
+* the line. Node loads the build `build/esm-debug` of each client package (the condition `node` of
+* its exports), and the server packages are CommonJS (`build`).
+*
+* The protocol is engine.io 4. The server writes a ping each pingInterval, and the client answers
+* with a pong. Each side has its own timer. The server waits pingTimeout for the pong of its ping.
+* The client waits pingInterval + pingTimeout for the next ping. The handshake gives the client
+* both times, thus the client has no setting of its own for its heartbeat.
+*/
+/** This text is the client package of the engine at its version. */
+const EC = "engine.io-client 6.6.7 build/esm-debug";
+/** This text is the client package of Socket.IO at its version. */
+const SC = "socket.io-client 4.8.4 build/esm-debug";
+/** This text is the server package of the engine at its version. */
+const ES = "engine.io 6.6.11 build";
+/** This text is the ws package at its version. */
+const WS = "ws 8.21.3 lib";
+/** This text is the wait of the client for the next ping, in ms: the sum that the handshake gives. */
+const PING_WAIT = "ping_interval + ping_timeout";
+/**
+* This text is the backoff of try n + 1 of the reconnect, in ms, before its jitter: `fired` is n.
+* The Backoff of socket.io-client has the factor 2.
+*/
+const BACKOFF = "reconnection_delay * pow(2, fired)";
+/** This text is the wait of try n + 1 of the reconnect with no jitter, in ms. */
+const RECONNECT_WAIT = `min(${BACKOFF}, reconnection_delay_max)`;
+/**
+* This document is the connection of the Manager of socket.io-client 4.8.4 over engine.io-client
+* 6.6.7, with the Node WebSocket transport (the ws package), over its Linux TCP socket.
+*
+* - The client waits pingInterval + pingTimeout for each ping. The handshake arms the timer, and
+*   each ping arms it again. No other packet and no write moves it. At its end the client closes
+*   the connection with the reason "ping timeout".
+* - The close of the client is close() of ws: a close frame. The socket stays open below it until
+*   the peer answers, or for the close timeout of ws (30 s).
+* - Each close starts the reconnect of the Manager, when it is on. The wait of try n + 1 is
+*   min(reconnectionDelay × 2^n, reconnectionDelayMax), with a jitter of ± randomizationFactor of
+*   the backoff before its cap. An open sets n to 0, and so does each close of an open connection.
+* - Each try has a time limit (`timeout` of the Manager).
+* - A call with an acknowledgement has its own time limit, and the connection stays.
+*/
+const SOCKETIO_CLIENT = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "socketio-client",
+	title: "The connection of the Manager of socket.io-client 4.8.4 (engine.io-client 6.6.7, ws 8.21.3)",
+	layer: "driver",
+	version: "4.8.4",
+	conditions: {
+		"socket.io-client": "4.8.4",
+		"engine.io-client": "6.6.7",
+		ws: "8.21.3",
+		node: "24.21.0",
+		kernel: "Linux 6.6"
+	},
+	sources: [
+		{
+			ref: `${EC}/socket.js:401-414 onHandshake: pingInterval and pingTimeout come from the server (:406-407), and the timer starts (:413); :373-378 each ping writes a pong and starts the timer again (:377); :420-430 _resetPingTimeout: the delay is pingInterval + pingTimeout (:422), and at its end the reason "ping timeout" (:425)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${EC}/socket.js:639-669 _onClose: transport.close() (:649); ${EC}/transport.js:55-61 close() of an open transport calls doClose(); ${EC}/transports/websocket.js:81-87 doClose calls close() of its WebSocket`,
+			rung: "implemented"
+		},
+		{
+			ref: `${WS}/websocket.js:302-340 close(): a handshake is aborted (:304-307); an open socket writes a close frame, then setCloseTimer (:1309-1314) destroys it after CLOSE_TIMEOUT, 30000 ms (lib/constants.js:10)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${SC}/manager.js:23-33 the options: reconnectionAttempts || Infinity (:24), reconnectionDelay || 1000 (:25), reconnectionDelayMax || 5000 (:26), randomizationFactor ?? 0.5 (:27), timeout 20000 (:33)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${SC}/manager.js:315-326 onclose: the backoff goes back to 0 (:320), then reconnect() (:324); :332-374 reconnect: backoff.duration() (:343), a timer, then open() (:354), and a failed try starts the next wait (:357-358); :380-385 an open sets the backoff to 0`,
+			rung: "implemented"
+		},
+		{
+			ref: `${SC}/contrib/backo2.js:26-34 duration: min × factor^attempts (:27), factor 2 (:16), the jitter adds or subtracts floor(rand × jitter × ms) (:28-32), then min(ms, max) | 0 (:33)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${SC}/manager.js:140-156 the time limit of each try: an error "timeout", and close() of the engine`,
+			rung: "implemented"
+		},
+		{
+			ref: `${EC}/transports/websocket.node.js: createSocket gives new WebSocket of ws with the URL and the options of the engine. ws sets no keepalive on its socket, and the engine gives it none`,
+			rung: "implemented"
+		}
+	],
+	states: {
+		DISCONNECTED: {
+			initial: true,
+			note: "no socket"
+		},
+		CONNECTING: { note: "a try, with its time limit" },
+		CONNECTED: { note: "the handshake ended: the ping timer runs" },
+		RECONNECTING: { note: "the wait before the next try" }
+	},
+	events: {
+		connect: {
+			kind: "app",
+			note: "the Manager opens"
+		},
+		open: {
+			kind: "rx",
+			note: "the handshake of the engine: the backoff goes back to 0"
+		},
+		"connect-timeout": { kind: "timer" },
+		"rx.ping": {
+			kind: "rx",
+			note: "a ping of the server: the client writes a pong"
+		},
+		"ping-timeout": { kind: "timer" },
+		drop: {
+			kind: "local",
+			note: "the close event of the socket: a FIN, a reset, a give-up of the kernel, or a failed try"
+		},
+		"reconnect-due": { kind: "timer" },
+		"give-up": {
+			kind: "local",
+			note: "a close without reconnect, or without tries left"
+		},
+		"tx.request": {
+			kind: "tx",
+			note: "an event with an acknowledgement"
+		},
+		"rx.reply": {
+			kind: "rx",
+			note: "the acknowledgement"
+		},
+		"request-timeout": { kind: "timer" },
+		close: {
+			kind: "app",
+			note: "close() of the application"
+		}
+	},
+	knobs: {
+		ping_interval: {
+			key: "pingInterval (from the handshake)",
+			scope: "server",
+			unit: "ms",
+			default: 25e3
+		},
+		ping_timeout: {
+			key: "pingTimeout (from the handshake)",
+			scope: "server",
+			unit: "ms",
+			default: 2e4
+		},
+		reconnection_delay: {
+			key: "reconnectionDelay",
+			scope: "client",
+			unit: "ms",
+			default: 1e3
+		},
+		reconnection_delay_max: {
+			key: "reconnectionDelayMax",
+			scope: "client",
+			unit: "ms",
+			default: 5e3
+		},
+		reconnection_attempts: {
+			key: "reconnectionAttempts",
+			scope: "client",
+			unit: "count",
+			default: null,
+			note: "Infinity at the default"
+		},
+		randomization_factor: {
+			key: "randomizationFactor",
+			scope: "client",
+			unit: "count",
+			default: .5,
+			note: "the random part of each wait, from 0 to 1: the backoff, plus or minus floor(r × factor × backoff)"
+		},
+		connect_timeout: {
+			key: "timeout",
+			scope: "client",
+			unit: "ms",
+			default: 2e4,
+			note: "the time limit of each try"
+		},
+		request_timeout: {
+			key: "socket.timeout()",
+			scope: "client",
+			unit: "ms",
+			default: null,
+			note: "no time limit at the default"
+		},
+		hz: {
+			key: "CONFIG_HZ",
+			scope: "global",
+			unit: "Hz",
+			default: null,
+			note: "the HZ of the kernel, for the step of the coarse loop clock of libuv (http/timers.ts)"
+		}
+	},
+	timers: {
+		ping: {
+			duration: {
+				expr: PING_WAIT,
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness(PING_WAIT),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:CONNECTED", "rx.ping"],
+			cancels: ["drop", "close"],
+			fires: "ping-timeout",
+			note: "from the last ping that reached the client, or from the handshake. Data of the connection does not move it"
+		},
+		reconnect: {
+			duration: {
+				expr: RECONNECT_WAIT,
+				unit: "ms"
+			},
+			lateness: {
+				expr: `randomization_factor * ${BACKOFF} + ${nodeLateMs(RECONNECT_WAIT)}`,
+				unit: "ms"
+			},
+			early: {
+				expr: `randomization_factor * ${BACKOFF} + ${NODE_EARLY_MS}`,
+				unit: "ms"
+			},
+			arms: ["enter:RECONNECTING"],
+			cancels: ["close"],
+			fires: "reconnect-due",
+			backoff: { resets: ["open", "drop"] },
+			note: "the jitter adds or subtracts at most randomizationFactor × the backoff before its cap: both bounds"
+		},
+		connect: {
+			duration: {
+				knob: "connect_timeout",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("connect_timeout"),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:CONNECTING"],
+			cancels: [
+				"open",
+				"drop",
+				"close"
+			],
+			fires: "connect-timeout"
+		},
+		request: {
+			duration: {
+				knob: "request_timeout",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("request_timeout"),
+			early: NODE_TIMER_EARLY,
+			arms: ["tx.request"],
+			cancels: ["rx.reply", "close"],
+			fires: "request-timeout",
+			note: "one timer for each call: it fails the call, and the connection stays"
+		}
+	},
+	transitions: [
+		{
+			id: "sc.connect",
+			from: "DISCONNECTED",
+			on: "connect",
+			to: "CONNECTING"
+		},
+		{
+			id: "sc.open",
+			from: "CONNECTING",
+			on: "open",
+			to: "CONNECTED",
+			source: `${EC}/socket.js:401-414`
+		},
+		{
+			id: "sc.connect-timeout",
+			from: "CONNECTING",
+			on: "connect-timeout",
+			to: "RECONNECTING",
+			timer: "connect",
+			source: `${SC}/manager.js:144-149`
+		},
+		{
+			id: "sc.ping",
+			from: "CONNECTED",
+			on: "rx.ping",
+			to: "CONNECTED",
+			emits: ["tx.pong"],
+			source: `${EC}/socket.js:373-378`
+		},
+		{
+			id: "sc.ping-timeout",
+			from: "CONNECTED",
+			on: "ping-timeout",
+			to: "RECONNECTING",
+			timer: "ping",
+			emits: ["tx.close-frame"],
+			note: "close() of ws writes a close frame, and the socket stays open below it",
+			source: `${EC}/socket.js:424-426, :649`
+		},
+		{
+			id: "sc.drop",
+			from: ["CONNECTING", "CONNECTED"],
+			on: "drop",
+			to: "RECONNECTING",
+			guard: "the reconnect is on, and tries are left",
+			source: `${SC}/manager.js:315-326, :354-359`
+		},
+		{
+			id: "sc.give-up",
+			from: ["CONNECTING", "CONNECTED"],
+			on: "give-up",
+			to: "DISCONNECTED",
+			source: `${SC}/manager.js:336-341`
+		},
+		{
+			id: "sc.reconnect",
+			from: "RECONNECTING",
+			on: "reconnect-due",
+			to: "CONNECTING",
+			timer: "reconnect",
+			source: `${SC}/manager.js:346-366`
+		},
+		{
+			id: "sc.request-timeout",
+			from: "CONNECTED",
+			on: "request-timeout",
+			to: "CONNECTED",
+			timer: "request",
+			errno: "TIMEOUT"
+		},
+		{
+			id: "sc.close",
+			from: [
+				"CONNECTING",
+				"CONNECTED",
+				"RECONNECTING"
+			],
+			on: "close",
+			to: "DISCONNECTED"
+		}
+	],
+	over: {
+		machine: "systems.machine.linux-tcp",
+		states: {
+			CONNECTING: "SYN_SENT",
+			CONNECTED: "ESTABLISHED"
+		},
+		sets: {},
+		ends: "drop",
+		note: "ws turns no keepalive on, thus the keepalive sysctls of the namespace do not reach the socket"
+	}
+});
+/**
+* This document is one connection as the Server of socket.io 4.8.4 on engine.io 6.6.11 holds it.
+* The transport is WebSocket (ws 8.21.3), over its Linux TCP socket.
+*
+* - pingInterval after the handshake, or after the last pong, the server writes a ping. Then it
+*   waits pingTimeout for the pong, and at its end it closes the connection: close() of ws, a close
+*   frame. Thus the drop comes pingTimeout after the first ping without an answer.
+* - In that wait, the first packet that is not a pong starts the wait again, once for each ping.
+* - The http.Server of Node sets no SO_KEEPALIVE when keepAlive is off, its default.
+*/
+const SOCKETIO_SERVER = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "socketio-server",
+	title: "One connection as the Server of socket.io 4.8.4 (engine.io 6.6.11, ws 8.21.3) holds it",
+	layer: "server",
+	version: "4.8.4",
+	conditions: {
+		"socket.io": "4.8.4",
+		"engine.io": "6.6.11",
+		ws: "8.21.3",
+		node: "24.21.0",
+		kernel: "Linux 6.6"
+	},
+	sources: [
+		{
+			ref: `${ES}/server.js:48-49 the defaults: pingTimeout 20000 and pingInterval 25000`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ES}/socket.js:88-95 the handshake schedules the first ping (protocol 4); :166-173 schedulePing: after pingInterval, sendPacket("ping"), then resetPingTimeout; :179-188 resetPingTimeout: onClose("ping timeout") after pingTimeout`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ES}/socket.js:130-140 a pong clears the wait (:136-137) and starts the interval again (:138); :111-118 in the wait, the first packet that is not a pong starts the wait again, once`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ES}/socket.js:336-352 onClose clears the timers and calls clearTransport (:315-327), which calls close() of the transport (:327); ${ES}/transports/websocket.js:90-94 doClose calls close() of its WebSocket: a close frame (${WS}/websocket.js:302-340)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${ES}/socket.js:386-409 sendPacket emits packetCreate (:402) before the write of the packet: the line of each ping`,
+			rung: "implemented"
+		},
+		{
+			ref: "node v24.21.0 lib/_http_server.js:646-651 and lib/net.js:2753-2756: keepAlive of http.Server is off at the default, thus an accepted socket has no SO_KEEPALIVE",
+			rung: "implemented"
+		}
+	],
+	states: {
+		ABSENT: {
+			initial: true,
+			pseudo: true
+		},
+		OPEN: { note: "the interval to the next ping runs" },
+		AWAITING_PONG: { note: "a ping went out: its wait runs" },
+		CLOSED: { final: true }
+	},
+	events: {
+		accept: {
+			kind: "local",
+			note: "the handshake of the engine"
+		},
+		"ping-due": { kind: "timer" },
+		"rx.pong": { kind: "rx" },
+		"rx.packet": {
+			kind: "rx",
+			note: "a packet that is not a pong"
+		},
+		"pong-timeout": { kind: "timer" },
+		close: {
+			kind: "peer",
+			note: "the close event of the socket of ws"
+		},
+		"socket.error": {
+			kind: "local",
+			note: "the kernel beneath gave up on the socket, or a reset arrived"
+		}
+	},
+	knobs: {
+		ping_interval: {
+			key: "pingInterval",
+			scope: "server",
+			unit: "ms",
+			default: 25e3
+		},
+		ping_timeout: {
+			key: "pingTimeout",
+			scope: "server",
+			unit: "ms",
+			default: 2e4
+		},
+		hz: {
+			key: "CONFIG_HZ",
+			scope: "global",
+			unit: "Hz",
+			default: null
+		}
+	},
+	timers: {
+		ping: {
+			duration: {
+				knob: "ping_interval",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("ping_interval"),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:OPEN"],
+			cancels: ["close"],
+			fires: "ping-due",
+			backoff: { resets: ["rx.pong"] },
+			note: "a timer that starts again at each pong: each firing writes a ping, and the pong timer gives up on it"
+		},
+		pong: {
+			duration: {
+				knob: "ping_timeout",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("ping_timeout"),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:AWAITING_PONG"],
+			cancels: ["rx.pong", "close"],
+			fires: "pong-timeout",
+			note: "from the write of the ping. The first packet that is not a pong in the wait starts it again, once (rx.packet)"
+		}
+	},
+	transitions: [
+		{
+			id: "ss.accept",
+			from: "ABSENT",
+			on: "accept",
+			to: "OPEN"
+		},
+		{
+			id: "ss.ping",
+			from: "OPEN",
+			on: "ping-due",
+			to: "AWAITING_PONG",
+			timer: "ping",
+			emits: ["tx.ping"],
+			source: `${ES}/socket.js:166-173`
+		},
+		{
+			id: "ss.pong",
+			from: "AWAITING_PONG",
+			on: "rx.pong",
+			to: "OPEN",
+			source: `${ES}/socket.js:130-140`
+		},
+		{
+			id: "ss.refresh",
+			from: "AWAITING_PONG",
+			on: "rx.packet",
+			to: "AWAITING_PONG",
+			note: "the wait starts again once for each ping: a later packet does not move it",
+			source: `${ES}/socket.js:111-118`
+		},
+		{
+			id: "ss.pong-timeout",
+			from: "AWAITING_PONG",
+			on: "pong-timeout",
+			to: "CLOSED",
+			timer: "pong",
+			emits: ["tx.close-frame"],
+			source: `${ES}/socket.js:179-188, :336-352`
+		},
+		{
+			id: "ss.close",
+			from: ["OPEN", "AWAITING_PONG"],
+			on: ["close", "socket.error"],
+			to: "CLOSED"
+		}
+	],
+	over: {
+		machine: "systems.machine.linux-tcp",
+		states: {
+			OPEN: "ESTABLISHED",
+			AWAITING_PONG: "ESTABLISHED"
+		},
+		sets: {},
+		ends: "socket.error"
+	}
+});
+// src/index.ts
 /** This function gives each document by its identifier. Two documents with one identifier stop the import. */
 const byId = (documents) => {
 	const out = {};
@@ -19128,6 +19617,8 @@ const MACHINES = byId([
 	GO_TRANSPORT,
 	PROCEDURES_WS_CLIENT,
 	PROCEDURES_WS_SERVER,
+	SOCKETIO_CLIENT,
+	SOCKETIO_SERVER,
 	MONGODB_NODE,
 	MONGOD_REPL,
 	MONGOD_SESSION,
@@ -19162,7 +19653,6 @@ const MACHINES = byId([
 	DEADLINE_CALL,
 	KUBELET_READINESS
 ]);
-//#endregion
-export { AMQPLIB, ATEN_DETECTOR, CADDY_HTTP2, DEADLINE_CALL, DOCKER_PROXY_LINK, ENVOY_HTTP2, ETCD_SERVER, GO_TRANSPORT, GRPC_GO_SERVER, GRPC_JS, HAPROXY_TCP, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, ISTIO_SIDECAR_INBOUND, ISTIO_SIDECAR_OUTBOUND, KAFKA_CONSUMER_GROUP, KAFKA_PARTITION, KUBELET_READINESS, LINUX_TCP, MACHINES, MANIFESTATIONS, MONGODB_NODE, MONGOD_REPL, MONGOD_SESSION, NF_CONNTRACK_TCP, NGINX_GRPC, NODE_HTTP_AGENT, NODE_HTTP_SERVER, NODE_POSTGRES, NODE_TIMER_EARLY, PGBOUNCER_CLIENT, PGBOUNCER_SERVER, PGPOOL_SESSION, PILOT_AGENT, POSTGRES_SESSION, PROCEDURES_WS_CLIENT, PROCEDURES_WS_SERVER, RABBITMQ_CONNECTION, RA_MEMBER, REDIS_CLIENT, SENTINEL, SUPAVISOR_CLIENT, SUPAVISOR_SERVER, TOXIPROXY_LINK, TRAEFIK_HTTP2, UNDICI_CLIENT, UNDICI_RETRY, UNDICI_TICK_MS, ZTUNNEL_HBONE, goLateSeconds, goTimerLateness, istioSidecar, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
+export { AMQPLIB, ATEN_DETECTOR, CADDY_HTTP2, DEADLINE_CALL, DOCKER_PROXY_LINK, ENVOY_HTTP2, ETCD_SERVER, GO_TRANSPORT, GRPC_GO_SERVER, GRPC_JS, HAPROXY_TCP, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, ISTIO_SIDECAR_INBOUND, ISTIO_SIDECAR_OUTBOUND, KAFKA_CONSUMER_GROUP, KAFKA_PARTITION, KUBELET_READINESS, LINUX_TCP, MACHINES, MANIFESTATIONS, MONGODB_NODE, MONGOD_REPL, MONGOD_SESSION, NF_CONNTRACK_TCP, NGINX_GRPC, NODE_HTTP_AGENT, NODE_HTTP_SERVER, NODE_POSTGRES, NODE_TIMER_EARLY, PGBOUNCER_CLIENT, PGBOUNCER_SERVER, PGPOOL_SESSION, PILOT_AGENT, POSTGRES_SESSION, PROCEDURES_WS_CLIENT, PROCEDURES_WS_SERVER, RABBITMQ_CONNECTION, RA_MEMBER, REDIS_CLIENT, SENTINEL, SOCKETIO_CLIENT, SOCKETIO_SERVER, SUPAVISOR_CLIENT, SUPAVISOR_SERVER, TOXIPROXY_LINK, TRAEFIK_HTTP2, UNDICI_CLIENT, UNDICI_RETRY, UNDICI_TICK_MS, ZTUNNEL_HBONE, goLateSeconds, goTimerLateness, istioSidecar, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
 
 //# sourceMappingURL=index.js.map