@openclaw/diagnostics-otel 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/import-in-the-middle/lib/get-exports.mjs

@@ -1,17 +1,29 @@
 'use strict'
 
 import getEsmExports from './get-esm-exports.mjs'
-import { parse as parseCjs, init as parserInit } from 'cjs-module-lexer'
+import { parse as parseCjs, initSync } from 'cjs-module-lexer'
 import { readFileSync, existsSync } from 'fs'
 import { builtinModules, createRequire } from 'module'
 import { fileURLToPath, pathToFileURL } from 'url'
 import { dirname, join } from 'path'
+import { LOAD } from './io.mjs'
 
 const nodeMajor = Number(process.versions.node.split('.')[0])
 export const hasModuleExportsCJSDefault = nodeMajor >= 23
 
 let parserInitialized = false
 
+// The CJS export scanner is backed by WebAssembly. `initSync` compiles it
+// up front so the scanner can run inside synchronous loader hooks
+// (`module.registerHooks`) as well as the off-thread loader; it is a one-time
+// cost on the first CommonJS module either way.
+function ensureParserInitialized () {
+  if (!parserInitialized) {
+    initSync()
+    parserInitialized = true
+  }
+}
+
 function addDefault (arr) {
   return new Set(['default', ...arr])
 }
@@ -142,15 +154,33 @@ const BUILT_INS = new Map()
 
 let require
 
-function getExportsForNodeBuiltIn (name) {
-  let exports = BUILT_INS.get(name)
-
+// Returns a builtin's exports object. `process.getBuiltinModule` (Node >=
+// 20.16 / >= 22.3) bypasses registered loader hooks; `require` does not. Under
+// the in-thread `module.registerHooks` loader a plain `require(name)` here
+// re-enters iitm's own hooks and resolves to the half-built wrapper instead of
+// the native module. The off-thread `module.register` loader runs `require` on
+// the loader thread where the hooks aren't installed, so the fallback stays
+// correct on older Node that lacks getBuiltinModule.
+function loadBuiltin (name) {
+  if (typeof process.getBuiltinModule === 'function') {
+    return process.getBuiltinModule(name)
+  }
   if (!require) {
     require = createRequire(import.meta.url)
   }
+  return require(name)
+}
+
+function getExportsForNodeBuiltIn (name) {
+  let exports = BUILT_INS.get(name)
 
   if (!exports) {
-    exports = new Set(addDefault(Object.keys(require(name))))
+    // get all properties both enumerable and non-enumerable
+    exports = new Set(addDefault(Object.getOwnPropertyNames(loadBuiltin(name))))
+    // added in node 23 as alias for default in cjs modules
+    if (hasModuleExportsCJSDefault) {
+      exports.add('module.exports')
+    }
     BUILT_INS.set(name, exports)
   }
 
@@ -215,52 +245,54 @@ function resolvePackageImports (specifier, fromUrl) {
   return null
 }
 
-async function getCjsExports (url, context, parentLoad, source) {
+function * getCjsExports (url, context, source) {
   if (urlsBeingProcessed.has(url)) {
     return new Set()
   }
   urlsBeingProcessed.add(url)
 
   try {
-    if (!parserInitialized) {
-      await parserInit()
-      parserInitialized = true
-    }
+    ensureParserInitialized()
     const result = parseCjs(source)
     const full = addDefault(result.exports)
 
-    await Promise.all(result.reexports.map(async re => {
-      if (re.startsWith('node:') || builtinModules.includes(re)) {
-        for (const each of getExportsForNodeBuiltIn(re)) {
+    for (const reexport of result.reexports) {
+      if (reexport.startsWith('node:') || builtinModules.includes(reexport)) {
+        for (const each of getExportsForNodeBuiltIn(reexport)) {
           full.add(each)
         }
-      } else {
-        if (re === '.') {
-          re = './'
-        }
+        continue
+      }
 
-        // Entries in the import field should always start with #
-        if (re.startsWith('#')) {
-          const resolved = resolvePackageImports(re, url)
-          if (!resolved) return
-          [url, re] = resolved
-        }
+      // Resolve each re-export relative to the current module. Keep the
+      // resolution scoped to this iteration: a `#`-import rewrites both the
+      // base URL and the specifier, and that rewrite must not leak into the
+      // next re-export.
+      let reUrl = url
+      let reSpecifier = reexport === '.' ? './' : reexport
+
+      // Entries in the import field should always start with #
+      if (reSpecifier.startsWith('#')) {
+        const resolved = resolvePackageImports(reSpecifier, url)
+        if (!resolved) continue
+        ;[reUrl, reSpecifier] = resolved
+      }
 
-        // Resolve the re-exported module relative to the current module.
-        if (!require) {
-          require = createRequire(import.meta.url)
-        }
-        const newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+      if (!require) {
+        require = createRequire(import.meta.url)
+      }
+      const newUrl = pathToFileURL(
+        require.resolve(reSpecifier, { paths: [dirname(fileURLToPath(reUrl))] })
+      ).href
 
-        if (newUrl.endsWith('.node') || newUrl.endsWith('.json')) {
-          return
-        }
+      if (newUrl.endsWith('.node') || newUrl.endsWith('.json')) {
+        continue
+      }
 
-        for (const each of await getExports(newUrl, context, parentLoad)) {
-          full.add(each)
-        }
+      for (const each of yield * getExports(newUrl, context)) {
+        full.add(each)
       }
-    }))
+    }
 
     // added in node 23 as alias for default in cjs modules
     if (full.has('default') && hasModuleExportsCJSDefault) {
@@ -276,26 +308,30 @@ async function getCjsExports (url, context, parentLoad, source) {
 }
 
 /**
- * Inspects a module for its type (commonjs or module), attempts to get the
- * source code for said module from the loader API, and parses the result
- * for the entities exported from that module.
+ * Inspects a module for its type (commonjs or module), obtains the source code
+ * for said module from the loader API, and parses the result for the entities
+ * exported from that module.
+ *
+ * This is a "sans-io" generator: instead of calling the loader's `load` hook
+ * directly, it `yield`s `[LOAD, url, context]` and is driven by either
+ * {@link driveSync} or {@link driveAsync} (see `lib/io.mjs`). The same body
+ * therefore serves both the off-thread loader and `module.registerHooks`.
  *
- * @param {string} url A file URL string pointing to the module that
- * we should get the exports of.
- * @param {object} context Context object as provided by the `load`
- * hook from the loaders API.
- * @param {Function} parentLoad Next hook function in the loaders API
- * hook chain.
+ * @param {string} url A file URL string pointing to the module that we should
+ * get the exports of.
+ * @param {object} context Context object as provided by the `load` hook from
+ * the loaders API.
  *
- * @returns {Promise<Set<string>>} An array of identifiers exported by the module.
+ * @returns {Generator<Array, Set<string>>} A generator that yields I/O
+ * operations and ultimately returns the identifiers exported by the module.
  * Please see {@link getEsmExports} for caveats on special identifiers that may
  * be included in the result set.
  */
-export async function getExports (url, context, parentLoad) {
-  // `parentLoad` gives us the possibility of getting the source
-  // from an upstream loader. This doesn't always work though,
-  // so later on we fall back to reading it from disk.
-  const parentCtx = await parentLoad(url, context)
+export function * getExports (url, context) {
+  // `[LOAD, ...]` gives us the possibility of getting the source from an
+  // upstream loader. This doesn't always work though, so later on we fall back
+  // to reading it from disk.
+  const parentCtx = yield [LOAD, url, context]
   let source = parentCtx.source
   const format = parentCtx.format
 
@@ -331,7 +367,7 @@ export async function getExports (url, context, parentLoad) {
     }
 
     if (format === 'commonjs') {
-      return await getCjsExports(url, context, parentLoad, source)
+      return yield * getCjsExports(url, context, source)
     }
 
     // At this point our `format` is either undefined or not known by us. Fall
@@ -344,7 +380,7 @@ export async function getExports (url, context, parentLoad) {
       if (!hasEsmSyntax(source)) {
         // It might be possible to get here if the format
         // isn't set at first and yet we have an ESM module with no exports.
-        return await getCjsExports(url, context, parentLoad, source)
+        return yield * getCjsExports(url, context, source)
       }
     }
     return esmExports

package/node_modules/import-in-the-middle/lib/io.mjs

@@ -0,0 +1,78 @@
+'use strict'
+
+// The export-collection logic (resolving star re-exports, reading source,
+// parsing exports) is identical whether `import-in-the-middle` runs as an
+// off-thread loader (`module.register`, asynchronous `nextResolve`/`nextLoad`)
+// or as an in-thread synchronous loader (`module.registerHooks`). To keep a
+// single implementation of that logic — instead of two copies that drift — it
+// is written as "sans-io" generators that `yield` the I/O they need and let a
+// driver fulfil it. The async driver awaits; the sync driver calls straight
+// through. Everything between the yields is shared.
+
+// Operation kinds a loader generator may yield. Each is `[KIND, ...args]`.
+export const LOAD = 0 // [LOAD, url, context]      -> resolves to { source, format }
+export const RESOLVE = 1 // [RESOLVE, specifier, context] -> resolves to { url, format }
+
+function runOp (op, io) {
+  if (op[0] === RESOLVE) {
+    return io.resolve(op[1], op[2])
+  }
+  return io.load(op[1], op[2])
+}
+
+/**
+ * Drives a loader generator to completion, fulfilling each yielded I/O
+ * operation synchronously. Used with `module.registerHooks`, whose
+ * `nextResolve`/`nextLoad` return their result directly.
+ *
+ * Errors from I/O are thrown back into the generator (via `gen.throw`) so its
+ * `try`/`finally` blocks run exactly as they would for an `await` rejection.
+ *
+ * @template T
+ * @param {Generator<Array, T>} gen
+ * @param {{ load: Function, resolve?: Function }} io
+ * @returns {T}
+ */
+export function driveSync (gen, io) {
+  let next = gen.next()
+  while (next.done === false) {
+    let result
+    let error
+    let threw = false
+    try {
+      result = runOp(next.value, io)
+    } catch (err) {
+      threw = true
+      error = err
+    }
+    next = threw ? gen.throw(error) : gen.next(result)
+  }
+  return next.value
+}
+
+/**
+ * Drives a loader generator to completion, awaiting each yielded I/O
+ * operation. Used with the off-thread `module.register` loader, whose
+ * `nextResolve`/`nextLoad` are asynchronous.
+ *
+ * @template T
+ * @param {Generator<Array, T>} gen
+ * @param {{ load: Function, resolve?: Function }} io
+ * @returns {Promise<T>}
+ */
+export async function driveAsync (gen, io) {
+  let next = gen.next()
+  while (next.done === false) {
+    let result
+    let error
+    let threw = false
+    try {
+      result = await runOp(next.value, io)
+    } catch (err) {
+      threw = true
+      error = err
+    }
+    next = threw ? gen.throw(error) : gen.next(result)
+  }
+  return next.value
+}

package/node_modules/import-in-the-middle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "import-in-the-middle",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "description": "Intercept imports in Node.js",
   "engines": {
     "node": ">=18"

package/node_modules/import-in-the-middle/register-hooks.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for {@link register}. `include`/`exclude` accept bare specifiers,
+ * `file:` URLs or regular expressions, matched against the module being
+ * resolved.
+ */
+export type RegisterHooksOptions = {
+  include?: Array<string | RegExp>
+  exclude?: Array<string | RegExp>
+}
+
+/**
+ * Registers `import-in-the-middle` as a *synchronous*, in-thread loader hook via
+ * [`module.registerHooks()`](https://nodejs.org/api/module.html#moduleregisterhooksoptions).
+ *
+ * Unlike `module.register('import-in-the-middle/hook.mjs', ...)`, which runs the
+ * loader on a separate thread and pays an IPC round-trip per resolved module,
+ * synchronous hooks run on the application thread, so `Hook()` registrations are
+ * visible to the loader directly and no acknowledgement step is required.
+ *
+ * Requires a Node.js version with `module.registerHooks()` (>= 22.15.0 / >= 24).
+ *
+ * ```ts
+ * import { register } from 'import-in-the-middle/register-hooks.mjs'
+ * import { Hook } from 'import-in-the-middle'
+ *
+ * register({ include: ['package-i-want-to-include'] })
+ *
+ * Hook(['package-i-want-to-include'], (exported, name, baseDir) => {
+ *   // Instrument the module
+ * })
+ * ```
+ *
+ * @throws If `module.registerHooks()` is unavailable in the running Node.js.
+ */
+export declare function register(options?: RegisterHooksOptions): void

package/node_modules/import-in-the-middle/register-hooks.mjs

@@ -0,0 +1,63 @@
+import * as module from 'module'
+import { createHook, supportsSyncHooks } from './create-hook.mjs'
+
+export { supportsSyncHooks }
+
+const hook = createHook(import.meta)
+
+let registered = false
+
+/**
+ * Registers `import-in-the-middle` as a *synchronous*, in-thread loader hook via
+ * [`module.registerHooks()`](https://nodejs.org/api/module.html#moduleregisterhooksoptions).
+ *
+ * Unlike `module.register('import-in-the-middle/hook.mjs', ...)`, which runs the
+ * loader on a separate thread and pays an IPC round-trip per resolved module,
+ * synchronous hooks run in the application thread. There is no message channel
+ * to bridge, so `Hook()` registrations from the main `import-in-the-middle`
+ * entry point are visible to the loader directly and no acknowledgement step is
+ * required.
+ *
+ * Requires a Node.js version whose `module.registerHooks` accepts the nullish
+ * CommonJS source the loader relies on: >= 22.22.3, >= 24.11.1, >= 25.1.0, or
+ * >= 26.0.0 (see `supportsSyncHooks`). Use that predicate to fall back to the
+ * asynchronous `module.register` loader on unsupported versions.
+ *
+ * ```js
+ * import { register } from 'import-in-the-middle/register-hooks.mjs'
+ * import { Hook } from 'import-in-the-middle'
+ *
+ * register({ include: ['package-i-want-to-include'] })
+ *
+ * Hook(['package-i-want-to-include'], (exported, name, baseDir) => {
+ *   // Instrument the module
+ * })
+ * ```
+ *
+ * @param {object} [options]
+ * @param {Array<string|RegExp>} [options.include] Only intercept these modules.
+ * @param {Array<string|RegExp>} [options.exclude] Never intercept these modules.
+ * @returns {void}
+ */
+export function register (options) {
+  if (!supportsSyncHooks()) {
+    throw new Error(
+      "'import-in-the-middle' synchronous hooks require a Node.js version whose " +
+      'module.registerHooks accepts nullish CommonJS source ' +
+      '(>= 22.22.3, >= 24.11.1, >= 25.1.0, or >= 26.0.0); ' +
+      'see https://github.com/nodejs/node/pull/59929'
+    )
+  }
+
+  if (registered) {
+    process.emitWarning("'import-in-the-middle' synchronous hooks have already been registered")
+    return
+  }
+  registered = true
+
+  if (options) {
+    hook.applyOptions(options)
+  }
+
+  module.registerHooks({ resolve: hook.resolveSync, load: hook.loadSync })
+}

package/node_modules/undici-types/agent.d.ts

@@ -22,8 +22,6 @@ declare namespace Agent {
   export interface Options extends Pool.Options {
     /** Default: `(origin, opts) => new Pool(origin, opts)`. */
     factory?(origin: string | URL, opts: Object): Dispatcher;
-
-    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
     maxOrigins?: number
   }
 

package/node_modules/undici-types/client.d.ts

@@ -3,7 +3,7 @@ import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 import TClientStats from './client-stats'
 
-type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>
 
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
@@ -20,22 +20,17 @@ export class Client extends Dispatcher {
   readonly stats: TClientStats
 
   // Override dispatcher APIs.
-  override connect (
-    options: ClientConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
-    options: ClientConnectOptions,
-    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>
+  ): Promise<Dispatcher.ConnectData<TOpaque>>
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>,
+    callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void
   ): void
 }
 
 export declare namespace Client {
-  export interface OptionsInterceptors {
-    Client: readonly Dispatcher.DispatchInterceptor[];
-  }
   export interface Options {
-    /** TODO */
-    interceptors?: OptionsInterceptors;
     /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
     maxHeaderSize?: number;
     /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
@@ -44,7 +39,7 @@ export declare namespace Client {
     socketTimeout?: never;
     /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
     requestTimeout?: never;
-    /** TODO */
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
     connectTimeout?: number;
     /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
     bodyTimeout?: number;
@@ -60,7 +55,7 @@ export declare namespace Client {
     keepAliveMaxTimeout?: number;
     /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
     keepAliveTimeoutThreshold?: number;
-    /** TODO */
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
     socketPath?: string;
     /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
     pipelining?: number;
@@ -68,23 +63,25 @@ export declare namespace Client {
     tls?: never;
     /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
     strictContentLength?: boolean;
-    /** TODO */
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
     maxCachedSessions?: number;
-    /** TODO */
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
     connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
-    /** TODO */
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
     maxRequestsPerClient?: number;
-    /** TODO */
+    /** Local IP address the socket should connect from. */
     localAddress?: string;
     /** Max response body size in bytes, -1 is disabled */
     maxResponseSize?: number;
+    /** WebSocket-specific options */
+    webSocket?: Client.WebSocketOptions;
     /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
     autoSelectFamily?: boolean;
     /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
     autoSelectFamilyAttemptTimeout?: number;
     /**
      * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
-     * @default false
+     * @default true
      */
     allowH2?: boolean;
     /**
@@ -118,6 +115,15 @@ export declare namespace Client {
     bytesWritten?: number
     bytesRead?: number
   }
+  export interface WebSocketOptions {
+    /**
+     * Maximum allowed payload size in bytes for WebSocket messages.
+     * Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages.
+     * Set to 0 to disable the limit.
+     * @default 134217728 (128 MB)
+     */
+    maxPayloadSize?: number;
+  }
 }
 
 export default Client

package/node_modules/undici-types/dispatcher.d.ts

@@ -2,17 +2,15 @@ import { URL } from 'node:url'
 import { Duplex, Readable, Writable } from 'node:stream'
 import { EventEmitter } from 'node:events'
 import { Blob } from 'node:buffer'
-import { IncomingHttpHeaders } from './header'
+import { IncomingHttpHeaders, OutgoingHttpHeaders } from './header'
 import BodyReadable from './readable'
 import { FormData } from './formdata'
 import Errors from './errors'
 import { Autocomplete } from './utility'
 
-type AbortSignal = unknown
-
 export default Dispatcher
 
-export type UndiciHeaders = Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null
+export type UndiciHeaders = OutgoingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null
 
 /** Dispatcher is the core API used to dispatch requests. */
 declare class Dispatcher extends EventEmitter {
@@ -123,8 +121,6 @@ declare namespace Dispatcher {
     bodyTimeout?: number | null;
     /** Whether the request should stablish a keep-alive or not. Default `false` */
     reset?: boolean;
-    /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
-    throwOnError?: boolean;
     /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
     expectContinue?: boolean;
   }
@@ -137,8 +133,6 @@ declare namespace Dispatcher {
     signal?: AbortSignal | EventEmitter | null;
     /** This argument parameter is passed through to `ConnectData` */
     opaque?: TOpaque;
-    /** Default: false */
-    redirectionLimitReached?: boolean;
     /** Default: `null` */
     responseHeaders?: 'raw' | null;
   }
@@ -147,8 +141,6 @@ declare namespace Dispatcher {
     opaque?: TOpaque;
     /** Default: `null` */
     signal?: AbortSignal | EventEmitter | null;
-    /** Default: false */
-    redirectionLimitReached?: boolean;
     /** Default: `null` */
     onInfo?: (info: { statusCode: number, headers: Record<string, string | string[]> }) => void;
     /** Default: `null` */
@@ -170,8 +162,6 @@ declare namespace Dispatcher {
     protocol?: string;
     /** Default: `null` */
     signal?: AbortSignal | EventEmitter | null;
-    /** Default: false */
-    redirectionLimitReached?: boolean;
     /** Default: `null` */
     responseHeaders?: 'raw' | null;
   }
@@ -218,6 +208,8 @@ declare namespace Dispatcher {
     get aborted(): boolean
     get paused(): boolean
     get reason(): Error | null
+    rawHeaders?: Buffer[] | string[] | IncomingHttpHeaders | null
+    rawTrailers?: Buffer[] | string[] | IncomingHttpHeaders | null
     abort(reason: Error): void
     pause(): void
     resume(): void
@@ -231,30 +223,12 @@ declare namespace Dispatcher {
     onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
     onResponseError?(controller: DispatchController, error: Error): void;
 
-    /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
-    /** @deprecated */
-    onConnect?(abort: (err?: Error) => void): void;
-    /** Invoked when an error has occurred. */
-    /** @deprecated */
-    onError?(err: Error): void;
-    /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
-    /** @deprecated */
-    onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
     /** Invoked when response is received, before headers have been read. **/
-    /** @deprecated */
     onResponseStarted?(): void;
-    /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
-    /** @deprecated */
-    onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
-    /** Invoked when response payload data is received. */
-    /** @deprecated */
-    onData?(chunk: Buffer): boolean;
-    /** Invoked when response payload and trailers have been received and the request has completed. */
-    /** @deprecated */
-    onComplete?(trailers: string[] | null): void;
     /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
-    /** @deprecated */
-    onBodySent?(chunkSize: number, totalBytesSent: number): void;
+    onBodySent?(chunk: Buffer): void;
+    /** Invoked after the request body is fully sent. */
+    onRequestSent?(): void;
   }
   export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable
   export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>

package/node_modules/undici-types/dispatcher1-wrapper.d.ts

@@ -0,0 +1,7 @@
+import Dispatcher from './dispatcher'
+
+export default Dispatcher1Wrapper
+
+declare class Dispatcher1Wrapper extends Dispatcher {
+  constructor (dispatcher: Dispatcher)
+}