@openclaw/slack 2026.10.10-beta.5 → 2026.11.5-beta.1

package/node_modules/typebox/build/type/engine/evaluate/property.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { IsOptional } from '../../types/_optional.mjs';
+import { IsReadonly } from '../../types/_readonly.mjs';
+import { AddOptionalAction } from '../optional/instantiate_add.mjs';
+import { AddReadonlyAction } from '../readonly/instantiate_add.mjs';
+import { RemoveOptionalAction } from '../optional/instantiate_remove.mjs';
+import { RemoveReadonlyAction } from '../readonly/instantiate_remove.mjs';
+import { EvaluateIntersect, EvaluateUnion } from './evaluate.mjs';
+export function EvaluatePropertyIntersect(left, right) {
+    const isReadonly = IsReadonly(left) && IsReadonly(right);
+    const isOptional = IsOptional(left) && IsOptional(right);
+    const evaluated = EvaluateIntersect([left, right]);
+    const property = RemoveReadonlyAction(RemoveOptionalAction(evaluated, {}), {});
+    return (isReadonly && isOptional ? AddReadonlyAction(AddOptionalAction(property, {}), {}) :
+        isReadonly ? AddReadonlyAction(property, {}) :
+            isOptional ? AddOptionalAction(property, {}) :
+                property);
+}
+export function EvaluatePropertyUnion(left, right) {
+    const isReadonly = IsReadonly(left) || IsReadonly(right);
+    const isOptional = IsOptional(left) || IsOptional(right);
+    const leftProperty = RemoveReadonlyAction(RemoveOptionalAction(left, {}), {});
+    const rightProperty = RemoveReadonlyAction(RemoveOptionalAction(right, {}), {});
+    const property = EvaluateUnion([leftProperty, rightProperty]);
+    return (isReadonly && isOptional ? AddReadonlyAction(AddOptionalAction(property, {}), {}) :
+        isReadonly ? AddReadonlyAction(property, {}) :
+            isOptional ? AddOptionalAction(property, {}) :
+                property);
+}

package/node_modules/typebox/build/type/engine/immutable/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TImmutable } from '../../types/_immutable.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddImmutableOperation<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
-export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = TAddImmutableOperation<Type>> = Result;
+export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
 export declare function AddImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddImmutableAction<Type>;
 export type TAddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddImmutableAction<InstantiateType>;
 export declare function AddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddImmutableInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/immutable/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddImmutableOperation(type) {
-    return Memory.Update(type, { '~immutable': true }, {});
-}
 export function AddImmutableAction(type, options) {
-    const result = Memory.Update(AddImmutableOperation(type), {}, options);
+    const result = Memory.Update(type, { '~immutable': true }, options);
     return result;
 }
 export function AddImmutableInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/object/from_intersect.d.mts

@@ -2,13 +2,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TFromType } from './from_type.mjs';
-import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluatePropertyIntersect } from '../evaluate/property.mjs';
 type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>, LeftProperties extends TProperties = {
     [Key in LeftKeys]: Left[Key];
 }, RightProperties extends TProperties = {
     [Key in RightKeys]: Right[Key];
 }, SharedProperties extends TProperties = {
-    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
+    [Key in SharedKeys]: TEvaluatePropertyIntersect<Left[Key], Right[Key]>;
 }, Unique extends TProperties = Memory.TAssign<LeftProperties, RightProperties>, Shared extends TProperties = Memory.TAssign<Unique, SharedProperties>> = Shared;
 export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
     [Key in keyof Result]: Result[Key];

package/node_modules/typebox/build/type/engine/object/from_intersect.mjs

@@ -3,14 +3,14 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { FromType } from './from_type.mjs';
-import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { EvaluatePropertyIntersect } from '../evaluate/property.mjs';
 function CollapseIntersectProperties(left, right) {
     const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));
     const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key));
     const sharedKeys = Guard.Keys(left).filter((key) => Guard.HasPropertyKey(right, key));
     const leftProperties = leftKeys.reduce((result, key) => ({ ...result, [key]: left[key] }), {});
     const rightProperties = rightKeys.reduce((result, key) => ({ ...result, [key]: right[key] }), {});
-    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluateIntersect([left[key], right[key]]) }), {});
+    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluatePropertyIntersect(left[key], right[key]) }), {});
     const unique = Memory.Assign(leftProperties, rightProperties);
     const shared = Memory.Assign(unique, sharedProperties);
     return shared;

package/node_modules/typebox/build/type/engine/object/from_union.d.mts

@@ -1,10 +1,10 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluatePropertyUnion } from '../evaluate/property.mjs';
 import { type TFromType } from './from_type.mjs';
 type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
-    [Key in SharedKeys]: TEvaluateUnion<[Left[Key], Right[Key]]>;
+    [Key in SharedKeys]: TEvaluatePropertyUnion<Left[Key], Right[Key]>;
 }> = Result;
 type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
 export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);

package/node_modules/typebox/build/type/engine/object/from_union.mjs

@@ -1,12 +1,12 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Unreachable } from '../../../system/unreachable/index.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluatePropertyUnion } from '../evaluate/property.mjs';
 import { FromType } from './from_type.mjs';
 function CollapseUnionProperties(left, right) {
     const sharedKeys = Guard.Keys(left).filter((key) => key in right);
     const result = sharedKeys.reduce((result, key) => {
-        return { ...result, [key]: EvaluateUnion([left[key], right[key]]) };
+        return { ...result, [key]: EvaluatePropertyUnion(left[key], right[key]) };
     }, {});
     return result;
 }

package/node_modules/typebox/build/type/engine/optional/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TOptional } from '../../types/_optional.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddOptionalOperation<Type extends TSchema, Result extends TSchema = `~optional` extends keyof Type ? Type : TOptional<Type>> = Result;
-export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = TAddOptionalOperation<Type>> = Result;
+export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
 export declare function AddOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddOptionalAction<Type>;
 export type TAddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddOptionalAction<InstantiateType>;
 export declare function AddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddOptionalInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/optional/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddOptionalOperation(type) {
-    return Memory.Update(type, { '~optional': true }, {});
-}
 export function AddOptionalAction(type, options) {
-    const result = Memory.Update(AddOptionalOperation(type), {}, options);
+    const result = Memory.Update(type, { '~optional': true }, options);
     return result;
 }
 export function AddOptionalInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TReadonly } from '../../types/_readonly.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddReadonlyOperation<Type extends TSchema, Result extends TSchema = `~readonly` extends keyof Type ? Type : TReadonly<Type>> = Result;
-export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = TAddReadonlyOperation<Type>> = Result;
+export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = '~readonly' extends keyof Type ? Type : TReadonly<Type>> = Result;
 export declare function AddReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddReadonlyAction<Type>;
 export type TAddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddReadonlyAction<InstantiateType>;
 export declare function AddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddReadonlyInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddReadonlyOperation(type) {
-    return Memory.Update(type, { '~readonly': true }, {});
-}
 export function AddReadonlyAction(type, options) {
-    const result = Memory.Update(AddReadonlyOperation(type), {}, options);
+    const result = Memory.Update(type, { '~readonly': true }, options);
     return result;
 }
 export function AddReadonlyInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/this/index.d.mts

@@ -0,0 +1 @@
+export * from './expand_this.mjs';

package/node_modules/typebox/build/type/engine/this/index.mjs

@@ -0,0 +1 @@
+export * from './expand_this.mjs';

package/node_modules/typebox/build/value/clone/clone.d.mts

@@ -1,5 +1,6 @@
 /**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
+ * Returns a deep Clone of the given value. This function is similar to `structuredClone()`,
+ * but also supports deep cloning `Map`, `Set`, and `TypeArray` instances. This function can also be used
+ * to clone TypeBox types while retaining their enumerable and non-enumerable properties.
  */
-export declare function Clone<Value extends unknown>(value: Value): Value;
+export declare function Clone<Value extends unknown = unknown>(value: Value): Value;

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

@@ -1,12 +1,10 @@
 // deno-fmt-ignore-file
-import { Clone as SystemClone } from '../../system/memory/clone.mjs';
-// ------------------------------------------------------------------
-// Clone
-// ------------------------------------------------------------------
+import { Deep } from '../../system/memory/deep.mjs';
 /**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
+ * Returns a deep Clone of the given value. This function is similar to `structuredClone()`,
+ * but also supports deep cloning `Map`, `Set`, and `TypeArray` instances. This function can also be used
+ * to clone TypeBox types while retaining their enumerable and non-enumerable properties.
  */
 export function Clone(value) {
-    return SystemClone(value);
+    return Deep(value);
 }

package/node_modules/typebox/build/value/repair/from_cyclic.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TCyclic } from '../../type/index.mjs';
+export declare function FromCyclic(context: TProperties, type: TCyclic, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_cyclic.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Ref } from '../../type/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromCyclic(context, type, value) {
+    return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
+}

package/node_modules/typebox/build/value/shared/union_priority_sort.mjs

@@ -1,28 +1,27 @@
 // deno-fmt-ignore-file
 import Guard from '../../guard/index.mjs';
-import { IsArray, Array as _Array_, ArrayOptions } from '../../type/index.mjs';
-import { IsUnion, Union } from '../../type/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { Array as _Array_, ArrayOptions, IsArray } from '../../type/index.mjs';
+import { Intersect, IsIntersect } from '../../type/index.mjs';
 import { IsObject, Object as _Object_ } from '../../type/index.mjs';
-import { IsRecord, Record, RecordKey, RecordValue } from '../../type/index.mjs';
+import { IsRecord, Record, RecordPattern, RecordValue } from '../../type/index.mjs';
+import { String } from '../../type/index.mjs';
 import { IsTuple, Tuple } from '../../type/index.mjs';
-import { IsIntersect, Intersect } from '../../type/index.mjs';
+import { IsUnion, Union } from '../../type/index.mjs';
 import { Priority } from '../../type/index.mjs';
 // ------------------------------------------------------------------
 // Modifiers (Mutable)
 //
 // Prioritized types lose `~modifier` properties and additional constraints
 // (e.g. additionalProperties) during the mapping phase and need to be
-// reassigned afterward. This is a fast mutable assignment to handle that,
-// but we should consider a more general solution. (review)
+// reassigned afterward. We previously used a mutable assignment on this
+// function, however `immutableTypes: true` caused errors. We use the 
+// Memory.Assign to ensure modifiers are retained and we preserve type
+// configurations (review)
 //
 // ------------------------------------------------------------------
 function Modifiers(type, next) {
-    for (const key of Guard.Keys(type)) {
-        if (Guard.HasPropertyKey(next, key))
-            continue;
-        next[key] = type[key];
-    }
-    return next;
+    return Memory.Assign(type, next);
 }
 // ------------------------------------------------------------------
 // Properties
@@ -34,6 +33,18 @@ function FromProperties(properties) {
     return result;
 }
 // ------------------------------------------------------------------
+// FromRecordKey
+//
+// This is required because RecordKey(...) returns a canonical
+// decoded type derived from the pattern. When the pattern is an
+// unrecognized user-defined one, the result falls through to
+// TString (^.*$) and the user-defined pattern is lost. This
+// function ensures the exact pattern is retained.
+// ------------------------------------------------------------------
+function FromRecordKey(type) {
+    return String({ pattern: RecordPattern(type) });
+}
+// ------------------------------------------------------------------
 // PriorityTypes
 // ------------------------------------------------------------------
 function FromPriorityTypes(types) {
@@ -43,7 +54,7 @@ function FromPriorityTypes(types) {
 // Types
 // ------------------------------------------------------------------
 function FromTypes(types) {
-    return types.map(type => FromType(type));
+    return types.map((type) => FromType(type));
 }
 // ------------------------------------------------------------------
 // Type
@@ -53,7 +64,7 @@ function FromType(type) {
         IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
             IsUnion(type) ? Union(FromPriorityTypes(type.anyOf)) :
                 IsObject(type) ? _Object_(FromProperties(type.properties)) :
-                    IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                    IsRecord(type) ? Record(FromRecordKey(type), FromType(RecordValue(type))) :
                         IsTuple(type) ? Tuple(FromTypes(type.items)) :
                             type);
     return Modifiers(type, next);

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.35",
+  "version": "1.4.2",
   "keywords": [
     "typescript",
     "jsonschema"

package/node_modules/typebox/readme.md

@@ -196,7 +196,7 @@ const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {
 
 [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) | [JSON Schema Compliance Suite](https://github.com/sinclairzx81/json-schema-compliance-suite)
 
-TypeBox supports all versions of JSON Schema and is heavily tested against the official JSON Schema Test Suite. It prioritizes compatibility with modern specifications while also maintaining broad support for legacy versions provided their semantics are not in conflict with modern specifications.
+TypeBox supports all versions of JSON Schema and is heavily tested against the official JSON Schema Test Suite. It has high compatibility with modern specifications while also offering broad support for legacy versions if their semantics are not in conflict with modern specifications.
 
 | Spec | 3 | 4 | 6 | 7 | 2019-09 | 2020-12 | v1 |
 |:-----|:--|:--|:--|:--|:--|:--|:--|

package/node_modules/undici/README.md

@@ -86,6 +86,24 @@ Using [benchmark-http2.js](https://github.com/nodejs/undici/blob/main/benchmarks
 
 Node.js includes a built-in `fetch()` implementation powered by undici starting from Node.js v18. However, there are important differences between using the built-in fetch and installing undici as a separate module.
 
+### WebAssembly requirement
+
+Undici's HTTP/1 parser requires WebAssembly. There is no alternative parser when
+WebAssembly is unavailable, for example in Node.js configurations where
+`--jitless` disables it. The existence of `fetch` does not imply that it can make
+HTTP/1 requests in that environment.
+
+When the HTTP/1 parser is needed without WebAssembly, Client and dispatcher
+requests fail with an `Error` whose code is `ERR_WEBASSEMBLY_NOT_SUPPORTED`.
+`fetch` rejects with a `TypeError` carrying that error in `error.cause`. Importing
+Undici, accessing `fetch`, and using `Headers`, `FormData`, `Request`, or `Response`
+do not themselves require the HTTP/1 parser.
+
+The error is defined locally in Undici and does not depend on Node.js providing
+that error code. For built-in fetch, this behavior depends on the bundled Undici
+version. Node.js receives upstream fixes through its normal vendored Undici
+update, rather than changes to the generated bundle alone.
+
 ### Built-in Fetch (Node.js v18+)
 
 Node.js's built-in fetch is powered by a bundled version of undici:
@@ -773,14 +791,18 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 
 ## Collaborators
 
-* [__Daniele Belardi__](https://github.com/dnlup), <https://www.npmjs.com/~dnlup>
-* [__Ethan Arrowood__](https://github.com/ethan-arrowood), <https://www.npmjs.com/~ethan_arrowood>
+* [__Aras Abbasi__](https://github.com/Uzlopak)
+* [__Carlos Fuentes__](https://github.com/metcoder95), <https://www.npmjs.com/~metcoder95>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood), <https://www.npmjs.com/~ethan_arrowood>
 * [__Matteo Collina__](https://github.com/mcollina), <https://www.npmjs.com/~matteo.collina>
 * [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
+* [__Mert Can Altin__](https://github.com/mertcanaltin), <https://www.npmjs.com/~mertcanaltin>
 * [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
-* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
+* [__Trivikram Kamat__](https://github.com/trivikr), <https://www.npmjs.com/~trivikr>
+* [__tsctx__](https://github.com/tsctx)
 
 ## Past Collaborators
+* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
 * [__Tomas Della Vedova__](https://github.com/delvedor), <https://www.npmjs.com/~delvedor>
 
 ### Releasers

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

@@ -42,7 +42,8 @@ added: v7.0.0
 Stores cached responses in memory. The store enforces upper bounds on the total
 number of responses, the total size of all responses, and the size of any single
 response. When a limit is exceeded, the store evicts approximately half of its
-entries and emits a [`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
+entries, least recently used first, and emits a
+[`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -163,7 +164,9 @@ added: v7.0.0
 -->
 
 Stores cached responses in a SQLite database using the [`node:sqlite`][] API.
-The constructor throws when [`node:sqlite`][] is not available.
+The constructor throws when [`node:sqlite`][] is not available. Response bodies
+larger than `compressThreshold` are stored compressed with zstd and
+decompressed when read back, saving database space.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -189,9 +192,16 @@ added: v7.0.0
   * `maxEntrySize` {number} The maximum size, in bytes, of a single response
     body. Responses whose body exceeds this value are not cached. Must not
     exceed `2000000000` (2 GB). **Default:** `2000000000` (2 GB).
+  * `compressThreshold` {number} The size, in bytes, above which a response
+    body is stored compressed with zstd. Responses with an easily compressible
+    Content-Type (e.g. json, xml, plain text) are compressed regardless of
+    size. Requires a Node version with zstd
+    support (22.19+); when unavailable, bodies are stored uncompressed.
+    **Default:** `1048576` (1 MiB).
 
-`maxCount` and `maxEntrySize` must be non-negative integers; a `TypeError` is
-thrown otherwise, or if `maxEntrySize` is greater than 2 GB.
+`maxCount`, `maxEntrySize`, and `compressThreshold` must be non-negative
+integers; a `TypeError` is thrown otherwise, or if `maxEntrySize` is greater
+than 2 GB.
 
 ### `sqliteCacheStore.close()`
 
@@ -225,7 +235,8 @@ added: v7.0.0
   See [`GetResult`](#getresult).
 
 Looks up a cached response for `key`, comparing the request method and every
-header named in the stored `vary` map.
+header named in the stored `vary` map. A body that was stored compressed is
+decompressed before being returned.
 
 ### `sqliteCacheStore.set(key, value)`
 
@@ -240,9 +251,11 @@ added: v7.0.0
 * Returns: {undefined}
 
 Writes a response into the database directly, without going through a stream. If
-the body exceeds `maxEntrySize`, nothing is stored. When an entry already exists
-for `key` it is overwritten; otherwise a new row is inserted and old entries are
-pruned to honour `maxCount`. This method is used internally by
+the body exceeds `maxEntrySize`, nothing is stored. A body larger than
+`compressThreshold`, or with an easily compressible Content-Type (e.g. json,
+xml, plain text), is compressed with zstd before being written. When an entry
+already exists for `key` it is overwritten; otherwise a new row is inserted and
+old entries are pruned to honour `maxCount`. This method is used internally by
 [`sqliteCacheStore.createWriteStream()`](#sqlitecachestorecreatewritestreamkey-value).
 
 ### `sqliteCacheStore.createWriteStream(key, value)`
@@ -260,7 +273,9 @@ added: v7.0.0
 
 Returns a {Writable} stream used to write the response body into the store. When
 the stream finishes, the buffered body is committed via
-[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value). If the body exceeds
+[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value), where bodies larger
+than `compressThreshold` or with an easily compressible Content-Type are
+compressed with zstd. If the body exceeds
 `maxEntrySize`, the stream is destroyed and nothing is stored.
 
 ### `sqliteCacheStore.delete(key)`

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

@@ -116,8 +116,8 @@ added: v1.0.0
   * `maxConcurrentStreams` {number} _Deprecated: use h2Options.useH2c instead_ The maximum number of concurrent HTTP/2
     streams for a single session. Once h2 is negotiated this — not `pipelining`,
     which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-    It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-    frame. **Default:** `100`.
+    The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+    not raise it. **Default:** `100`.
   * `connectionWindowSize` {number} _Deprecated: use h2Options.connectionWindowSize instead_ The HTTP/2 connection-level flow-control
     window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
     positive integer. **Default:** `524288`.
@@ -130,8 +130,8 @@ added: v1.0.0
     * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
       streams for a single session. Once h2 is negotiated this — not `pipelining`,
       which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-      It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-      frame. **Default:** `100`.
+      The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+      not raise it. **Default:** `100`.
     * `connectionWindowSize` {number} The HTTP/2 connection-level flow-control
       window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
       positive integer. **Default:** `524288`.
@@ -148,8 +148,13 @@ added: v1.0.0
       payloads, and decompressed (`permessage-deflate`) messages. Set to `0` to
       disable the limit. **Default:** `134217728`.
   * `eventSource` {Object} (optional) EventSource-specific configuration.
-    * `maxEventSize` {number} The maximum allowed event size, in bytes, for
-      EventSource messages. Set to `0` to disable the limit.
+    * `maxEventSize` {number} The maximum total bytes of data and metadata
+      field values retained for a pending EventSource event. Each unfinished
+      line is separately limited to this value plus seven syntax bytes, before
+      its line ending arrives. The number of `data:` lines per event and input
+      chunks buffered for an unfinished line are each limited to
+      `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead.
+      Set to `0` to disable these limits.
       **Default:** `buffer.kStringMaxLength`.
 * Returns: {Client}
 

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

@@ -209,6 +209,9 @@ added: v4.0.0
   * `path` {string} The request path.
   * `method` {string} The HTTP method, e.g. `'GET'` or `'POST'`.
   * `body` {string|Buffer|Uint8Array|Readable|FormData|null} The request body.
+    Undici's network clients require a `FormData` body created by the same
+    undici package instance. A body from another source, including Node.js's
+    built-in `FormData`, is rejected with an `InvalidArgumentError`.
     **Default:** `null`.
   * `headers` {UndiciHeaders} Request headers. **Default:** `null`.
   * `query` {Object} Query string parameters embedded into the request URL. Both

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

@@ -18,7 +18,7 @@ if (err instanceof errors.ConnectTimeoutError) {
 }
 ```
 
-All errors, except [`HTTPParserError`][], extend [`UndiciError`][]. Each error
+All errors, except [`HTTPParserError`][] and `WebAssemblyNotSupportedError`, extend [`UndiciError`][]. Each error
 carries a stable `code` string (for example `UND_ERR_CONNECT_TIMEOUT`) and a
 `name`.
 
@@ -32,6 +32,37 @@ if (err.code === 'UND_ERR_CONNECT_TIMEOUT') {
 }
 ```
 
+## Timeout-related errors
+
+The timeout errors below are controlled by dispatcher/client options:
+
+| Error code | When it is thrown | Related option |
+| ---------- | ----------------- | -------------- |
+| `UND_ERR_CONNECT_TIMEOUT` | A connection could not be established before the connection timeout elapsed. | [`connect.timeout`](Client.md) |
+| `UND_ERR_HEADERS_TIMEOUT` | The full response headers were not received before the headers timeout elapsed. | [`headersTimeout`](Client.md) |
+| `UND_ERR_BODY_TIMEOUT` | While reading the response body, no new data arrived before the body timeout elapsed. | [`bodyTimeout`](Client.md) |
+| `UND_ERR_SOCKET` | A generic socket-level failure happened. | Inspect `error.socket` for connection details. |
+
+### Configuring timeouts for `fetch`
+
+If you are using `fetch` (including Node.js built-in `fetch`), configure timeouts
+through the global dispatcher:
+
+```js
+import { Agent, setGlobalDispatcher, fetch } from 'undici'
+
+setGlobalDispatcher(new Agent({
+  connect: { timeout: 10_000 }, // connection phase
+  headersTimeout: 15_000, // wait for response headers
+  bodyTimeout: 30_000 // wait between response body chunks
+}))
+
+await fetch('https://example.com/data')
+```
+
+You can inspect timeout error codes from `error.code` or (for wrapped fetch
+errors) from `error.cause?.code`.
+
 ## Class: `UndiciError`
 
 <!-- YAML
@@ -52,6 +83,35 @@ on a well-known symbol rather than the prototype chain.
 * `name` {string} Always `'UndiciError'`.
 * `code` {string} Always `'UND_ERR'`.
 
+## Class: `WebAssemblyNotSupportedError`
+
+* Extends: {Error}
+
+WebAssembly is unavailable when Undici initializes its HTTP/1 parser. Undici does
+not provide an alternative parser for environments without WebAssembly, including
+Node.js configurations where `--jitless` disables it. The check is performed when
+the parser is needed, not when importing Undici or accessing `fetch`.
+
+* `name` {string} Always `'Error'`.
+* `code` {string} Always `'ERR_WEBASSEMBLY_NOT_SUPPORTED'`.
+* `message` {string} By default `'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing'`.
+
+Client and dispatcher requests report this error directly. `fetch` rejects with
+a `TypeError` whose `cause` is this error:
+
+```js
+try {
+  await fetch('http://localhost:3000')
+} catch (error) {
+  if (error.cause?.code === 'ERR_WEBASSEMBLY_NOT_SUPPORTED') {
+    // HTTP/1 parsing requires WebAssembly in this environment.
+  }
+}
+```
+
+`Headers`, `FormData`, `Request`, `Response`, and other operations that do not need
+the HTTP/1 parser remain usable without WebAssembly.
+
 ## Class: `ConnectTimeoutError`
 
 <!-- YAML
@@ -436,6 +496,7 @@ The response returned an error status code. This is raised, for example, when th
 * `code` {string} Always `'UND_ERR_RESPONSE'`.
 * `statusCode` {number} The HTTP status code of the response.
 * `body` {Object|string|null} The response body.
+* `bodyTruncated` {boolean} Whether `body` was truncated by a configured limit.
 * `headers` {Object|string[]|null} The response headers.
 
 ### `new ResponseError(message, code, options)`
@@ -445,6 +506,7 @@ The response returned an error status code. This is raised, for example, when th
 * `options` {Object}
   * `headers` {Object|string[]|null} The response headers. (optional)
   * `body` {Object|string|null} The response body. (optional)
+  * `bodyTruncated` {boolean} Whether `body` was truncated. **Default:** `false`.
 
 ## Class: `ProxyConnectionError`
 
@@ -512,6 +574,19 @@ The maximum number of allowed origins has been reached.
 * `name` {string} Always `'MaxOriginsReachedError'`.
 * `code` {string} Always `'UND_ERR_MAX_ORIGINS_REACHED'`.
 
+## Class: `MaxRedirectsError`
+
+<!-- YAML
+added: v8.12.0
+-->
+
+* Extends: {UndiciError}
+
+The maximum number of redirects has been reached.
+
+* `name` {string} Always `'MaxRedirectsError'`.
+* `code` {string} Always `'UND_ERR_REDIRECT_MAX'`.
+
 ## Class: `Socks5ProxyError`
 
 <!-- YAML

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

@@ -55,8 +55,9 @@ added: v7.7.0
   hostname, and port. Only the `http:` protocol is supported.
 * `options` {H2CClientOptions} (optional)
   * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
-    streams for the session. It is advertised to the server and may be overridden
-    by a remote `SETTINGS` frame. Must be a positive integer. **Default:** `100`.
+    streams for the session. The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can
+    lower this limit, but not raise it. Must be a positive integer.
+    **Default:** `100`.
   * `pipelining` {number} The number of concurrent requests multiplexed over the
     single connection. For an `H2CClient` this is aliased to
     `maxConcurrentStreams` and may not exceed it. Must be a positive integer.