@openclaw/slack 2026.9.6 → 2026.9.8

package/node_modules/typebox/build/schema/pointer/pointer.mjs

@@ -1,106 +1,89 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Asserts
+// Throw
 // ------------------------------------------------------------------
-function AssertNotRoot(indices) {
-    if (indices.length === 0)
-        throw Error('Cannot set root');
+function Throw(message) {
+    throw Error(message);
 }
-function AssertCanSet(value) {
-    if (!Guard.IsObject(value))
-        throw Error('Cannot set value');
+function ThrowUnsafePropertyKey() {
+    Throw('Pointer contains unsafe property key');
 }
-function AssertIndex(index) {
-    if (Guard.IsUnsafePropertyKey(index))
-        throw Error('Pointer contains unsafe property key');
-}
-function AssertIndices(indices) {
-    for (const index of indices)
-        AssertIndex(index);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-function IsNumericIndex(index) {
-    return /^(0|[1-9]\d*)$/.test(index);
-}
-function TakeIndexRight(indices) {
-    return [
-        indices.slice(0, indices.length - 1),
-        indices.slice(indices.length - 1)[0]
-    ];
-}
-function HasIndex(index, value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
-}
-function GetIndex(index, value) {
-    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
-}
-function GetIndices(indices, value) {
-    return indices.reduce((value, index) => GetIndex(index, value), value);
+function ThrowCannotSetRoot() {
+    Throw('Cannot set value');
 }
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
-/** Returns an array of path indices for the given pointer */
 export function Indices(pointer) {
-    if (Guard.IsEqual(pointer.length, 0))
-        return [];
-    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
+    return indices[0] === '' ? indices.slice(1) : indices;
 }
 // ------------------------------------------------------------------
 // Has
 // ------------------------------------------------------------------
-/** Returns true if a value exists at the current pointer */
 export function Has(value, pointer) {
     let current = value;
-    return Indices(pointer).every(index => {
-        if (!HasIndex(index, current))
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
             return false;
         current = current[index];
-        return true;
-    });
+    }
+    return true;
 }
 // ------------------------------------------------------------------
 // Get
 // ------------------------------------------------------------------
-/** Gets a value at the pointer, or undefined if not exists */
 export function Get(value, pointer) {
-    const indices = Indices(pointer);
-    return GetIndices(indices, value);
+    let current = value;
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
+            return undefined;
+        current = current[index];
+    }
+    return current;
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+function Parent(value, indices, last) {
+    let current = value;
+    for (const index of indices) {
+        if (Guard.IsUnsafePropertyKey(index))
+            ThrowUnsafePropertyKey();
+        current = Guard.IsObject(current) ? current[index] : undefined;
+    }
+    if (Guard.IsUnsafePropertyKey(last))
+        ThrowUnsafePropertyKey();
+    if (!Guard.IsObject(current))
+        ThrowCannotSetRoot();
+    return current;
 }
 // ------------------------------------------------------------------
 // Set
 // ------------------------------------------------------------------
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    parent[index] = next;
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    Parent(value, indices, last)[last] = next;
     return value;
 }
 // ------------------------------------------------------------------
 // Delete
 // ------------------------------------------------------------------
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
-        parent.splice(+index, 1);
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    const parent = Parent(value, indices, last);
+    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
+        parent.splice(Number(last), 1);
     }
     else {
-        delete parent[index];
+        delete parent[last];
     }
     return value;
 }

package/node_modules/typebox/build/system/settings/internal.d.mts

@@ -0,0 +1,2 @@
+export declare function EnableParseErrors(): void;
+export declare function DisableParseErrors(): void;

package/node_modules/typebox/build/system/settings/internal.mjs

@@ -0,0 +1,20 @@
+import { Get } from './settings.mjs';
+// ------------------------------------------------------------------
+// TempMaxErrors
+// ------------------------------------------------------------------
+let TempMaxErrors = 0;
+// ------------------------------------------------------------------
+// [Internal] EnableParseErrors
+// ------------------------------------------------------------------
+export function EnableParseErrors() {
+    const settings = Get();
+    TempMaxErrors = settings.maxErrors;
+    settings.maxErrors = settings.maxParseErrors;
+}
+// ------------------------------------------------------------------
+// [Internal] DisableParseErrors
+// ------------------------------------------------------------------
+export function DisableParseErrors() {
+    const settings = Get();
+    settings.maxErrors = TempMaxErrors;
+}

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -16,6 +16,17 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
+     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
+     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
+     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
+     * errors are needed. The default setting of 1 will terminate on the first error, while a
+     * setting of 0 will skip error gathering entirely.
+     *
+     * @default 1
+     */
+    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,8 +1,12 @@
 import { Guard } from '../../guard/index.mjs';
+// -------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -10,10 +14,14 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
+// -------------------------------------------------------------------
+// Reset
+// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -21,6 +29,9 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
+// -------------------------------------------------------------------
+// Set
+// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -30,6 +41,9 @@ export function Set(options) {
         }
     }
 }
+// -------------------------------------------------------------------
+// Get
+// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;

package/node_modules/typebox/build/type/extends/inference.d.mts

@@ -22,7 +22,7 @@ export declare function TryRestInferable<Type extends TSchema>(type: Type): TTry
 export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
 export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
 type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
-declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right): TryInferResults<Rest, Right>;
 export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
     [_ in Name]: TTuple<Results>;
 }>> : Result.TExtendsFalse);

package/node_modules/typebox/build/type/extends/inference.mjs

@@ -45,8 +45,21 @@ export function TryInferable(type) {
     return (IsInfer(type) ? Inferrable(type.name, type.extends) :
         undefined);
 }
-function TryInferResults(rest, right, result = []) {
-    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+// function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result: TSchema[] = []): TryInferResults<Rest, Right> {
+//   return Guard.ShiftLeft(rest, (head, tail) =>
+//     Result.Match(ExtendsLeft({}, head, right),
+//       () => TryInferResults(tail, right, [...result, head]), // Stack Overflow Here (Large Rest)
+//       () => undefined),
+//     () => result) as never
+// }
+function TryInferResults(rest, right) {
+    const result = [];
+    for (const head of rest) {
+        if (!Result.IsExtendsTrueLike(ExtendsLeft({}, head, right)))
+            return undefined;
+        result.push(head);
+    }
+    return result;
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -16,7 +16,8 @@ type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftR
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
 type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
-type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArrayReduce<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : TExtendsTupleToArrayReduce<Inferred, Left, Right>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -47,11 +47,31 @@ function ExtendsTupleToTuple(inferred, left, right) {
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
+// function ExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>
+//   (inferred: Inferred, left: [...Left], right: Right):
+//     TExtendsTupleToArrayReduce<Inferred, Left, Right> {
+//   return (
+//     Guard.ShiftLeft(left, (head, tail) =>
+//       Result.Match(ExtendsLeft(inferred, head, right), inferred =>
+//         ExtendsTupleToArrayReduce(inferred, tail, right), // Stack Overflow Here (Large Left)
+//         () => Result.ExtendsFalse()),
+//       () => Result.ExtendsTrue(inferred))
+//   ) as never
+// }
+function ExtendsTupleToArrayReduce(inferred, left, right) {
+    for (const head of left) {
+        const result = ExtendsLeft(inferred, head, right);
+        if (!Result.IsExtendsTrueLike(result))
+            return result;
+        inferred = result.inferred; // (review-assign-to-argument)
+    }
+    return Result.ExtendsTrue(inferred);
+}
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : ExtendsTupleToArrayReduce(inferred, left, right));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/node_modules/typebox/build/value/parse/parse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { Settings } from '../../system/system.mjs';
-import { Arguments } from '../../system/arguments/index.mjs';
+import { EnableParseErrors, DisableParseErrors } from '../../system/settings/internal.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -18,8 +18,11 @@ export class ParseError extends AssertError {
     }
 }
 function Assert(context, type, value) {
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
     if (!Check(context, type, value))
-        throw new ParseError(value, Errors(context, type, value));
+        throw new ParseError(value, errors);
     return value;
 }
 // ------------------------------------------------------------------
@@ -43,5 +46,8 @@ export function Parse(...args) {
         return value;
     if (Settings.Get().correctiveParse)
         return Parser(context, type, value);
-    throw new ParseError(value, Errors(context, type, value));
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
+    throw new ParseError(value, errors);
 }

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.30",
+  "version": "1.3.34",
   "keywords": [
     "typescript",
     "jsonschema"

package/node_modules/typebox/readme.md

@@ -166,9 +166,11 @@ import Schema from 'typebox/schema'
 
 ### Compile
 
-The compiler accepts both TypeBox types and plain JSON Schema objects. The Compile function will return a new Validator instance which can be used to check and parse values. The example below compiles a Script definition into a validator.
+The compiler accepts TypeBox types as well as plain JSON Schema objects, and returns a Validator instance which can be used to check values. The following compiles a Vector type.
 
 ```typescript
+import Schema from 'typebox/schema'
+
 // Compile
 
 const Vector = Schema.Compile(Type.Script(`{

package/node_modules/undici/README.md

@@ -21,28 +21,65 @@ npm i undici
 
 ## Benchmarks
 
-The benchmark is a simple getting data [example](https://github.com/nodejs/undici/blob/main/benchmarks/benchmark.js) using a
-50 TCP connections with a pipelining depth of 10 running on Node 22.11.0.
+The benchmark is a simple getting data [example](https://github.com/nodejs/undici/blob/main/benchmarks/benchmark.js) using
+50 TCP connections with a pipelining depth of 10 running on Node 24.14.1.
+
+### HTTP/1.1
 
 ```
 ┌────────────────────────┬─────────┬────────────────────┬────────────┬─────────────────────────┐
 │  Tests                 │ Samples │ Result             │ Tolerance  │ Difference with slowest │
 ├────────────────────────┼─────────┼────────────────────┼────────────┼─────────────────────────┤
-│  'axios'               │ 15      │ '5708.26 req/sec'  │ '± 2.91 %' │ '-'                     │
-│  'http - no keepalive' │ 10      │ '5809.80 req/sec'  │ '± 2.30 %' │ '+ 1.78 %'              │
-│  'request'             │ 30      │ '5828.80 req/sec'  │ '± 2.91 %' │ '+ 2.11 %'              │
-│  'undici - fetch'      │ 40      │ '5903.78 req/sec'  │ '± 2.87 %' │ '+ 3.43 %'              │
-│  'node-fetch'          │ 10      │ '5945.40 req/sec'  │ '± 2.13 %' │ '+ 4.15 %'              │
-│  'got'                 │ 35      │ '6511.45 req/sec'  │ '± 2.84 %' │ '+ 14.07 %'             │
-│  'http - keepalive'    │ 65      │ '9193.24 req/sec'  │ '± 2.92 %' │ '+ 61.05 %'             │
-│  'superagent'          │ 35      │ '9339.43 req/sec'  │ '± 2.95 %' │ '+ 63.61 %'             │
-│  'undici - pipeline'   │ 50      │ '13364.62 req/sec' │ '± 2.93 %' │ '+ 134.13 %'            │
-│  'undici - stream'     │ 95      │ '18245.36 req/sec' │ '± 2.99 %' │ '+ 219.63 %'            │
-│  'undici - request'    │ 50      │ '18340.17 req/sec' │ '± 2.84 %' │ '+ 221.29 %'            │
-│  'undici - dispatch'   │ 40      │ '22234.42 req/sec' │ '± 2.94 %' │ '+ 289.51 %'            │
+│  'node-fetch'          │ 50      │ '4711.86 req/sec'  │ '± 2.92 %' │ '-'                     │
+│  'undici - fetch'      │ 75      │ '5438.50 req/sec'  │ '± 2.97 %' │ '+ 15.42 %'             │
+│  'axios'               │ 45      │ '5448.08 req/sec'  │ '± 2.98 %' │ '+ 15.62 %'             │
+│  'request'             │ 65      │ '5809.63 req/sec'  │ '± 2.90 %' │ '+ 23.30 %'             │
+│  'http - no keepalive' │ 35      │ '5910.77 req/sec'  │ '± 2.87 %' │ '+ 25.44 %'             │
+│  'got'                 │ 50      │ '6047.80 req/sec'  │ '± 2.91 %' │ '+ 28.35 %'             │
+│  'superagent'          │ 60      │ '7534.53 req/sec'  │ '± 2.97 %' │ '+ 59.91 %'             │
+│  'http - keepalive'    │ 75      │ '9343.41 req/sec'  │ '± 2.90 %' │ '+ 98.30 %'             │
+│  'undici - pipeline'   │ 65      │ '13470.70 req/sec' │ '± 2.93 %' │ '+ 185.89 %'            │
+│  'undici - request'    │ 80      │ '16850.87 req/sec' │ '± 2.93 %' │ '+ 257.63 %'            │
+│  'undici - stream'     │ 101     │ '18488.56 req/sec' │ '± 3.81 %' │ '+ 292.38 %'            │
+│  'undici - dispatch'   │ 101     │ '20786.44 req/sec' │ '± 3.08 %' │ '+ 341.15 %'            │
 └────────────────────────┴─────────┴────────────────────┴────────────┴─────────────────────────┘
 ```
 
+### HTTP/1.1 over HTTPS
+
+Using [benchmark-https.js](https://github.com/nodejs/undici/blob/main/benchmarks/benchmark-https.js) against an h1-over-TLS server (50 connections, pipelining depth 10, Node 24.14.1).
+
+```
+┌────────────────────────┬─────────┬───────────────────┬────────────┬─────────────────────────┐
+│  Tests                 │ Samples │ Result            │ Tolerance  │ Difference with slowest │
+├────────────────────────┼─────────┼───────────────────┼────────────┼─────────────────────────┤
+│  'https - no keepalive'│ 10      │ '1358.40 req/sec' │ '± 1.99 %' │ '-'                     │
+│  'undici - fetch'      │ 30      │ '3721.76 req/sec' │ '± 2.97 %' │ '+ 173.98 %'            │
+│  'https - keepalive'   │ 35      │ '5633.91 req/sec' │ '± 2.84 %' │ '+ 314.75 %'            │
+│  'undici - pipeline'   │ 15      │ '6254.05 req/sec' │ '± 2.80 %' │ '+ 360.40 %'            │
+│  'undici - request'    │ 25      │ '6669.80 req/sec' │ '± 2.73 %' │ '+ 391.01 %'            │
+│  'undici - stream'     │ 25      │ '7019.04 req/sec' │ '± 2.77 %' │ '+ 416.71 %'            │
+│  'undici - dispatch'   │ 20      │ '7361.85 req/sec' │ '± 2.90 %' │ '+ 441.95 %'            │
+└────────────────────────┴─────────┴───────────────────┴────────────┴─────────────────────────┘
+```
+
+### HTTP/2
+
+Using [benchmark-http2.js](https://github.com/nodejs/undici/blob/main/benchmarks/benchmark-http2.js) against an h2 server (50 connections, pipelining depth 10, Node 24.14.1).
+
+```
+┌────────────────────────┬─────────┬───────────────────┬────────────┬─────────────────────────┐
+│  Tests                 │ Samples │ Result            │ Tolerance  │ Difference with slowest │
+├────────────────────────┼─────────┼───────────────────┼────────────┼─────────────────────────┤
+│  'undici - fetch'      │ 45      │ '3499.03 req/sec' │ '± 2.93 %' │ '-'                     │
+│  'native - http2'      │ 25      │ '4904.58 req/sec' │ '± 2.81 %' │ '+ 40.17 %'             │
+│  'undici - pipeline'   │ 60      │ '5836.82 req/sec' │ '± 2.99 %' │ '+ 66.81 %'             │
+│  'undici - request'    │ 65      │ '6831.25 req/sec' │ '± 2.83 %' │ '+ 95.23 %'             │
+│  'undici - stream'     │ 55      │ '6874.30 req/sec' │ '± 2.91 %' │ '+ 96.46 %'             │
+│  'undici - dispatch'   │ 55      │ '7791.23 req/sec' │ '± 2.96 %' │ '+ 122.67 %'            │
+└────────────────────────┴─────────┴───────────────────┴────────────┴─────────────────────────┘
+```
+
 ## Undici vs. Fetch
 
 ### Overview
@@ -200,7 +237,9 @@ await fetch('https://example.com', {
 ```
 
 `install()` replaces the global `fetch`, `Headers`, `Response`, `Request`, and
-`FormData` implementations with undici's versions, so they all match.
+`FormData` implementations with undici's versions, so they all match. It also
+installs undici's `WebSocket`, `CloseEvent`, `ErrorEvent`, `MessageEvent`, and
+`EventSource` globals.
 
 Avoid mixing a global `FormData` with `undici.fetch()`, or `undici.FormData`
 with the built-in global `fetch()`.
@@ -283,12 +322,12 @@ const data2 = await getData();
 
 ## Global Installation
 
-Undici provides an `install()` function to add all WHATWG fetch classes to `globalThis`, making them available globally:
+Undici provides an `install()` function to add fetch-related and other web API classes to `globalThis`, making them available globally:
 
 ```js
 import { install } from 'undici'
 
-// Install all WHATWG fetch classes globally
+// Install undici's global web APIs
 install()
 
 // Now you can use fetch classes globally without importing
@@ -316,8 +355,9 @@ The `install()` function adds the following classes to `globalThis`:
 
 When you call `install()`, these globals come from the same undici
 implementation. For example, global `fetch` and global `FormData` will both be
-undici's versions, which is the recommended setup if you want to use undici
-through globals.
+undici's versions, and `WebSocket` and `EventSource` will also come from
+undici, which is the recommended setup if you want to use undici through
+globals.
 
 This is useful for:
 - Polyfilling environments that don't have fetch
@@ -337,6 +377,9 @@ The `body` mixins are the most common way to format the request/response body. M
 > [!NOTE]
 > The body returned from `undici.request` does not implement `.formData()`.
 
+> [!WARNING]
+> Calling `body.formData()` on a fetch response causes undici to buffer and parse the entire body. Since this is dictated by the spec, `body.formData()` must only be called on responses from trusted servers.
+
 Example usage:
 
 ```js
@@ -365,6 +408,11 @@ For more information about their behavior, please reference the body mixin from
 
 This section documents our most commonly used API methods. Additional APIs are documented in their own files within the [docs](./docs/) folder and are accessible via the navigation list on the left side of the docs site.
 
+For the top-level APIs below, the `url` argument supplies the request origin and
+path. Do not pass `origin` or `path` in the second `options` argument. The linked
+`Dispatcher` option types include those fields because dispatcher methods are
+lower-level APIs that do not receive a separate `url` argument.
+
 ### `undici.request([url, options]): Promise`
 
 Arguments:
@@ -619,6 +667,12 @@ See [Dispatcher.upgrade](./docs/docs/api/Dispatcher.md#dispatcherupgradeoptions-
 Sets the global dispatcher used by Common API Methods. Global dispatcher is shared among compatible undici modules,
 including undici that is bundled internally with node.js.
 
+Undici stores this dispatcher under `Symbol.for('undici.globalDispatcher.2')`.
+
+`setGlobalDispatcher()` also mirrors the configured dispatcher to
+`Symbol.for('undici.globalDispatcher.1')` using `Dispatcher1Wrapper`, so Node.js built-in `fetch`
+can keep using the legacy handler contract while Undici uses the new handler API.
+
 ### `undici.getGlobalDispatcher()`
 
 Gets the global dispatcher used by Common API Methods.
@@ -668,8 +722,9 @@ Refs: https://tools.ietf.org/html/rfc7231#section-5.1.1
 #### Pipelining
 
 Undici will only use pipelining if configured with a `pipelining` factor
-greater than `1`. Also it is important to pass `blocking: false` to the
-request options to properly pipeline requests.
+greater than `1`. Only enable pipelining when the remote server is trusted.
+Also it is important to pass `blocking: false` to the request options to
+properly pipeline requests.
 
 Undici always assumes that connections are persistent and will immediately
 pipeline requests, without checking whether the connection is persistent.
@@ -731,10 +786,11 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 Undici aligns with the Node.js LTS schedule. The following table shows the supported versions:
 
 | Undici Version | Bundled in Node.js | Node.js Versions Supported | End of Life |
-|----------------|-------------------|----------------------------|-------------|
-| 5.x           | 18.x              | ≥14.0 (tested: 14, 16, 18) | 2024-04-30  |
-| 6.x           | 20.x, 22.x       | ≥18.17 (tested: 18, 20, 21, 22) | 2026-04-30  |
-| 7.x           | 24.x              | ≥20.18.1 (tested: 20, 22, 24) | 2027-04-30  |
+|----------------|--------------------|----------------------------|-------------|
+| 5.x            | 18.x               | ≥14.0 (tested: 14, 16, 18) | 2024-04-30  |
+| 6.x            | 20.x, 22.x         | ≥18.17 (tested: 18, 20, 21, 22) | 2027-04-30  |
+| 7.x            | 24.x               | ≥20.18.1 (tested: 20, 22, 24) | 2028-04-30  |
+| 8.x            | 26.x               | ≥22.19.0 (tested: 22, 24, 26) | 2029-04-30  |
 
 ## License