@mark1russell7/machines 0.3.25 → 0.3.26

package/README.md

@@ -65,8 +65,9 @@ The algebra reads these documents. It gives the closed form of each timer, the f
 | `ISTIO_SIDECAR_OUTBOUND` | `istio-sidecar-outbound` | The client sidecar of Istio 1.31.3: Envoy 1.39.4 between the app and the mesh, its retries, an update of LDS and the SIGKILL | proxy | 31 implemented |
 | `ISTIO_SIDECAR_INBOUND` | `istio-sidecar-inbound` | The server sidecar of Istio 1.31.3: Envoy 1.39.4 between the mesh and the app, the policy, an update of LDS and the SIGKILL | proxy | 31 implemented |
 | `PILOT_AGENT` | `pilot-agent` | pilot-agent of Istio 1.31.3: the drain and the SIGKILL of the Envoy of a sidecar at the stop of its pod | proxy | 12 implemented |
+| `ZTUNNEL_HBONE` | `ztunnel-hbone` | ztunnel 1.31.3 in in-pod mode: one HBONE connection from a client pod to a server pod, its PING, its drain and the close of each flow of the app | proxy | 14 implemented, 3 derived |
 
-Thirty-two documents operate on Linux TCP (`over`). Eight documents operate on no other document. They are Linux TCP, conntrack, the Sentinel, the replication of mongod, aten, the member of Ra, the `RetryAgent` of undici and pilot-agent.
+Thirty-three documents operate on Linux TCP (`over`). Eight documents operate on no other document. They are Linux TCP, conntrack, the Sentinel, the replication of mongod, aten, the member of Ra, the `RetryAgent` of undici and pilot-agent.
 
 The `RetryAgent` is one request above the sockets of a `Client`. Its timer is the delay of a retry. Each retry can go on a new socket. The `conditions` of each document give the range where it holds, for example a range of kernels.
 
@@ -114,6 +115,15 @@ A change to the version of a system changes its sources too. Each fact of the do
 
 In this repository, a snapshot of the predictions of the cells (`packages/cells/src/__snapshots__/predictions.json`) shows each prediction that a change to a document moves.
 
+### 0.3.26
+
+- **ztunnel 1.31.3 for T15** (`ztunnel-hbone`). This new document is one HBONE connection of the ambient mesh, from the source at its tag.
+  - The PING has a fixed cadence: a PING 10 s after the last PONG, then at most 20 s for its PONG. Both are constants, and data does not put a PING off. Thus a black hole is found 20 s to 30 s later.
+  - At the end of a stream or of its connection, ztunnel shuts down the socket of each app: a FIN. A connect to 15008 that fails closes the socket of the app before any byte of an answer.
+  - The connect times out at 10 s. At SIGTERM, ztunnel sends GOAWAY and ends what is left at its deadline of 25 s. It has no idle timeout and no maximum age of a connection.
+  - The HBONE socket is Linux TCP with a keepalive of 180 s, 180 s and 9 probes, and no TCP_USER_TIMEOUT.
+  - The cell T15.defaults.12 cites it. It reads no timer of the document, thus it moves no prediction of the snapshot.
+
 ### 0.3.25
 
 - **The sidecar of Istio 1.31.3 for T15.** Three new documents, each from the source at its tag. `istioSidecar(side)` builds the two sidecars from `envoy-http2`, because the proxy of Istio 1.31.3 has the code of Envoy 1.39.4.

package/build/index.d.ts

@@ -510,6 +510,23 @@ export declare const TOXIPROXY_LINK: Machine;
  */
 export declare const DOCKER_PROXY_LINK: Machine;
 //#endregion
+//#region src/proxy/ztunnel.d.ts
+/**
+ * This document is ztunnel 1.31.3 in the ambient mesh of Istio, in in-pod mode. It is one HBONE
+ * connection from the ztunnel of a client pod to the port 15008 of a server pod. The flows of the
+ * apps are its streams. The agent istio-cni redirects each connection of an app to the listener
+ * 15001 of ztunnel, in the network namespace of the pod. Thus the HBONE socket has the address of the pod.
+ *
+ * The PING of the connection has a fixed cadence: 10 s of sleep, a PING, then at most 20 s for its
+ * PONG. Both are constants, and data does not put a PING off. Thus a link that fails is found 20 s to
+ * 30 s later.
+ *
+ * At the end of a stream or of its connection, ztunnel shuts down the socket of the app. The app then
+ * gets a FIN. No timer closes an idle connection or an old one. At SIGTERM, ztunnel sends GOAWAY, and
+ * it ends what is left at its deadline of 25 s.
+ */
+export declare const ZTUNNEL_HBONE: Machine;
+//#endregion
 //#region src/rabbit/amqplib.d.ts
 /**
  * This document is amqplib 2.2.0 on Node, for one connection to a broker of AMQP 0-9-1 and one channel

package/build/index.js

@@ -15139,6 +15139,513 @@ const DOCKER_PROXY_LINK = machineSchema.parse({
 	over: overOf(["linked", "half-closed"])
 });
 //#endregion
+//#region src/proxy/ztunnel.ts
+const Z = "ztunnel 1.31.3";
+const I = "istio 1.31.3";
+/**
+* This document is ztunnel 1.31.3 in the ambient mesh of Istio, in in-pod mode. It is one HBONE
+* connection from the ztunnel of a client pod to the port 15008 of a server pod. The flows of the
+* apps are its streams. The agent istio-cni redirects each connection of an app to the listener
+* 15001 of ztunnel, in the network namespace of the pod. Thus the HBONE socket has the address of the pod.
+*
+* The PING of the connection has a fixed cadence: 10 s of sleep, a PING, then at most 20 s for its
+* PONG. Both are constants, and data does not put a PING off. Thus a link that fails is found 20 s to
+* 30 s later.
+*
+* At the end of a stream or of its connection, ztunnel shuts down the socket of the app. The app then
+* gets a FIN. No timer closes an idle connection or an old one. At SIGTERM, ztunnel sends GOAWAY, and
+* it ends what is left at its deadline of 25 s.
+*/
+const ZTUNNEL_HBONE = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "ztunnel-hbone",
+	title: "ztunnel 1.31.3 in in-pod mode: one HBONE connection from a client pod to a server pod, its PING, its drain and the close of each flow of the app",
+	layer: "proxy",
+	version: "1.31.3",
+	conditions: {
+		ztunnel: "1.31.3",
+		istio: "1.31.3 with the profile ambient: istio-cni and ztunnel on each node",
+		mode: "in-pod: istio-cni redirects the traffic of each pod to the listeners of ztunnel in the network namespace of the pod",
+		connection: "one HBONE connection to the port 15008 of a server pod, with mTLS and HTTP/2, and its streams"
+	},
+	sources: [
+		{
+			ref: `${Z} src/proxy/h2/client.rs:50-58 and src/proxy/outbound.rs:446-452 the key of the pool: the source identity, the destination identities, the destination address and the source IP. In in-pod mode the destination is the server pod at port 15008`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/config.rs:74, :106, :790 and src/proxy/h2/client.rs:183-190 at most 100 streams on one HBONE connection`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/config.rs:75, :105, :795 and src/proxy/pool.rs:142-146 POOL_UNUSED_RELEASE_TIMEOUT is 5 min. A release does not close the connection: HTTP/2 closes it when no reference and no stream is left`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy.rs:645, :695 the TCP connect of ztunnel times out at 10 s, a constant`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/h2.rs:31-76 the PING loop: 10 s of sleep, a PING, at most 20 s for its PONG, then again. PING_INTERVAL and PING_TIMEOUT are constants (:36-37)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/h2.rs:222-225 the PING is not data aware: data on the connection does not put a PING off`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/h2/client.rs:237-238 and src/proxy/h2/server.rs:160-168 at a PING timeout the client drops the connection, and the server calls abrupt_shutdown(NO_ERROR)`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/h2.rs:229-238 and src/copy.rs:176-183, :198-212 at the end of a stream or of its connection, the copy loop shuts down the socket of the app: a FIN`,
+			rung: "implemented"
+		},
+		{
+			ref: "linux v6.6 net/ipv4/tcp.c:2781-2807 the close of a socket with unread bytes in its receive queue sends a reset, and else a FIN",
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/config.rs:44-48, :355-360, :913-931 and src/proxy.rs:109-126 the TCP keepalive: 180 s idle, 180 s between probes and 9 probes, on each socket that ztunnel connects. No TCP_USER_TIMEOUT`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy, src/copy.rs and src/config.rs: no idle timeout of L4 and no maximum age of a connection, from a search of the tag`,
+			rung: "derived"
+		},
+		{
+			ref: `${Z} src/proxy/outbound.rs: a connect of the pool that fails ends the flow of the app before its copy starts. The app sees its socket close before any byte of an answer`,
+			rung: "derived"
+		},
+		{
+			ref: `${I} cni/pkg/nodeagent/informers.go:316-325, :396-408 and ${Z} src/inpod/statemanager.rs:170-191 and src/drain.rs:58-70 at the deletion of a pod, the node agent sends DelWorkload, and ztunnel drains the proxy of that pod at once`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/config.rs:101, :810-827 and src/app.rs:391-399 the deadline of the drain: CONNECTION_TERMINATION_DEADLINE, else the grace less 5 s. The chart sets the grace to 30 s (${I} manifests/charts/ztunnel/values.yaml:102): 25 s`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/h2/server.rs:170-172 and src/proxy/outbound.rs:121 at SIGTERM the accept loops stop, and the HBONE server sends GOAWAY`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} src/proxy/connection_manager.rs:133, :364-376 and src/proxy/inbound.rs:273-280 a CONNECT that a policy denies gets 401. At a change of a policy, ztunnel checks each open inbound connection again and closes each one that it now denies`,
+			rung: "implemented"
+		},
+		{
+			ref: `${Z} proto/workload.proto:148-198 the workload API has only routing preferences and a health policy for load balancing. No field of a DestinationRule reaches ztunnel on an L4 path`,
+			rung: "derived"
+		}
+	],
+	states: {
+		"[none]": {
+			initial: true,
+			pseudo: true,
+			note: "Before the first flow of the app that needs the connection"
+		},
+		connecting: { note: "The TCP connect and the TLS handshake to the port 15008 of the server pod. The flow of the app waits" },
+		ready: { note: "The connection carries the flows of the apps as streams. The PING loop runs" },
+		draining: { note: "After SIGTERM: the HBONE server sent GOAWAY, and the open streams go on until the deadline" },
+		ended: {
+			final: true,
+			note: "The connection closed. Each flow of the app on it got a FIN"
+		}
+	},
+	events: {
+		"local.accept": {
+			kind: "local",
+			note: "The listener 15001 accepts a connection of the app, and the pool has no connection for its key"
+		},
+		"local.connected": {
+			kind: "local",
+			note: "The TCP connect and the TLS handshake to 15008 complete"
+		},
+		"local.connect-failed": {
+			kind: "local",
+			note: "The connect to 15008 fails: a reset, a refusal or a failed handshake"
+		},
+		"local.stream-end": {
+			kind: "local",
+			note: "The last stream on the connection ends"
+		},
+		"local.policy-denied": {
+			kind: "local",
+			note: "A change of a policy denies the connection: on the side of the server"
+		},
+		"local.del-workload": {
+			kind: "local",
+			note: "DelWorkload of the node agent of istio-cni for the pod: its deletion"
+		},
+		"rx.pong": {
+			kind: "rx",
+			note: "The PONG of the last PING"
+		},
+		"peer.rst": {
+			kind: "peer",
+			note: "A reset of the HBONE socket"
+		},
+		"peer.fin": {
+			kind: "peer",
+			note: "An end of file of the HBONE socket, or the end of the HTTP/2 connection"
+		},
+		"app.stop": {
+			kind: "app",
+			note: "SIGTERM to ztunnel: a restart or a deletion of its pod"
+		},
+		"timer.connect": {
+			kind: "timer",
+			note: "The connect does not complete in 10 s"
+		},
+		"timer.ping": {
+			kind: "timer",
+			note: "10 s after the last PONG: the next PING"
+		},
+		"timer.pong": {
+			kind: "timer",
+			note: "No PONG for 20 s after a PING"
+		},
+		"timer.release": {
+			kind: "timer",
+			note: "No stream on the connection for the unused release timeout"
+		},
+		"timer.deadline": {
+			kind: "timer",
+			note: "The deadline of the drain after SIGTERM"
+		},
+		"tx.ping": {
+			kind: "tx",
+			note: "A PING of HTTP/2"
+		},
+		"tx.goaway": {
+			kind: "tx",
+			note: "A GOAWAY of the HBONE server"
+		},
+		"tx.close": {
+			kind: "tx",
+			note: "The close of the HBONE connection"
+		},
+		"tx.app-fin": {
+			kind: "tx",
+			note: "The shutdown of the socket of each flow of the app on the connection: a FIN, or a reset when bytes are unread"
+		},
+		"tx.app-close": {
+			kind: "tx",
+			note: "The close of the socket of the app whose flow waited for the connect, before any byte of an answer"
+		}
+	},
+	knobs: {
+		connect_timeout: {
+			key: "the TCP connect timeout of ztunnel",
+			scope: "build",
+			unit: "s",
+			default: 10,
+			note: "proxy.rs:645: a constant"
+		},
+		ping_interval: {
+			key: "PING_INTERVAL",
+			scope: "build",
+			unit: "s",
+			default: 10,
+			note: "h2.rs:36: a constant"
+		},
+		ping_timeout: {
+			key: "PING_TIMEOUT",
+			scope: "build",
+			unit: "s",
+			default: 20,
+			note: "h2.rs:37: a constant"
+		},
+		pool_release: {
+			key: "POOL_UNUSED_RELEASE_TIMEOUT",
+			scope: "process",
+			unit: "s",
+			default: 300,
+			note: "config.rs:75: 5 min, an environment variable"
+		},
+		deadline: {
+			key: "CONNECTION_TERMINATION_DEADLINE",
+			scope: "process",
+			unit: "s",
+			default: 25,
+			note: "config.rs:810-827: unset, thus the grace of 30 s of the chart less 5 s"
+		},
+		keepidle: {
+			key: "the TCP keepalive idle of ztunnel",
+			scope: "process",
+			unit: "s",
+			default: 180,
+			note: "config.rs:44-48"
+		},
+		keepintvl: {
+			key: "the TCP keepalive interval of ztunnel",
+			scope: "process",
+			unit: "s",
+			default: 180,
+			note: "config.rs:44-48"
+		},
+		keepcnt: {
+			key: "the TCP keepalive count of ztunnel",
+			scope: "process",
+			unit: "count",
+			default: 9,
+			note: "config.rs:44-48"
+		},
+		slack: {
+			key: "the lateness of the runtime of tokio for one step",
+			scope: "process",
+			unit: "s",
+			default: .01,
+			note: "An assumption of this document, not a value of ztunnel"
+		}
+	},
+	timers: {
+		connect: {
+			duration: {
+				knob: "connect_timeout",
+				unit: "s"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "s"
+			},
+			arms: ["enter:connecting"],
+			cancels: ["local.connected", "local.connect-failed"],
+			fires: "timer.connect",
+			note: "proxy.rs:645, :695"
+		},
+		ping: {
+			duration: {
+				knob: "ping_interval",
+				unit: "s"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "s"
+			},
+			arms: ["enter:ready", "rx.pong"],
+			fires: "timer.ping",
+			backoff: { resets: ["rx.pong"] },
+			note: "h2.rs:39, :56: the sleep before each PING. It starts again after each PONG, thus it detects nothing by itself"
+		},
+		pong: {
+			duration: {
+				expr: "ping_interval + ping_timeout",
+				unit: "s"
+			},
+			early: {
+				knob: "ping_interval",
+				unit: "s"
+			},
+			lateness: {
+				expr: "2 * slack",
+				unit: "s"
+			},
+			arms: ["enter:ready", "rx.pong"],
+			cancels: ["peer.rst", "peer.fin"],
+			fires: "timer.pong",
+			note: "h2.rs:46: the wait of 20 s for the PONG of the PING that comes 10 s after the last PONG. A failure at a time in the cycle is found 20 s to 30 s later, and data does not change it"
+		},
+		release: {
+			duration: {
+				knob: "pool_release",
+				unit: "s"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "s"
+			},
+			arms: ["local.stream-end"],
+			cancels: ["local.accept"],
+			fires: "timer.release",
+			note: "pool.rs:142-146: from the end of the last stream"
+		},
+		deadline: {
+			duration: {
+				knob: "deadline",
+				unit: "s"
+			},
+			lateness: {
+				knob: "slack",
+				unit: "s"
+			},
+			arms: ["app.stop"],
+			fires: "timer.deadline",
+			note: "app.rs:391-399: from SIGTERM"
+		}
+	},
+	realizes: {
+		"systems.mechanism.heartbeat-interval": { timer: "ping" },
+		"systems.mechanism.heartbeat-detection-time": {
+			duration: {
+				expr: "ping_interval + ping_timeout",
+				unit: "s"
+			},
+			lateness: {
+				expr: "2 * slack",
+				unit: "s"
+			},
+			note: "The PING 10 s after the last PONG, and the drop 20 s after the PING"
+		}
+	},
+	transitions: [
+		{
+			id: "zt.connect",
+			from: "[none]",
+			to: "connecting",
+			on: "local.accept",
+			timer: "connect",
+			source: "outbound.rs:446-452, client.rs:50-58"
+		},
+		{
+			id: "zt.connected",
+			from: "connecting",
+			to: "ready",
+			on: "local.connected",
+			timer: "pong",
+			source: "client.rs:183-190"
+		},
+		{
+			id: "zt.connect-failed",
+			from: "connecting",
+			to: "ended",
+			on: "local.connect-failed",
+			emits: ["tx.app-close"],
+			note: "A reset of the SYN to 15008 fails the connect at once. The app sees its socket close before any byte of an answer: a client of gRPC counts a failed connect",
+			source: "outbound.rs"
+		},
+		{
+			id: "zt.connect-timeout",
+			from: "connecting",
+			to: "ended",
+			on: "timer.connect",
+			timer: "connect",
+			emits: ["tx.app-close"],
+			source: "proxy.rs:645, :695"
+		},
+		{
+			id: "zt.ping",
+			from: "ready",
+			to: "ready",
+			on: "timer.ping",
+			timer: "ping",
+			emits: ["tx.ping"],
+			source: "h2.rs:39-46"
+		},
+		{
+			id: "zt.pong",
+			from: "ready",
+			to: "ready",
+			on: "rx.pong",
+			note: "The PONG starts the sleep and the wait again",
+			source: "h2.rs:46-56"
+		},
+		{
+			id: "zt.pong-timeout",
+			from: "ready",
+			to: "ended",
+			on: "timer.pong",
+			timer: "pong",
+			emits: ["tx.close", "tx.app-fin"],
+			note: "The client drops the connection, and the server calls abrupt_shutdown(NO_ERROR). Each flow of the app on it gets a FIN",
+			source: "client.rs:237-238, server.rs:160-168, copy.rs:176-183"
+		},
+		{
+			id: "zt.reset",
+			from: ["ready", "draining"],
+			to: "ended",
+			on: ["peer.rst", "peer.fin"],
+			emits: ["tx.app-fin"],
+			note: "A reset or an end of file of the HBONE socket ends each stream. The copy loop shuts down the socket of each app: a FIN, not a reset",
+			source: "h2.rs:229-238, copy.rs:198-212"
+		},
+		{
+			id: "zt.policy-denied",
+			from: "ready",
+			to: "ended",
+			on: "local.policy-denied",
+			emits: ["tx.close", "tx.app-fin"],
+			note: "The server side checks each open inbound connection again at a change of a policy, and closes the ones that it now denies",
+			source: "connection_manager.rs:364-376"
+		},
+		{
+			id: "zt.release",
+			from: "ready",
+			to: "ended",
+			on: "timer.release",
+			timer: "release",
+			guard: "no stream is open and no other flow holds the connection",
+			emits: ["tx.close"],
+			source: "pool.rs:142-146"
+		},
+		{
+			id: "zt.stop",
+			from: "ready",
+			to: "draining",
+			on: "app.stop",
+			timer: "deadline",
+			emits: ["tx.goaway"],
+			note: "The accept loops stop, and the HBONE server sends GOAWAY",
+			source: "server.rs:170-172, outbound.rs:121"
+		},
+		{
+			id: "zt.drained",
+			from: "draining",
+			to: "ended",
+			on: "local.stream-end",
+			emits: ["tx.close"],
+			source: "drain.rs:52-70"
+		},
+		{
+			id: "zt.deadline",
+			from: "draining",
+			to: "ended",
+			on: "timer.deadline",
+			timer: "deadline",
+			emits: ["tx.close", "tx.app-fin"],
+			note: "ztunnel ends what is left itself, before the SIGKILL of the kubelet",
+			source: "app.rs:391-399, pool.rs:345-347"
+		},
+		{
+			id: "zt.del-workload",
+			from: [
+				"connecting",
+				"ready",
+				"draining"
+			],
+			to: "ended",
+			on: "local.del-workload",
+			emits: ["tx.close", "tx.app-fin"],
+			note: "The proxy of a deleted pod drains at once, with no deadline",
+			source: "statemanager.rs:170-191, drain.rs:58-70"
+		}
+	],
+	over: {
+		machine: "systems.machine.linux-tcp",
+		states: {
+			connecting: "SYN_SENT",
+			ready: "ESTABLISHED",
+			draining: "ESTABLISHED"
+		},
+		sets: {
+			keepidle: {
+				knob: "keepidle",
+				unit: "s"
+			},
+			keepintvl: {
+				knob: "keepintvl",
+				unit: "s"
+			},
+			keepcnt: {
+				knob: "keepcnt",
+				unit: "count"
+			}
+		},
+		ends: "peer.rst",
+		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
 const AT$1 = "amqplib 2.2.0 lib";
 /**
@@ -17217,9 +17724,10 @@ const MACHINES = byId([
 	TRAEFIK_HTTP2,
 	ISTIO_SIDECAR_OUTBOUND,
 	ISTIO_SIDECAR_INBOUND,
-	PILOT_AGENT
+	PILOT_AGENT,
+	ZTUNNEL_HBONE
 ]);
 //#endregion
-export { AMQPLIB, ATEN_DETECTOR, CADDY_HTTP2, DOCKER_PROXY_LINK, ENVOY_HTTP2, ETCD_SERVER, GO_TRANSPORT, GRPC_GO_SERVER, GRPC_JS, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, ISTIO_SIDECAR_INBOUND, ISTIO_SIDECAR_OUTBOUND, 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, goLateSeconds, goTimerLateness, istioSidecar, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
+export { AMQPLIB, ATEN_DETECTOR, CADDY_HTTP2, DOCKER_PROXY_LINK, ENVOY_HTTP2, ETCD_SERVER, GO_TRANSPORT, GRPC_GO_SERVER, GRPC_JS, HIKARICP_PGJDBC, IOREDIS_SENTINEL, IOREDIS_STATUS, ISTIO_SIDECAR_INBOUND, ISTIO_SIDECAR_OUTBOUND, 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 };
 
 //# sourceMappingURL=index.js.map