@noodleseed/one 0.22.0 → 0.23.0

package/node_modules/undici/docs/docs/api/RetryHandler.md

@@ -1,116 +1,200 @@
-# Class: RetryHandler
+# RetryHandler
 
-Extends: `undici.DispatcherHandlers`
+<!--introduced_in=v5.28.0-->
+<!--type=module-->
+<!-- source_link=lib/handler/retry-handler.js -->
 
-A handler class that implements the retry logic for a request.
+> Stability: 2 - Stable
 
-## `new RetryHandler(opts, { dispatch, handler })`
+A [`Dispatcher`][] handler that automatically retries a request when it fails
+with a recoverable network error or an eligible HTTP status code. It wraps an
+inner handler and re-dispatches the request, applying an exponential backoff and
+honouring the `Retry-After` response header. When a response is partially
+consumed before the failure, the handler resumes the download with a `Range`
+request guarded by the original `ETag`.
 
-Arguments:
+The handler is most often used indirectly through [`RetryAgent`][], but it can
+also be supplied directly to [`dispatcher.dispatch()`][] for fine-grained
+control over the retry behaviour.
 
-- **opts** `Dispatch.DispatchOptions & { retryOptions?: RetryOptions }` (required) - An intersection of `Dispatcher.DispatchOptions` and an optional `RetryOptions` object.
-- **{ dispatch, handler }** `RetryHandlers` (required) - Object containing the `dispatch` to be used on every retry, and `handler` for handling the `dispatch` lifecycle.
-
-Returns: `retryHandler`
-
-### Parameter: `Dispatch.DispatchOptions & RetryOptions`
-
-Extends: [`Dispatch.DispatchOptions`](/docs/docs/api/Dispatcher.md#parameter-dispatchoptions).
-
-#### `RetryOptions`
+```mjs
+import { RetryHandler } from 'undici'
+```
 
-- **throwOnError** `boolean` (optional) - Disable to prevent throwing error on last retry attept, useful if you need the body on errors from server or if you have custom error handler.
-- **retry** `(err: Error, context: RetryContext, callback: (err?: Error | null) => void) => void` (optional) - Function to be called after every retry. It should pass error if no more retries should be performed.
-- **maxRetries** `number` (optional) - Maximum number of retries. Default: `5`
-- **maxTimeout** `number` (optional) - Maximum number of milliseconds to wait before retrying. Default: `30000` (30 seconds)
-- **minTimeout** `number` (optional) - Minimum number of milliseconds to wait before retrying. Default: `500` (half a second)
-- **timeoutFactor** `number` (optional) - Factor to multiply the timeout by for each retry attempt. Default: `2`
-- **retryAfter** `boolean` (optional) - It enables automatic retry after the `Retry-After` header is received. Default: `true`
-- **methods** `string[]` (optional) - Array of HTTP methods to retry. Default: `['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE']`
-- **statusCodes** `number[]` (optional) - Array of HTTP status codes to retry. Default: `[429, 500, 502, 503, 504]`
-- **errorCodes** `string[]` (optional) - Array of Error codes to retry. Default: `['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ENETDOWN', 'ENETUNREACH', 'EHOSTDOWN', 'EHOSTUNREACH', 'EPIPE', 'UND_ERR_SOCKET']`
+## Class: `RetryHandler`
 
-**`RetryContext`**
+<!-- YAML
+added: v5.28.0
+-->
 
-- `state`: `RetryState` - Current retry state. It can be mutated.
-- `opts`: `Dispatch.DispatchOptions & RetryOptions` - Options passed to the retry handler.
+* Extends: {DispatchHandler}
 
-**`RetryState`**
+Implements the [`DispatchHandler`][] interface. An instance is consumed by a
+single dispatch call and forwards the dispatch lifecycle to the inner `handler`,
+re-issuing the request through the supplied `dispatch` function whenever a retry
+is warranted.
 
-It represents the retry state for a given request.
+> **Note:** The `RetryHandler` does not retry over stateful bodies (for example
+> streams or `AsyncIterable`), because once consumed they cannot be replayed. In
+> these situations the body is identified as stateful and the request is rejected
+> with the `UND_ERR_REQ_RETRY` error instead of being retried.
 
-- `counter`: `number` - Current retry attempt.
+### `new RetryHandler(options, retryHandlers)`
 
-### Parameter `RetryHandlers`
+<!-- YAML
+added: v5.28.0
+changes:
+  - version: v7.0.0
+    pr-url: https://github.com/nodejs/undici/pull/3883
+    description: Reimplemented on top of the new dispatch lifecycle hooks.
+-->
 
-- **dispatch** `(options: Dispatch.DispatchOptions, handlers: Dispatch.DispatchHandler) => Promise<Dispatch.DispatchResponse>` (required) - Dispatch function to be called after every retry.
-- **handler** Extends [`Dispatch.DispatchHandler`](/docs/docs/api/Dispatcher.md#dispatcherdispatchoptions-handler) (required) - Handler function to be called after the request is successful or the retries are exhausted.
+* `options` {DispatchOptions} The dispatch options for the request, extended with
+  an optional `retryOptions` field. Type is
+  `DispatchOptions & { retryOptions?: RetryOptions }`.
+  * `retryOptions` {RetryOptions} (optional) Configuration controlling when and
+    how the request is retried. See [`RetryOptions`](#retryoptions).
+* `retryHandlers` {RetryHandlers} The handlers used to drive the retry loop. See
+  [`RetryHandlers`](#parameter-retryhandlers).
+* Returns: {RetryHandler}
 
->__Note__: The `RetryHandler` does not retry over stateful bodies (e.g. streams, AsyncIterable) as those, once consumed, are left in a state that cannot be reutilized. For these situations the `RetryHandler` will identify
->the body as stateful and will not retry the request rejecting with the error `UND_ERR_REQ_RETRY`.
+#### `RetryOptions`
 
-Examples:
+* `throwOnError` {boolean} When `true`, an error is thrown on the last retry
+  attempt and propagated to the inner handler; when `false`, the failing response
+  is passed through instead, which is useful when the error body is needed or a
+  custom error handler is in place. **Default:** `true`.
+* `retry` {Function} Callback invoked on every retry iteration to decide whether
+  another attempt should be made. It receives the error, the retry context, and a
+  callback. Call the callback with an `Error` to stop retrying, or with `null` to
+  schedule another attempt. **Default:** the built-in retry strategy described
+  below.
+  * `err` {Error} The error that triggered the retry.
+  * `context` {RetryContext} The current retry context. See
+    [`RetryContext`](#retrycontext).
+  * `callback` {Function} Signals the outcome of this iteration.
+    * `result` {Error|null} (optional) An `Error` to abort retrying, or `null` to
+      retry.
+* `maxRetries` {number} Maximum number of retries allowed. **Default:** `5`.
+* `maxTimeout` {number} Maximum number of milliseconds to wait between retries.
+  **Default:** `30000` (30 seconds).
+* `minTimeout` {number} Initial number of milliseconds to wait before the first
+  retry. **Default:** `500` (half a second).
+* `timeoutFactor` {number} Multiplier applied to the timeout between successive
+  retries to produce an exponential backoff. **Default:** `2`.
+* `retryAfter` {boolean} When `true`, the delay before the next retry is inferred
+  from the `Retry-After` response header when present. **Default:** `true`.
+* `methods` {string[]} HTTP methods that are eligible for retrying. **Default:**
+  `['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE']`.
+* `statusCodes` {number[]} HTTP status codes that trigger a retry. **Default:**
+  `[500, 502, 503, 504, 429]`.
+* `errorCodes` {string[]} Network error codes that trigger a retry. **Default:**
+  `['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ENETDOWN', 'ENETUNREACH', 'EHOSTDOWN', 'EHOSTUNREACH', 'EPIPE', 'UND_ERR_SOCKET']`.
+
+The default `retry` strategy computes the delay before the next attempt as
+`minTimeout * timeoutFactor ** (counter - 1)`, capped at `maxTimeout`. When a
+`Retry-After` header is present it takes precedence (interpreted as seconds, or as
+an HTTP date), still capped at `maxTimeout`. The default strategy stops retrying
+once `counter` exceeds `maxRetries`, when the error code is not in `errorCodes`,
+when the method is not in `methods`, or when the response status code is not in
+`statusCodes`.
+
+#### `RetryContext`
+
+* `state` {RetryState} The current retry state. See [`RetryState`](#retrystate).
+* `opts` {DispatchOptions} The dispatch options passed to the handler, including
+  the resolved `retryOptions`. Type is
+  `DispatchOptions & { retryOptions?: RetryOptions }`.
+
+The context object passed as the second argument to the `retry` callback.
+
+#### `RetryState`
+
+* `counter` {number} The current retry attempt, starting at `1` for the first
+  retry.
+
+Represents the retry state for a given request.
+
+#### Parameter: `RetryHandlers`
+
+* `dispatch` {Function} The dispatch function called to (re-)issue the request on
+  every attempt. Type is `(options, handler) => boolean`.
+* `handler` {DispatchHandler} The inner handler invoked once the request succeeds
+  or the retries are exhausted.
+
+### Examples
+
+```mjs
+import { Client, RetryHandler } from 'undici'
+
+const client = new Client(`http://localhost:${server.address().port}`)
+const chunks = []
 
-```js
-const client = new Client(`http://localhost:${server.address().port}`);
-const chunks = [];
 const handler = new RetryHandler(
   {
     ...dispatchOptions,
     retryOptions: {
-      // custom retry function
-      retry: function (err, state, callback) {
-        counter++;
-
-        if (err.code && err.code === "UND_ERR_DESTROYED") {
-          callback(err);
-          return;
+      // Custom retry decision function.
+      retry (err, { state, opts }, callback) {
+        if (err.code === 'UND_ERR_DESTROYED') {
+          callback(err)
+          return
         }
 
         if (err.statusCode === 206) {
-          callback(err);
-          return;
+          callback(err)
+          return
         }
 
-        setTimeout(() => callback(null), 1000);
-      },
-    },
+        setTimeout(() => callback(null), 1000)
+      }
+    }
   },
   {
-    dispatch: (...args) => {
-      return client.dispatch(...args);
+    dispatch (...args) {
+      return client.dispatch(...args)
     },
     handler: {
-      onRequestStart() {},
-      onBodySent(chunk) {},
-      onResponseStart(_controller, status, headers) {
-        // do something with headers
+      onRequestStart () {},
+      onResponseStart (controller, status, headers) {
+        // Do something with the response headers.
       },
-      onResponseData(_controller, chunk) {
-        chunks.push(chunk);
+      onResponseData (controller, chunk) {
+        chunks.push(chunk)
       },
-      onResponseEnd() {},
-      onResponseError(_controller, err) {
-        // handle error properly
-      },
-    },
+      onResponseEnd () {},
+      onResponseError (controller, err) {
+        // Handle the error.
+      }
+    }
   }
-);
+)
+
+client.dispatch(dispatchOptions, handler)
 ```
 
-#### Example - Basic RetryHandler with defaults
+A minimal handler that relies entirely on the default retry options:
+
+```mjs
+import { Client, RetryHandler } from 'undici'
+
+const client = new Client(`http://localhost:${server.address().port}`)
 
-```js
-const client = new Client(`http://localhost:${server.address().port}`);
 const handler = new RetryHandler(dispatchOptions, {
   dispatch: client.dispatch.bind(client),
   handler: {
-    onRequestStart() {},
-    onBodySent(chunk) {},
-    onResponseStart(_controller, status, headers) {},
-    onResponseData(_controller, chunk) {},
-    onResponseEnd() {},
-    onResponseError(_controller, err) {},
-  },
-});
+    onRequestStart () {},
+    onResponseStart (controller, status, headers) {},
+    onResponseData (controller, chunk) {},
+    onResponseEnd () {},
+    onResponseError (controller, err) {}
+  }
+})
+
+client.dispatch(dispatchOptions, handler)
 ```
+
+[`Dispatcher`]: Dispatcher.md#class-dispatcher
+[`DispatchHandler`]: Dispatcher.md#parameter-dispatchhandler
+[`RetryAgent`]: RetryAgent.md#class-retryagent
+[`dispatcher.dispatch()`]: Dispatcher.md#dispatcherdispatchoptions-handler

package/node_modules/undici/docs/docs/api/RoundRobinPool.md

@@ -1,131 +1,213 @@
-# Class: RoundRobinPool
+# RoundRobinPool
 
-Extends: `undici.Dispatcher`
+<!--introduced_in=v7.17.0-->
+<!--type=module-->
+<!-- source_link=lib/dispatcher/round-robin-pool.js -->
 
-A pool of [Client](/docs/docs/api/Client.md) instances connected to the same upstream target with round-robin client selection.
+> Stability: 2 - Stable
 
-Unlike [`Pool`](/docs/docs/api/Pool.md), which always selects the first available client, `RoundRobinPool` cycles through clients in a round-robin fashion. This ensures even distribution of requests across all connections, which is particularly useful when the upstream target is behind a load balancer that round-robins TCP connections across multiple backend servers (e.g., Kubernetes Services).
+A pool of [`Client`][] instances connected to the same upstream target that
+selects clients in a round-robin fashion.
 
-Requests are not guaranteed to be dispatched in order of invocation.
+Unlike [`Pool`][], which always reuses the first available client,
+`RoundRobinPool` cycles through its clients so that requests are distributed
+evenly across every open connection. This is useful when the upstream target is
+fronted by a load balancer that distributes TCP connections across multiple
+backend servers (for example, a Kubernetes Service): each connection is pinned
+to a backend by the load balancer, and `RoundRobinPool` spreads requests across
+those connections so every backend receives a comparable share of traffic.
 
-## `new RoundRobinPool(url[, options])`
+Requests are not guaranteed to be dispatched in the order they were invoked.
 
-Arguments:
+```mjs
+import { RoundRobinPool } from 'undici'
+
+const pool = new RoundRobinPool('http://localhost:3000', { connections: 10 })
+```
+
+`RoundRobinPool` distributes HTTP requests evenly across TCP connections, not
+across backend servers directly. Even backend distribution therefore depends on
+the load balancer assigning different connections to different backends (for
+example, round-robin, random, or least-connections without client affinity). If
+the load balancer pins all connections from one source to the same backend (for
+example, source-IP affinity or sticky sessions), consider [`BalancedPool`][]
+with the individual backend addresses instead.
+
+## Class: `RoundRobinPool`
+
+<!-- YAML
+added: v7.17.0
+-->
+
+* Extends: {Dispatcher}
+
+### `new RoundRobinPool(url[, options])`
 
-* **url** `URL | string` - It should only include the **protocol, hostname, and port**.
-* **options** `RoundRobinPoolOptions` (optional)
+<!-- YAML
+added: v7.17.0
+-->
 
-### Parameter: `RoundRobinPoolOptions`
+* `url` {URL|string} The upstream target. It should only include the
+  **protocol, hostname, and port**.
+* `options` {RoundRobinPoolOptions} (optional)
 
-Extends: [`ClientOptions`](/docs/docs/api/Client.md#parameter-clientoptions)
+#### Parameter: `RoundRobinPoolOptions`
 
-* **factory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Client(origin, opts)`
-* **connections** `number | null` (optional) - Default: `null` - The number of `Client` instances to create. When set to `null`, the `RoundRobinPool` instance will create an unlimited amount of `Client` instances.
-* **clientTtl** `number | null` (optional) - Default: `null` - The amount of time before a `Client` instance is removed from the `RoundRobinPool` and closed. When set to `null`, `Client` instances will not be removed or closed based on age.
+Extends: {ClientOptions}
 
-## Use Case
+* `factory` {Function} A function used to create the underlying {Client}
+  instances. **Default:** `(origin, opts) => new Client(origin, opts)`.
+  * `origin` {URL}
+  * `opts` {Object}
+  * Returns: {Dispatcher}
+* `connections` {number|null} (optional) The maximum number of {Client}
+  instances to create. When set to `null`, the `RoundRobinPool` instance creates
+  an unlimited number of {Client} instances. **Default:** `null`.
+* `clientTtl` {number|null} (optional) The amount of time, in milliseconds,
+  before a {Client} instance is removed from the `RoundRobinPool` and closed.
+  When set to `null`, {Client} instances are not removed or closed based on age.
+  **Default:** `null`.
 
-`RoundRobinPool` is designed for scenarios where:
+`RoundRobinPool` inherits all [`Client`][] options. A [`Client`][] instance is
+created lazily on the first dispatch and additional instances are created on
+demand, up to `connections`, when every existing client is busy.
 
-1. You connect to a single origin (e.g., `http://my-service.namespace.svc`)
-2. That origin is backed by a load balancer distributing TCP connections across multiple servers
-3. You want requests evenly distributed across all backend servers
+### `roundRobinPool.closed`
 
-**Example**: In Kubernetes, when using a Service DNS name with multiple Pod replicas, kube-proxy load balances TCP connections. `RoundRobinPool` ensures each connection (and thus each Pod) receives an equal share of requests.
+<!-- YAML
+added: v7.17.0
+-->
 
-### Important: Backend Distribution Considerations
+* Type: {boolean}
 
-`RoundRobinPool` distributes **HTTP requests** evenly across **TCP connections**. Whether this translates to even backend server distribution depends on the load balancer's behavior:
+`true` after `roundRobinPool.close()` has been called.
 
-**✓ Works when the load balancer**:
-- Assigns different backends to different TCP connections from the same client
-- Uses algorithms like: round-robin, random, least-connections (without client affinity)
-- Example: Default Kubernetes Services without `sessionAffinity`
+### `roundRobinPool.destroyed`
 
-**✗ Does NOT work when**:
-- Load balancer has client/source IP affinity (all connections from one IP → same backend)
-- Load balancer uses source-IP-hash or sticky sessions
+<!-- YAML
+added: v7.17.0
+-->
 
-**How it works:**
-1. `RoundRobinPool` creates N TCP connections to the load balancer endpoint
-2. Load balancer assigns each TCP connection to a backend (per its algorithm)
-3. `RoundRobinPool` cycles HTTP requests across those N connections
-4. Result: Requests distributed proportionally to how the LB distributed the connections
+* Type: {boolean}
 
-If the load balancer assigns all connections to the same backend (e.g., due to session affinity), `RoundRobinPool` cannot overcome this. In such cases, consider using [`BalancedPool`](/docs/docs/api/BalancedPool.md) with direct backend addresses (e.g., individual pod IPs) instead of a load-balanced endpoint.
+`true` after `roundRobinPool.destroy()` has been called, or after
+`roundRobinPool.close()` has been called and the pool shutdown has completed.
 
-## Instance Properties
+### `roundRobinPool.stats`
 
-### `RoundRobinPool.closed`
+<!-- YAML
+added: v7.17.0
+-->
 
-Implements [Client.closed](/docs/docs/api/Client.md#clientclosed)
+* Type: {PoolStats}
 
-### `RoundRobinPool.destroyed`
+Aggregate connection statistics for the pool. See [`PoolStats`][].
 
-Implements [Client.destroyed](/docs/docs/api/Client.md#clientdestroyed)
+### `roundRobinPool.close([callback])`
 
-### `RoundRobinPool.stats`
+<!-- YAML
+added: v7.17.0
+-->
 
-Returns [`PoolStats`](/docs/docs/api/PoolStats.md) instance for this pool.
+Closes the pool and gracefully waits for enqueued requests to complete before
+resolving. Implements [`dispatcher.close([callback])`][].
 
-## Instance Methods
+### `roundRobinPool.destroy([error[, callback]])`
 
-### `RoundRobinPool.close([callback])`
+<!-- YAML
+added: v7.17.0
+-->
 
-Implements [`Dispatcher.close([callback])`](/docs/docs/api/Dispatcher.md#dispatcherclosecallback-promise).
+Destroys the pool abruptly. All pending and running requests are aborted with
+the given `error`. Implements [`dispatcher.destroy([error[, callback]])`][].
 
-### `RoundRobinPool.destroy([error, callback])`
+### `roundRobinPool.connect(options[, callback])`
 
-Implements [`Dispatcher.destroy([error, callback])`](/docs/docs/api/Dispatcher.md#dispatcherdestroyerror-callback-promise).
+<!-- YAML
+added: v7.17.0
+-->
 
-### `RoundRobinPool.connect(options[, callback])`
+Starts two-way communications with the requested resource using
+[HTTP CONNECT][]. See [`dispatcher.connect(options[, callback])`][].
 
-See [`Dispatcher.connect(options[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherconnectoptions-callback).
+### `roundRobinPool.dispatch(options, handler)`
 
-### `RoundRobinPool.dispatch(options, handler)`
+<!-- YAML
+added: v7.17.0
+-->
 
-Implements [`Dispatcher.dispatch(options, handler)`](/docs/docs/api/Dispatcher.md#dispatcherdispatchoptions-handler).
+Dispatches a request through the next client selected in round-robin order.
+Implements [`dispatcher.dispatch(options, handler)`][].
 
-### `RoundRobinPool.pipeline(options, handler)`
+### `roundRobinPool.pipeline(options, handler)`
 
-See [`Dispatcher.pipeline(options, handler)`](/docs/docs/api/Dispatcher.md#dispatcherpipelineoptions-handler).
+<!-- YAML
+added: v7.17.0
+-->
 
-### `RoundRobinPool.request(options[, callback])`
+For easy use with [`stream.pipeline`][]. See
+[`dispatcher.pipeline(options, handler)`][].
 
-See [`Dispatcher.request(options [, callback])`](/docs/docs/api/Dispatcher.md#dispatcherrequestoptions-callback).
+### `roundRobinPool.request(options[, callback])`
 
-### `RoundRobinPool.stream(options, factory[, callback])`
+<!-- YAML
+added: v7.17.0
+-->
 
-See [`Dispatcher.stream(options, factory[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherstreamoptions-factory-callback).
+Performs an HTTP request. See [`dispatcher.request(options[, callback])`][].
 
-### `RoundRobinPool.upgrade(options[, callback])`
+### `roundRobinPool.stream(options, factory[, callback])`
 
-See [`Dispatcher.upgrade(options[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherupgradeoptions-callback).
+<!-- YAML
+added: v7.17.0
+-->
 
-## Instance Events
+A faster version of [`roundRobinPool.request()`][]. See
+[`dispatcher.stream(options, factory[, callback])`][].
+
+### `roundRobinPool.upgrade(options[, callback])`
+
+<!-- YAML
+added: v7.17.0
+-->
+
+Upgrades a connection to a different protocol. See
+[`dispatcher.upgrade(options[, callback])`][].
 
 ### Event: `'connect'`
 
-See [Dispatcher Event: `'connect'`](/docs/docs/api/Dispatcher.md#event-connect).
+<!-- YAML
+added: v7.17.0
+-->
+
+See [Dispatcher Event: `'connect'`][].
 
 ### Event: `'disconnect'`
 
-See [Dispatcher Event: `'disconnect'`](/docs/docs/api/Dispatcher.md#event-disconnect).
+<!-- YAML
+added: v7.17.0
+-->
+
+See [Dispatcher Event: `'disconnect'`][].
 
 ### Event: `'drain'`
 
-See [Dispatcher Event: `'drain'`](/docs/docs/api/Dispatcher.md#event-drain).
+<!-- YAML
+added: v7.17.0
+-->
+
+See [Dispatcher Event: `'drain'`][].
 
 ## Example
 
-```javascript
+```mjs
 import { RoundRobinPool } from 'undici'
 
-const pool = new RoundRobinPool('http://my-service.default.svc.cluster.local', {
+const pool = new RoundRobinPool('http://localhost:3000', {
   connections: 10
 })
 
-// Requests will be distributed evenly across all 10 connections
+// Requests are distributed evenly across all 10 connections.
 for (let i = 0; i < 100; i++) {
   const { body } = await pool.request({
     path: '/api/data',
@@ -137,9 +219,21 @@ for (let i = 0; i < 100; i++) {
 await pool.close()
 ```
 
-## See Also
-
-- [Pool](/docs/docs/api/Pool.md) - Connection pool without round-robin
-- [BalancedPool](/docs/docs/api/BalancedPool.md) - Load balancing across multiple origins
-- [Issue #3648](https://github.com/nodejs/undici/issues/3648) - Original issue describing uneven distribution
-
+[HTTP CONNECT]: https://developer.mozilla.org/docs/Web/HTTP/Methods/CONNECT
+[`BalancedPool`]: BalancedPool.md#class-balancedpool
+[`Client`]: Client.md#class-client
+[`Pool`]: Pool.md#class-pool
+[`PoolStats`]: PoolStats.md#class-poolstats
+[`dispatcher.close([callback])`]: Dispatcher.md#dispatcherclosecallback-promise
+[`dispatcher.connect(options[, callback])`]: Dispatcher.md#dispatcherconnectoptions-callback
+[`dispatcher.destroy([error[, callback]])`]: Dispatcher.md#dispatcherdestroyerror-callback-promise
+[`dispatcher.dispatch(options, handler)`]: Dispatcher.md#dispatcherdispatchoptions-handler
+[`dispatcher.pipeline(options, handler)`]: Dispatcher.md#dispatcherpipelineoptions-handler
+[`dispatcher.request(options[, callback])`]: Dispatcher.md#dispatcherrequestoptions-callback
+[`dispatcher.stream(options, factory[, callback])`]: Dispatcher.md#dispatcherstreamoptions-factory-callback
+[`dispatcher.upgrade(options[, callback])`]: Dispatcher.md#dispatcherupgradeoptions-callback
+[`roundRobinPool.request()`]: #roundrobinpoolrequestoptions-callback
+[`stream.pipeline`]: https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback
+[Dispatcher Event: `'connect'`]: Dispatcher.md#event-connect
+[Dispatcher Event: `'disconnect'`]: Dispatcher.md#event-disconnect
+[Dispatcher Event: `'drain'`]: Dispatcher.md#event-drain