@psnext/slingcli 2.4.20260520-2 → 2.4.20260520-4

package/node_modules/@earendil-works/pi-coding-agent/node_modules/undici/docs/docs/api/ProxyAgent.md

@@ -0,0 +1,229 @@
+# Class: ProxyAgent
+
+Extends: `undici.Dispatcher`
+
+A Proxy Agent class that implements the Agent API. It allows the connection through proxy in a simple way.
+
+## `new ProxyAgent([options])`
+
+Arguments:
+
+* **options** `ProxyAgentOptions` (required) - It extends the `Agent` options.
+
+Returns: `ProxyAgent`
+
+### Parameter: `ProxyAgentOptions`
+
+Extends: [`AgentOptions`](/docs/docs/api/Agent.md#parameter-agentoptions)
+> It ommits `AgentOptions#connect`.
+
+> **Note:** When `AgentOptions#connections` is set, and different from `0`, the non-standard [`proxy-connection` header](https://udger.com/resources/http-request-headers-detail?header=Proxy-Connection) will be set to `keep-alive` in the request.
+
+* **uri** `string | URL` (required) - The URI of the proxy server.  This can be provided as a string, as an instance of the URL class, or as an object with a `uri` property of type string.
+If the `uri` is provided as a string or `uri` is an object with an `uri` property of type string, then it will be parsed into a `URL` object according to the [WHATWG URL Specification](https://url.spec.whatwg.org).
+For detailed information on the parsing process and potential validation errors, please refer to the ["Writing" section](https://url.spec.whatwg.org/#writing) of the WHATWG URL Specification.
+* **token** `string` (optional) - It can be passed by a string of token for authentication.
+* **auth** `string` (**deprecated**) - Use token.
+* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`
+* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
+* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
+* **proxyTunnel** `boolean` (optional) - For connections involving secure protocols, Undici will always establish a tunnel via the HTTP2  CONNECT extension. If proxyTunnel is set to true, this will occur for unsecured proxy/endpoint connections as well. Currently, there is no way to facilitate HTTP1 IP tunneling as described in https://www.rfc-editor.org/rfc/rfc9484.html#name-http-11-request. If proxyTunnel is set to false (the default), ProxyAgent connections where both the Proxy and Endpoint are unsecured will issue all requests to the Proxy, and prefix the endpoint request path with the endpoint origin address.
+
+Examples:
+
+```js
+import { ProxyAgent } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+// or
+const proxyAgent = new ProxyAgent(new URL('my.proxy.server'))
+// or
+const proxyAgent = new ProxyAgent({ uri: 'my.proxy.server' })
+// or
+const proxyAgent = new ProxyAgent({
+  uri: new URL('my.proxy.server'),
+  proxyTls: {
+    signal: AbortSignal.timeout(1000)
+  }
+})
+```
+
+#### Example - Basic ProxyAgent instantiation
+
+This will instantiate the ProxyAgent. It will not do anything until registered as the agent to use with requests.
+
+```js
+import { ProxyAgent } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+```
+
+#### Example - Basic Proxy Request with global agent dispatcher
+
+```js
+import { setGlobalDispatcher, request, ProxyAgent } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+setGlobalDispatcher(proxyAgent)
+
+const { statusCode, body } = await request('http://localhost:3000/foo')
+
+console.log('response received', statusCode) // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+#### Example - Basic Proxy Request with local agent dispatcher
+
+```js
+import { ProxyAgent, request } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo', { dispatcher: proxyAgent })
+
+console.log('response received', statusCode) // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+#### Example - Basic Proxy Request with authentication
+
+```js
+import { setGlobalDispatcher, request, ProxyAgent } from 'undici';
+
+const proxyAgent = new ProxyAgent({
+  uri: 'my.proxy.server',
+  // token: 'Bearer xxxx'
+  token: `Basic ${Buffer.from('username:password').toString('base64')}`
+});
+setGlobalDispatcher(proxyAgent);
+
+const { statusCode, body } = await request('http://localhost:3000/foo');
+
+console.log('response received', statusCode); // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')); // data foo
+}
+```
+
+### `ProxyAgent.close()`
+
+Closes the proxy agent and waits for registered pools and clients to also close before resolving.
+
+Returns: `Promise<void>`
+
+#### Example - clean up after tests are complete
+
+```js
+import { ProxyAgent, setGlobalDispatcher } from 'undici'
+
+const proxyAgent = new ProxyAgent('my.proxy.server')
+setGlobalDispatcher(proxyAgent)
+
+await proxyAgent.close()
+```
+
+### `ProxyAgent.dispatch(options, handlers)`
+
+Implements [`Agent.dispatch(options, handlers)`](/docs/docs/api/Agent.md#parameter-agentdispatchoptions).
+
+### `ProxyAgent.request(options[, callback])`
+
+See [`Dispatcher.request(options [, callback])`](/docs/docs/api/Dispatcher.md#dispatcherrequestoptions-callback).
+
+
+#### Example - ProxyAgent with Fetch
+
+This example demonstrates how to use `fetch` with a proxy via `ProxyAgent`. It is particularly useful for scenarios requiring proxy tunneling.
+
+```javascript
+import { ProxyAgent, fetch } from 'undici';
+
+// Define the ProxyAgent
+const proxyAgent = new ProxyAgent('http://localhost:8000');
+
+// Make a GET request through the proxy
+const response = await fetch('http://localhost:3000/foo', {
+  dispatcher: proxyAgent,
+  method: 'GET',
+});
+
+console.log('Response status:', response.status);
+console.log('Response data:', await response.text());
+```
+
+---
+
+#### Example - ProxyAgent with a Custom Proxy Server
+
+This example shows how to create a custom proxy server and use it with `ProxyAgent`.
+
+```javascript
+import * as http from 'node:http';
+import { createProxy } from 'proxy';
+import { ProxyAgent, fetch } from 'undici';
+
+// Create a proxy server
+const proxyServer = createProxy(http.createServer());
+proxyServer.listen(8000, () => {
+  console.log('Proxy server running on port 8000');
+});
+
+// Define and use the ProxyAgent
+const proxyAgent = new ProxyAgent('http://localhost:8000');
+
+const response = await fetch('http://example.com', {
+  dispatcher: proxyAgent,
+  method: 'GET',
+});
+
+console.log('Response status:', response.status);
+console.log('Response data:', await response.text());
+```
+
+---
+
+#### Example - ProxyAgent with HTTPS Tunneling
+
+This example demonstrates how to perform HTTPS tunneling using a proxy.
+
+```javascript
+import { ProxyAgent, fetch } from 'undici';
+
+// Define a ProxyAgent for HTTPS proxy
+const proxyAgent = new ProxyAgent('https://secure.proxy.server');
+
+// Make a request to an HTTPS endpoint via the proxy
+const response = await fetch('https://secure.endpoint.com/api/data', {
+  dispatcher: proxyAgent,
+  method: 'GET',
+});
+
+console.log('Response status:', response.status);
+console.log('Response data:', await response.json());
+```
+
+#### Example - ProxyAgent as a Global Dispatcher
+
+`ProxyAgent` can be configured as a global dispatcher, making it available for all requests without explicitly passing it. This simplifies code and is useful when a single proxy configuration applies to all requests.
+
+```javascript
+import { ProxyAgent, setGlobalDispatcher, fetch } from 'undici';
+
+// Define and configure the ProxyAgent
+const proxyAgent = new ProxyAgent('http://localhost:8000');
+setGlobalDispatcher(proxyAgent);
+
+// Make requests without specifying the dispatcher
+const response = await fetch('http://example.com');
+console.log('Response status:', response.status);
+console.log('Response data:', await response.text());

package/node_modules/@earendil-works/pi-coding-agent/node_modules/undici/docs/docs/api/RedirectHandler.md

@@ -0,0 +1,98 @@
+# Class: RedirectHandler
+
+A class that handles redirection logic for HTTP requests.
+
+## `new RedirectHandler(dispatch, maxRedirections, opts, handler)`
+
+Arguments:
+
+- **dispatch** `function` - The dispatch function to be called after every retry.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **opts** `object` - Options for handling redirection.
+- **handler** `object` - An object containing handlers for different stages of the request lifecycle.
+
+Returns: `RedirectHandler`
+
+### Parameters
+
+- **dispatch** `(options: Dispatch.DispatchOptions, handlers: Dispatch.DispatchHandler) => Promise<Dispatch.DispatchResponse>` (required) - Dispatch function to be called after every redirection.
+- **maxRedirections** `number` (required) - Maximum number of redirections allowed.
+- **opts** `object` (required) - Options for handling redirection.
+- **handler** `object` (required) - Handlers for different stages of the request lifecycle.
+
+### Properties
+
+- **location** `string` - The current redirection location.
+- **abort** `function` - The abort function.
+- **opts** `object` - The options for handling redirection.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **handler** `object` - Handlers for different stages of the request lifecycle.
+- **history** `Array` - An array representing the history of URLs during redirection.
+
+### Methods
+
+#### `onRequestStart(controller, context)`
+
+Called when the request starts.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **context** `object` - The dispatch context.
+
+#### `onRequestUpgrade(controller, statusCode, headers, socket)`
+
+Called when an upgrade is requested.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **socket** `object` - The socket object.
+
+#### `onResponseError(controller, error)`
+
+Called when an error occurs.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **error** `Error` - The error that occurred.
+
+#### `onResponseStart(controller, statusCode, headers, statusText)`
+
+Called when headers are received.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **statusText** `string` - The status text.
+
+#### `onResponseData(controller, chunk)`
+
+Called when data is received.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **chunk** `Buffer` - The data chunk received.
+
+#### `onResponseEnd(controller, trailers)`
+
+Called when the request is complete.
+
+Parameters:
+
+- **controller** `DispatchController` - The request controller.
+- **trailers** `object` - The trailers received.
+
+#### `onBodySent(chunk)`
+
+Called when the request body is sent.
+
+Parameters:
+
+- **chunk** `Buffer` - The chunk of the request body sent.

package/node_modules/@earendil-works/pi-coding-agent/node_modules/undici/docs/docs/api/RetryAgent.md

@@ -0,0 +1,49 @@
+# Class: RetryAgent
+
+Extends: `undici.Dispatcher`
+
+A `undici.Dispatcher` that allows to automatically retry a request.
+Wraps a `undici.RetryHandler`.
+
+## `new RetryAgent(dispatcher, [options])`
+
+Arguments:
+
+* **dispatcher** `undici.Dispatcher` (required) - the dispatcher to wrap
+* **options** `RetryHandlerOptions` (optional) - the options
+
+Returns: `ProxyAgent`
+
+### Parameter: `RetryHandlerOptions`
+
+- **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. Default: `true`
+- **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', 'PUT', 'HEAD', 'OPTIONS', 'DELETE']`
+- **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', 'UND_ERR_SOCKET']`
+
+**`RetryContext`**
+
+- `state`: `RetryState` - Current retry state. It can be mutated.
+- `opts`: `Dispatch.DispatchOptions & RetryOptions` - Options passed to the retry handler.
+
+Example:
+
+```js
+import { Agent, RetryAgent } from 'undici'
+
+const agent = new RetryAgent(new Agent())
+
+const res = await agent.request({
+  method: 'GET',
+  origin: 'http://example.com',
+  path: '/',
+})
+console.log(res.statusCode)
+console.log(await res.body.text())
+```

package/node_modules/@earendil-works/pi-coding-agent/node_modules/undici/docs/docs/api/RetryHandler.md

@@ -0,0 +1,116 @@
+# Class: RetryHandler
+
+Extends: `undici.DispatcherHandlers`
+
+A handler class that implements the retry logic for a request.
+
+## `new RetryHandler(dispatchOptions, retryHandlers, [retryOptions])`
+
+Arguments:
+
+- **options** `Dispatch.DispatchOptions & RetryOptions` (required) - It is an intersection of `Dispatcher.DispatchOptions` and `RetryOptions`.
+- **retryHandlers** `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`
+
+- **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) => number | null` (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', 'PUT', 'HEAD', 'OPTIONS', 'DELETE']`
+- **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', 'UND_ERR_SOCKET']`
+
+**`RetryContext`**
+
+- `state`: `RetryState` - Current retry state. It can be mutated.
+- `opts`: `Dispatch.DispatchOptions & RetryOptions` - Options passed to the retry handler.
+
+**`RetryState`**
+
+It represents the retry state for a given request.
+
+- `counter`: `number` - Current retry attempt.
+
+### Parameter `RetryHandlers`
+
+- **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.
+
+>__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`.
+
+Examples:
+
+```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;
+        }
+
+        if (err.statusCode === 206) {
+          callback(err);
+          return;
+        }
+
+        setTimeout(() => callback(null), 1000);
+      },
+    },
+  },
+  {
+    dispatch: (...args) => {
+      return client.dispatch(...args);
+    },
+    handler: {
+      onRequestStart() {},
+      onBodySent(chunk) {},
+      onResponseStart(_controller, status, headers) {
+        // do something with headers
+      },
+      onResponseData(_controller, chunk) {
+        chunks.push(chunk);
+      },
+      onResponseEnd() {},
+      onResponseError(_controller, err) {
+        // handle error properly
+      },
+    },
+  }
+);
+```
+
+#### Example - Basic RetryHandler with defaults
+
+```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) {},
+  },
+});
+```

package/node_modules/@earendil-works/pi-coding-agent/node_modules/undici/docs/docs/api/RoundRobinPool.md

@@ -0,0 +1,145 @@
+# Class: RoundRobinPool
+
+Extends: `undici.Dispatcher`
+
+A pool of [Client](/docs/docs/api/Client.md) instances connected to the same upstream target with round-robin client selection.
+
+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).
+
+Requests are not guaranteed to be dispatched in order of invocation.
+
+## `new RoundRobinPool(url[, options])`
+
+Arguments:
+
+* **url** `URL | string` - It should only include the **protocol, hostname, and port**.
+* **options** `RoundRobinPoolOptions` (optional)
+
+### Parameter: `RoundRobinPoolOptions`
+
+Extends: [`ClientOptions`](/docs/docs/api/Client.md#parameter-clientoptions)
+
+* **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.
+
+## Use Case
+
+`RoundRobinPool` is designed for scenarios where:
+
+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
+
+**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.
+
+### Important: Backend Distribution Considerations
+
+`RoundRobinPool` distributes **HTTP requests** evenly across **TCP connections**. Whether this translates to even backend server distribution depends on the load balancer's behavior:
+
+**✓ 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`
+
+**✗ 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
+
+**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
+
+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.
+
+## Instance Properties
+
+### `RoundRobinPool.closed`
+
+Implements [Client.closed](/docs/docs/api/Client.md#clientclosed)
+
+### `RoundRobinPool.destroyed`
+
+Implements [Client.destroyed](/docs/docs/api/Client.md#clientdestroyed)
+
+### `RoundRobinPool.stats`
+
+Returns [`PoolStats`](PoolStats.md) instance for this pool.
+
+## Instance Methods
+
+### `RoundRobinPool.close([callback])`
+
+Implements [`Dispatcher.close([callback])`](/docs/docs/api/Dispatcher.md#dispatcherclosecallback-promise).
+
+### `RoundRobinPool.destroy([error, callback])`
+
+Implements [`Dispatcher.destroy([error, callback])`](/docs/docs/api/Dispatcher.md#dispatcherdestroyerror-callback-promise).
+
+### `RoundRobinPool.connect(options[, callback])`
+
+See [`Dispatcher.connect(options[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherconnectoptions-callback).
+
+### `RoundRobinPool.dispatch(options, handler)`
+
+Implements [`Dispatcher.dispatch(options, handler)`](/docs/docs/api/Dispatcher.md#dispatcherdispatchoptions-handler).
+
+### `RoundRobinPool.pipeline(options, handler)`
+
+See [`Dispatcher.pipeline(options, handler)`](/docs/docs/api/Dispatcher.md#dispatcherpipelineoptions-handler).
+
+### `RoundRobinPool.request(options[, callback])`
+
+See [`Dispatcher.request(options [, callback])`](/docs/docs/api/Dispatcher.md#dispatcherrequestoptions-callback).
+
+### `RoundRobinPool.stream(options, factory[, callback])`
+
+See [`Dispatcher.stream(options, factory[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherstreamoptions-factory-callback).
+
+### `RoundRobinPool.upgrade(options[, callback])`
+
+See [`Dispatcher.upgrade(options[, callback])`](/docs/docs/api/Dispatcher.md#dispatcherupgradeoptions-callback).
+
+## Instance Events
+
+### Event: `'connect'`
+
+See [Dispatcher Event: `'connect'`](/docs/docs/api/Dispatcher.md#event-connect).
+
+### Event: `'disconnect'`
+
+See [Dispatcher Event: `'disconnect'`](/docs/docs/api/Dispatcher.md#event-disconnect).
+
+### Event: `'drain'`
+
+See [Dispatcher Event: `'drain'`](/docs/docs/api/Dispatcher.md#event-drain).
+
+## Example
+
+```javascript
+import { RoundRobinPool } from 'undici'
+
+const pool = new RoundRobinPool('http://my-service.default.svc.cluster.local', {
+  connections: 10
+})
+
+// Requests will be distributed evenly across all 10 connections
+for (let i = 0; i < 100; i++) {
+  const { body } = await pool.request({
+    path: '/api/data',
+    method: 'GET'
+  })
+  console.log(await body.json())
+}
+
+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
+