@mark1russell7/machines 0.3.18 → 0.3.19

package/README.md

@@ -34,6 +34,7 @@ The algebra reads these documents. It gives the closed form of each timer, the f
 | `NODE_HTTP_SERVER` | `node-http-server` | One connection of the `http.Server` of Node 24.21.0 | server | 8 implemented |
 | `NODE_HTTP_AGENT` | `node-http-agent` | One socket of the `http.Agent` of Node 24.21.0 | driver | 9 implemented |
 | `UNDICI_CLIENT` | `undici-client-h1` | The socket of an HTTP/1.1 `Client` of undici 8.12.2 | driver | 8 implemented |
+| `UNDICI_RETRY` | `undici-retry-agent` | One request through a `RetryAgent` of undici 8.12.2 | driver | 7 implemented, 1 normative |
 | `GO_TRANSPORT` | `go-nethttp-transport` | One connection of the `http.Transport` of Go 1.27.2 | driver | 7 implemented |
 | `PROCEDURES_WS_CLIENT` | `procedures-ws-client` | The WebSocket client of `@procedures/client` 0.3.0 | driver | 9 implemented, 1 documented |
 | `PROCEDURES_WS_SERVER` | `procedures-ws-server` | The WebSocket server of `@procedures/client` 0.3.0 | server | 4 implemented |
@@ -60,7 +61,7 @@ The algebra reads these documents. It gives the closed form of each timer, the f
 | `DOCKER_PROXY_LINK` | `docker-proxy-link` | docker-proxy of Docker Engine 29.1.5: one proxied TCP connection and its close | proxy | 9 implemented |
 | `CADDY_HTTP2` | `caddy-http2` | Caddy 2.11.7 as an HTTP/2 proxy of gRPC: one connection of a client, its idle close, its replies and its stop | proxy | 12 implemented |
 
-Twenty-eight documents operate on Linux TCP (`over`). Linux TCP, conntrack, the Sentinel, the replication of mongod, aten and the member of Ra operate on no other document. The `conditions` of each document give the range where it holds, for example a range of kernels.
+Twenty-eight documents operate on Linux TCP (`over`). Seven documents operate on no other document: Linux TCP, conntrack, the Sentinel, the replication of mongod, aten, the member of Ra and the `RetryAgent` of undici. 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.
 
 The package also gives these parts:
 

package/build/index.d.ts

@@ -95,6 +95,29 @@ export declare const NODE_HTTP_SERVER: Machine;
  */
 export declare const UNDICI_CLIENT: Machine;
 //#endregion
+//#region src/http/undici-retry.d.ts
+/**
+ * This document is one request through a `RetryAgent` of undici 8.12.2: the retries of a reply
+ * whose status is retryable, for example 429 or 503. Each fact comes from the published package at
+ * 8.12.2, with the file and the line. The defaults are 5 retries, a backoff from 500 ms with a factor
+ * of 2, a cap of 30 s, and Retry-After read.
+ *
+ * - The delay of a retry is the Retry-After of the reply, capped by `maxTimeout`. A Retry-After
+ *   longer than the cap does not stop the retries: the retry comes early. A reply without
+ *   Retry-After gets the backoff, with no jitter.
+ * - The agent gives up after `maxRetries` retries. The caller then gets `RequestRetryError`, with
+ *   the status of the last reply. Thus the retry window of the caller is the sum of the delays.
+ * - A POST and a PATCH are not retried.
+ * - The delay is a native Node timer. It arms after the parse of the whole reply, thus it comes after
+ *   the last segment by the handling time of the program. No source bounds that time, and this
+ *   document does not hold it. The cells add it from a calibration (`HANDLING` in
+ *   `packages/cells/src/http/race.ts`).
+ *
+ * The plain `Client` and `fetch` of undici, and the `fetch` of Node 24.21.0 (undici 7.29.1), send no
+ * request again for a status. Their retry window is 0.
+ */
+export declare const UNDICI_RETRY: Machine;
+//#endregion
 //#region src/ioredis-sentinel.d.ts
 /**
  * This document is the Sentinel path of ioredis 6.0.0. It tells how ioredis finds the primary of a

package/build/index.js

@@ -1,49 +1,49 @@
 import { machineSchema } from "@mark1russell7/algebra";
 import { z } from "zod";
 //#region src/grpc/grpc-go-server.ts
-const AT$11 = "grpc-go v1.84.0";
+const AT$12 = "grpc-go v1.84.0";
 const GO = "go1.27.2 src/net";
 const ETCD = "etcd v3.6.15";
 /** These are the facts of the transport of grpc-go, for each server on it. */
 const TRANSPORT = [
 	{
-		ref: `${AT$11} internal/transport/defaults.go:31-40 the server keepalive: Time 2 h, Timeout 20 s. MinTime of the policy 5 min. MaxConnectionIdle, Age and AgeGrace infinite`,
+		ref: `${AT$12} internal/transport/defaults.go:31-40 the server keepalive: Time 2 h, Timeout 20 s. MinTime of the policy 5 min. MaxConnectionIdle, Age and AgeGrace infinite`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:226-253 the defaults of the parameters, a jitter of 10 % on MaxConnectionAge, and TCP_USER_TIMEOUT = Timeout when Time is not infinite`,
+		ref: `${AT$12} internal/transport/http2_server.go:226-253 the defaults of the parameters, a jitter of 10 % on MaxConnectionAge, and TCP_USER_TIMEOUT = Timeout when Time is not infinite`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/syscall/syscall_linux.go:71-90 SetTCPUserTimeout acts only on a *net.TCPConn. On any other net.Conn it does nothing`,
+		ref: `${AT$12} internal/syscall/syscall_linux.go:71-90 SetTCPUserTimeout acts only on a *net.TCPConn. On any other net.Conn it does nothing`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:1197-1286 keepalive(): a PING after Time with no read, and Close when no read comes for Timeout after it. MaxConnectionIdle and MaxConnectionAge drain with GOAWAY, and AgeGrace closes`,
+		ref: `${AT$12} internal/transport/http2_server.go:1197-1286 keepalive(): a PING after Time with no read, and Close when no read comes for Timeout after it. MaxConnectionIdle and MaxConnectionAge drain with GOAWAY, and AgeGrace closes`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:881-933 handlePing: a PING less than MinTime after the last one is a strike, and with no stream open and PermitWithoutStream false, less than 2 h. The third strike sends GOAWAY ENHANCE_YOUR_CALM too_many_pings and closes the connection`,
+		ref: `${AT$12} internal/transport/http2_server.go:881-933 handlePing: a PING less than MinTime after the last one is a strike, and with no stream open and PermitWithoutStream false, less than 2 h. The third strike sends GOAWAY ENHANCE_YOUR_CALM too_many_pings and closes the connection`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:279-281, :1064, :1132, :1176 each write of headers, a status or data by the server clears the strikes`,
+		ref: `${AT$12} internal/transport/http2_server.go:279-281, :1064, :1132, :1176 each write of headers, a status or data by the server clears the strikes`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:1291-1310 Close closes the net.Conn: a FIN, or a reset when bytes are unread`,
+		ref: `${AT$12} internal/transport/http2_server.go:1291-1310 Close closes the net.Conn: a FIN, or a reset when bytes are unread`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} internal/transport/http2_server.go:536-537, :603-615 a call with the header grpc-timeout gets a timer of that timeout from the read of its headers. Its end closes the stream with RST_STREAM CANCEL, and the context of the handler ends`,
+		ref: `${AT$12} internal/transport/http2_server.go:536-537, :603-615 a call with the header grpc-timeout gets a timer of that timeout from the read of its headers. Its end closes the stream with RST_STREAM CANCEL, and the context of the handler ends`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} server.go:192, :1000-1009 a deadline of 120 s for the handshake of each new connection (ConnectionTimeout)`,
+		ref: `${AT$12} server.go:192, :1000-1009 a deadline of 120 s for the handshake of each new connection (ConnectionTimeout)`,
 		rung: "implemented"
 	},
 	{
-		ref: `${AT$11} server.go:894-905 the comment of grpc-go: Go sets a TCP keepalive of 15 s on each accepted connection`,
+		ref: `${AT$12} server.go:894-905 the comment of grpc-go: Go sets a TCP keepalive of 15 s on each accepted connection`,
 		rung: "documented"
 	},
 	{
@@ -702,7 +702,7 @@ const ETCD_SERVER = serverOf({
 });
 //#endregion
 //#region src/grpc/grpc-js.ts
-const AT$10 = "@grpc/grpc-js 1.14.6 src";
+const AT$11 = "@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
 * (one HTTP/2 session on one TCP connection) and one unary call on it. It gives the states of the
@@ -732,83 +732,83 @@ const GRPC_JS = machineSchema.parse({
 	},
 	sources: [
 		{
-			ref: `${AT$10}/transport.ts:70 KEEPALIVE_TIMEOUT_MS is 20000`,
+			ref: `${AT$11}/transport.ts:70 KEEPALIVE_TIMEOUT_MS is 20000`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:183-198 grpc.keepalive_time_ms is -1 when the caller gives none, grpc.keepalive_timeout_ms is 20000, and grpc.keepalive_permit_without_calls is false`,
+			ref: `${AT$11}/transport.ts:183-198 grpc.keepalive_time_ms is -1 when the caller gives none, grpc.keepalive_timeout_ms is 20000, and grpc.keepalive_permit_without_calls is false`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:447-453 a PING goes out only with a keepalive time above 0, and with a call in flight or permit_without_calls`,
+			ref: `${AT$11}/transport.ts:447-453 a PING goes out only with a keepalive time above 0, and with a call in flight or permit_without_calls`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:455-507 each PING starts a timer of keepalive_timeout_ms, and its end with no ACK ends the transport (handleDisconnect). A failed send of the PING ends it too`,
+			ref: `${AT$11}/transport.ts:455-507 each PING starts a timer of keepalive_timeout_ms, and its end with no ACK ends the transport (handleDisconnect). A failed send of the PING ends it too`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:515-534 and :553-561 the keepalive timer starts with the first call in flight, and after each ACK. It is not reset by data. When it ends with no call in flight, the PING goes out at the start of the next call`,
+			ref: `${AT$11}/transport.ts:515-534 and :553-561 the keepalive timer starts with the first call in flight, and after each ACK. It is not reset by data. When it ends with no call in flight, the PING goes out at the start of the next call`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:200-242 a close or an error of the session, or a close of its socket, ends the transport. A GOAWAY makes it unusable (reportDisconnectToOwner)`,
+			ref: `${AT$11}/transport.ts:200-242 a close or an error of the session, or a close of its socket, ends the transport. A GOAWAY makes it unusable (reportDisconnectToOwner)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:205-227 a GOAWAY ENHANCE_YOUR_CALM with the data too_many_pings tells the subchannel that the server refused the pings`,
+			ref: `${AT$11}/transport.ts:205-227 a GOAWAY ENHANCE_YOUR_CALM with the data too_many_pings tells the subchannel that the server refused the pings`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:431-441 handleDisconnect: each call in flight gets onDisconnect, and the session is destroyed in the next turn of the event loop`,
+			ref: `${AT$11}/transport.ts:431-441 handleDisconnect: each call in flight gets onDisconnect, and the session is destroyed in the next turn of the event loop`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:684-687 shutdown closes the session: a GOAWAY, then the end of the socket after the last stream`,
+			ref: `${AT$11}/transport.ts:684-687 shutdown closes the session: a GOAWAY, then the end of the socket after the last stream`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:792-810 the transport is ready at the first SETTINGS of the server (remoteSettings)`,
+			ref: `${AT$11}/transport.ts:792-810 the transport is ready at the first SETTINGS of the server (remoteSettings)`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:818-840 the TCP connect is net.connect with no timeout`,
+			ref: `${AT$11}/transport.ts:818-840 the TCP connect is net.connect with no timeout`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/transport.ts:862 setNoDelay on each connection: TCP_NODELAY, thus no Nagle. No setKeepAlive anywhere in the package`,
+			ref: `${AT$11}/transport.ts:862 setNoDelay on each connection: TCP_NODELAY, thus no Nagle. No setKeepAlive anywhere in the package`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/subchannel-call.ts:360-371 onDisconnect ends the call with UNAVAILABLE 'Connection dropped' in the next turn of the event loop, unless the stream ends first`,
+			ref: `${AT$11}/subchannel-call.ts:360-371 onDisconnect ends the call with UNAVAILABLE 'Connection dropped' in the next turn of the event loop, unless the stream ends first`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/subchannel-call.ts:230-329 the end of a stream with no status: REFUSED_STREAM is UNAVAILABLE, CANCEL after a dropped connection is UNAVAILABLE, and an internal error of ECONNRESET or ETIMEDOUT is UNAVAILABLE`,
+			ref: `${AT$11}/subchannel-call.ts:230-329 the end of a stream with no status: REFUSED_STREAM is UNAVAILABLE, CANCEL after a dropped connection is UNAVAILABLE, and an internal error of ECONNRESET or ETIMEDOUT is UNAVAILABLE`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/load-balancing-call.ts:257-261 a stream that the server refused has the progress REFUSED, and any other started stream PROCESSED`,
+			ref: `${AT$11}/load-balancing-call.ts:257-261 a stream that the server refused has the progress REFUSED, and any other started stream PROCESSED`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/retrying-call.ts:631-652 a transparent retry for NOT_STARTED, and one for REFUSED. A PROCESSED call is retried only by a retry policy of the service config, which the defaults do not have`,
+			ref: `${AT$11}/retrying-call.ts:631-652 a transparent retry for NOT_STARTED, and one for REFUSED. A PROCESSED call is retried only by a retry policy of the service config, which the defaults do not have`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/load-balancing-call.ts:338-345 a pick in TRANSIENT_FAILURE fails the call at once, unless it asks for waitForReady`,
+			ref: `${AT$11}/load-balancing-call.ts:338-345 a pick in TRANSIENT_FAILURE fails the call at once, unless it asks for waitForReady`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/resolving-call.ts:118-180 the deadline of a call is a timer from the start of the call. Its end cancels the call with DEADLINE_EXCEEDED`,
+			ref: `${AT$11}/resolving-call.ts:118-180 the deadline of a call is a timer from the start of the call. Its end cancels the call with DEADLINE_EXCEEDED`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/deadline.ts:39-52 the header grpc-timeout is the time left to the deadline when the call sends its headers, rounded up to whole milliseconds. A server can start a timer of it`,
+			ref: `${AT$11}/deadline.ts:39-52 the header grpc-timeout is the time left to the deadline when the call sends its headers, rounded up to whole milliseconds. A server can start a timer of it`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/subchannel-call.ts:269-279 a RST_STREAM CANCEL of the server ends the call with CANCELLED 'Call cancelled'`,
+			ref: `${AT$11}/subchannel-call.ts:269-279 a RST_STREAM CANCEL of the server ends the call with CANCELLED 'Call cancelled'`,
 			rung: "implemented"
 		},
 		{
@@ -816,19 +816,19 @@ const GRPC_JS = machineSchema.parse({
 			rung: "observed"
 		},
 		{
-			ref: `${AT$10}/subchannel.ts:275-291 the end of the transport takes the subchannel from READY to IDLE. After too_many_pings the keepalive time doubles`,
+			ref: `${AT$11}/subchannel.ts:275-291 the end of the transport takes the subchannel from READY to IDLE. After too_many_pings the keepalive time doubles`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/subchannel.ts:298-304 a failed connect takes the subchannel to TRANSIENT_FAILURE`,
+			ref: `${AT$11}/subchannel.ts:298-304 a failed connect takes the subchannel to TRANSIENT_FAILURE`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/backoff-timeout.ts:23-26 the reconnect waits 1000 ms first, each next wait 1.6 times longer, up to 120000 ms, with a jitter of 0.2`,
+			ref: `${AT$11}/backoff-timeout.ts:23-26 the reconnect waits 1000 ms first, each next wait 1.6 times longer, up to 120000 ms, with a jitter of 0.2`,
 			rung: "implemented"
 		},
 		{
-			ref: `${AT$10}/internal-channel.ts:74-77 and :324-325 a channel with no call for grpc.client_idle_timeout_ms goes IDLE: 30 min at the defaults, 1 s at least`,
+			ref: `${AT$11}/internal-channel.ts:74-77 and :324-325 a channel with no call for grpc.client_idle_timeout_ms goes IDLE: 30 min at the defaults, 1 s at least`,
 			rung: "implemented"
 		},
 		{
@@ -2581,6 +2581,222 @@ const UNDICI_CLIENT = machineSchema.parse({
 	}
 });
 //#endregion
+//#region src/http/undici-retry.ts
+const AT$10 = "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
+* whose status is retryable, for example 429 or 503. Each fact comes from the published package at
+* 8.12.2, with the file and the line. The defaults are 5 retries, a backoff from 500 ms with a factor
+* of 2, a cap of 30 s, and Retry-After read.
+*
+* - The delay of a retry is the Retry-After of the reply, capped by `maxTimeout`. A Retry-After
+*   longer than the cap does not stop the retries: the retry comes early. A reply without
+*   Retry-After gets the backoff, with no jitter.
+* - The agent gives up after `maxRetries` retries. The caller then gets `RequestRetryError`, with
+*   the status of the last reply. Thus the retry window of the caller is the sum of the delays.
+* - A POST and a PATCH are not retried.
+* - The delay is a native Node timer. It arms after the parse of the whole reply, thus it comes after
+*   the last segment by the handling time of the program. No source bounds that time, and this
+*   document does not hold it. The cells add it from a calibration (`HANDLING` in
+*   `packages/cells/src/http/race.ts`).
+*
+* The plain `Client` and `fetch` of undici, and the `fetch` of Node 24.21.0 (undici 7.29.1), send no
+* request again for a status. Their retry window is 0.
+*/
+const UNDICI_RETRY = machineSchema.parse({
+	format: "mark1russell7.machine/1",
+	id: "undici-retry-agent",
+	title: "One request through a RetryAgent of undici 8.12.2",
+	layer: "driver",
+	version: "8.12.2",
+	conditions: {
+		undici: "8.12.2",
+		node: "24.21.0",
+		throwOnError: "true"
+	},
+	sources: [
+		{
+			ref: `${AT$10}:125-133 the defaults: retryAfter true, maxTimeout 30000, minTimeout 500, timeoutFactor 2, maxRetries 5, the methods GET HEAD OPTIONS PUT DELETE TRACE QUERY, the statusCodes 500 502 503 504 429`,
+			rung: "implemented"
+		},
+		{
+			ref: "undici 8.12.2 lib/dispatcher/retry-agent.js:18-27: a RetryAgent wraps a dispatcher with a RetryHandler",
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$10}:331-351 the policy: a method or a status out of its lists is not retried, and a counter above maxRetries gives up`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$10}:353-370 the delay: Retry-After in seconds times 1000, or an HTTP-date less the clock of the client (:13-16), capped by maxTimeout; 0 at once; else min(minTimeout * timeoutFactor^(counter - 1), maxTimeout); then setTimeout`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$10}:380 the counter: one more at each reply`,
+			rung: "implemented"
+		},
+		{
+			ref: `${AT$10}:175-192 and :518-535 a retryable status with throwOnError drops the body of the reply, and the error goes to the policy`,
+			rung: "implemented"
+		},
+		{
+			ref: "undici 8.12.2 lib/core/errors.js:362-371 RequestRetryError: code UND_ERR_REQ_RETRY, statusCode, headers, data.count",
+			rung: "implemented"
+		},
+		{
+			ref: "RFC 9110 §10.2.3: Retry-After, as delay-seconds or an HTTP-date",
+			rung: "normative"
+		}
+	],
+	states: {
+		IDLE: {
+			initial: true,
+			pseudo: true
+		},
+		SENT: { note: "a send of the request waits for its reply" },
+		WAITING: { note: "the delay of a retry: the Retry-After of the reply, or the backoff" },
+		DONE: {
+			final: true,
+			note: "a reply whose status is not retryable goes to the caller"
+		},
+		FAILED: {
+			final: true,
+			note: "RequestRetryError (UND_ERR_REQ_RETRY), with the status of the last reply"
+		}
+	},
+	events: {
+		"req.dispatch": { kind: "app" },
+		"rx.retryable": {
+			kind: "rx",
+			note: "a reply with a status of statusCodes, for example 429 with Retry-After"
+		},
+		"rx.final": {
+			kind: "rx",
+			note: "a reply with another status, for example 200"
+		},
+		"timer.retry": { kind: "timer" }
+	},
+	knobs: {
+		maxRetries: {
+			key: "undici RetryAgent maxRetries",
+			scope: "client",
+			unit: "count",
+			default: 5
+		},
+		minTimeout: {
+			key: "undici RetryAgent minTimeout",
+			scope: "client",
+			unit: "ms",
+			default: 500
+		},
+		maxTimeout: {
+			key: "undici RetryAgent maxTimeout",
+			scope: "client",
+			unit: "ms",
+			default: 3e4
+		},
+		timeoutFactor: {
+			key: "undici RetryAgent timeoutFactor",
+			scope: "client",
+			unit: "count",
+			default: 2
+		},
+		retry_after: {
+			key: "Retry-After of the reply, in seconds",
+			scope: "reply",
+			unit: "s",
+			default: null,
+			note: "the server gives it. An HTTP-date counts on the clock of the client"
+		},
+		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 (timers.ts)"
+		}
+	},
+	timers: {
+		retry_after: {
+			duration: {
+				expr: "min(retry_after * 1000, maxTimeout)",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("min(retry_after * 1000, maxTimeout)"),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:WAITING"],
+			cancels: ["req.dispatch"],
+			fires: "timer.retry",
+			note: "setTimeout(cb, retryTimeout) with the Retry-After of the reply. It arms after the parse of the whole reply"
+		},
+		backoff: {
+			duration: {
+				expr: "min(minTimeout * pow(timeoutFactor, fired), maxTimeout)",
+				unit: "ms"
+			},
+			lateness: nodeTimerLateness("min(minTimeout * pow(timeoutFactor, fired), maxTimeout)"),
+			early: NODE_TIMER_EARLY,
+			arms: ["enter:WAITING"],
+			cancels: ["req.dispatch"],
+			fires: "timer.retry",
+			backoff: { resets: ["req.dispatch"] },
+			note: "a reply without Retry-After: 0.5, 1, 2, 4 and 8 s at the defaults, with no jitter"
+		}
+	},
+	transitions: [
+		{
+			id: "ur.send",
+			from: "IDLE",
+			to: "SENT",
+			on: "req.dispatch"
+		},
+		{
+			id: "ur.wait",
+			from: "SENT",
+			to: "WAITING",
+			on: "rx.retryable",
+			guard: "the count of replies is maxRetries or less, the method is in its list, and no part of the body went to the caller",
+			source: "retry-handler.js:331-351, :380, :581-584"
+		},
+		{
+			id: "ur.give-up",
+			from: "SENT",
+			to: "FAILED",
+			on: "rx.retryable",
+			guard: "the count of replies is above maxRetries, or the method is not in its list (POST, PATCH)",
+			errno: "UND_ERR_REQ_RETRY",
+			source: "retry-handler.js:331-335, :347-350, :430-436"
+		},
+		{
+			id: "ur.retry-after",
+			from: "WAITING",
+			to: "SENT",
+			on: "timer.retry",
+			timer: "retry_after",
+			guard: "the reply had a Retry-After of 0 or more",
+			emits: ["tx.request"],
+			source: "retry-handler.js:353-365, :370"
+		},
+		{
+			id: "ur.backoff",
+			from: "WAITING",
+			to: "SENT",
+			on: "timer.retry",
+			timer: "backoff",
+			guard: "the reply had no Retry-After, or one in the past, or one that does not parse",
+			emits: ["tx.request"],
+			source: "retry-handler.js:361-370"
+		},
+		{
+			id: "ur.done",
+			from: "SENT",
+			to: "DONE",
+			on: "rx.final",
+			source: "retry-handler.js:373-383"
+		}
+	]
+});
+//#endregion
 //#region src/ioredis-sentinel.ts
 const AT$9 = "ioredis 6.0.0 built";
 /**
@@ -15492,6 +15708,7 @@ const MACHINES = byId([
 	NODE_HTTP_SERVER,
 	NODE_HTTP_AGENT,
 	UNDICI_CLIENT,
+	UNDICI_RETRY,
 	GO_TRANSPORT,
 	PROCEDURES_WS_CLIENT,
 	PROCEDURES_WS_SERVER,
@@ -15519,6 +15736,6 @@ const MACHINES = byId([
 	CADDY_HTTP2
 ]);
 //#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, 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, TOXIPROXY_LINK, UNDICI_CLIENT, UNDICI_TICK_MS, goLateSeconds, goTimerLateness, 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, 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, TOXIPROXY_LINK, UNDICI_CLIENT, UNDICI_RETRY, UNDICI_TICK_MS, goLateSeconds, goTimerLateness, nodeEarlySeconds, nodeLateSeconds, nodeTimerLateness, undiciFastEarly, undiciFastLateness };
 
 //# sourceMappingURL=index.js.map