@openclaw/slack 2026.11.3 → 2026.11.5-beta.2

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/docs/docs/api/Interceptors.md

@@ -341,8 +341,21 @@ backing store.
 
 **Parameters**
 
-* `opts` {CacheHandler.CacheOptions} (optional) See the
-  [`CacheStore`](./CacheStore.md) documentation for accepted fields.
+* `opts` {Object} (optional)
+  * `store` {CacheStore} The store that cached responses are kept in. See
+    [`CacheStore`](./CacheStore.md). **Default:** a new `MemoryCacheStore`.
+  * `methods` {string[]} The HTTP methods to cache. Only safe methods are
+    allowed (`GET`, `HEAD`, `OPTIONS`, `TRACE`) and at least one is required.
+    **Default:** `['GET']`.
+  * `cacheByDefault` {number} RFC 9111 allows caching responses that are not
+    explicitly marked as cacheable or not cacheable. Set this to cache such
+    responses. **Default:** `undefined`.
+  * `type` {string} Whether the cache is `'shared'` or `'private'`, which
+    decides how directives such as `s-maxage` and `private` are applied.
+    **Default:** `'shared'`.
+  * `origins` {(string|RegExp)[]} Only requests to these origins are cached.
+    Strings are compared case-insensitively. **Default:** `undefined` (all
+    origins are cached).
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}
 

package/node_modules/undici/lib/dispatcher/client-h2.js

@@ -61,6 +61,12 @@ const kRefusedStreamRetry = Symbol('refused stream retry')
 // event loop.
 const MAX_GOAWAY_REPLAY_ATTEMPTS = 1
 
+// Lower bound on how long a liveness PING may take to be acked. Stream
+// timeouts can be tiny (tens of ms), while an ack on a live connection can take
+// longer than that on a loaded event loop; without a floor a slow but healthy
+// connection would be torn down.
+const MIN_PROBE_TIMEOUT = 1e3
+
 let extractBody
 
 /** @type {import('http2')} */
@@ -277,6 +283,9 @@ function connectH2 (client, socket) {
     // Armed while the peer advertises MAX_CONCURRENT_STREAMS = 0 and we have
     // work that cannot start. See setNoStreamsTimeout.
     noStreamsTimeout: null,
+    // Armed while a PING checks whether the peer is still there after a
+    // stream timed out. See probeHttp2Session.
+    probeTimeout: null,
     // Sockets start out ref'd. Session ref/unref proxies to the socket, so a
     // single cached flag lets us skip redundant uv ref/unref calls, provided
     // every ref/unref of the session or its socket goes through
@@ -361,6 +370,11 @@ function connectH2 (client, socket) {
         return true
       }
 
+      // Do not open streams on a connection that may be dead.
+      if (session[kHTTP2SessionState].probeTimeout != null) {
+        return true
+      }
+
       if (client[kRunning] >= client[kMaxConcurrentStreams]) {
         return true
       }
@@ -494,6 +508,60 @@ function onNoStreamsTimeout (session) {
   resetHttp2Session(session, err)
 }
 
+// A stream timeout only resets that stream, unlike HTTP/1.1 which destroys the
+// socket. If the connection itself silently died (dropped by a NAT or load
+// balancer, a hung peer), every new stream would time out in turn and the
+// session would never be replaced. Ask the peer for a PING ack within the
+// timeout that just fired (but at least MIN_PROBE_TIMEOUT): if it answers, only
+// that request was slow; if not, drop the session so queued requests move to a
+// fresh connection.
+function probeHttp2Session (session, timeout) {
+  const state = session[kHTTP2SessionState]
+
+  if (state.probeTimeout != null || session.closed || session.destroyed) {
+    return
+  }
+
+  try {
+    session.ping(onHttp2ProbeAck.bind(session))
+  } catch {
+    // The session is going away on its own.
+    return
+  }
+
+  state.probeTimeout = setTimeout(onHttp2ProbeTimeout, Math.max(timeout, MIN_PROBE_TIMEOUT), session).unref()
+}
+
+function clearHttp2ProbeTimeout (session) {
+  const state = session[kHTTP2SessionState]
+
+  if (state?.probeTimeout != null) {
+    clearTimeout(state.probeTimeout)
+    state.probeTimeout = null
+  }
+}
+
+function onHttp2ProbeAck () {
+  if (this[kHTTP2SessionState].probeTimeout == null) {
+    return
+  }
+
+  clearHttp2ProbeTimeout(this)
+  this[kClient][kResume]()
+}
+
+function onHttp2ProbeTimeout (session) {
+  session[kHTTP2SessionState].probeTimeout = null
+
+  if (session.closed || session.destroyed) {
+    return
+  }
+
+  const err = new SocketError('HTTP/2: connection unresponsive', util.getSocketInfo(session[kSocket]))
+  session[kError] = err
+  resetHttp2Session(session, err)
+}
+
 function clearHttp2IdleTimeout (session) {
   const state = session[kHTTP2SessionState]
 
@@ -686,6 +754,7 @@ function onHttp2SessionGoAway (errorCode, lastStreamID) {
 
   clearHttp2IdleTimeout(this)
   clearNoStreamsTimeout(this)
+  clearHttp2ProbeTimeout(this)
 
   if (!this.closed && !this.destroyed) {
     this.close()
@@ -711,6 +780,7 @@ function onHttp2SessionClose () {
 
   clearHttp2IdleTimeout(this)
   clearNoStreamsTimeout(this)
+  clearHttp2ProbeTimeout(this)
 
   if (state.ping.interval != null) {
     clearInterval(state.ping.interval)
@@ -1610,9 +1680,14 @@ function onTimeout () {
   // Remove self so timeout doesn't fire again after we handle it
   stream.off('timeout', onTimeout)
 
-  const err = state.responseReceived
-    ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${state.bodyTimeout}"`)
-    : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${state.headersTimeout}"`)
+  const { responseReceived, session, bodyTimeout, headersTimeout } = state
+  const err = responseReceived
+    ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${bodyTimeout}"`)
+    : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${headersTimeout}"`)
+
+  // Probe before aborting: completing the request resumes the queue, which
+  // must not open new streams until the peer has proven it is alive.
+  probeHttp2Session(session, responseReceived ? bodyTimeout : headersTimeout)
   state.abort(err)
 }
 

package/node_modules/undici/lib/dispatcher/pool-base.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { AsyncResource } = require('node:async_hooks')
 const { PoolStats } = require('../util/stats.js')
 const DispatcherBase = require('./dispatcher-base')
 const FixedQueue = require('./fixed-queue')
@@ -26,6 +27,22 @@ const kRetiring = Symbol('retiring clients')
 // Closes every live client, including clients that have been
 // taken out of rotation but are still finishing their own
 // requests.
+// Requests that wait in the Pool queue are dispatched later from whichever
+// callback drains the queue (another request's connect, drain, ...). Capture
+// the caller's async context so Client#dispatch, and the diagnostics channel
+// events it publishes, still run in it.
+class QueuedRequest extends AsyncResource {
+  constructor (opts, handler) {
+    super('UNDICI_POOL_QUEUED_REQUEST')
+    this.opts = opts
+    this.handler = handler
+  }
+
+  dispatch (dispatcher) {
+    return this.runInAsyncScope(dispatcher.dispatch, dispatcher, this.opts, this.handler)
+  }
+}
+
 function closeClients (pool) {
   const closeAll = []
   for (let i = 0; i < pool[kClients].length; i++) {
@@ -69,7 +86,7 @@ class PoolBase extends DispatcherBase {
         break
       }
       this[kQueued]--
-      needDrain = !client.dispatch(item.opts, item.handler)
+      needDrain = !item.dispatch(client)
     }
 
     client[kNeedDrain] = needDrain
@@ -114,7 +131,7 @@ class PoolBase extends DispatcherBase {
       const item = queue.shift()
       this[kQueued]--
 
-      if (!dispatcher.dispatch(item.opts, item.handler)) {
+      if (!item.dispatch(dispatcher)) {
         dispatcher[kNeedDrain] = true
         this[kOnClientBusy](dispatcher)
         hasDispatcher = this[kHasDispatcher]()
@@ -228,7 +245,7 @@ class PoolBase extends DispatcherBase {
 
     if (!dispatcher) {
       this[kNeedDrain] = true
-      this[kQueue].push({ opts, handler })
+      this[kQueue].push(new QueuedRequest(opts, handler))
       this[kQueued]++
     } else if (!dispatcher.dispatch(opts, handler)) {
       dispatcher[kNeedDrain] = true

package/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.12.2",
+  "version": "8.12.3",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -122,12 +122,12 @@
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
+    "eslint": "^10.12.0",
     "fast-check": "^4.1.1",
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "neostandard": "^0.14.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",

package/node_modules/undici/types/api.d.ts

@@ -5,7 +5,7 @@ import Dispatcher from './dispatcher'
 /** Performs an HTTP request. */
 declare function request<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>
 ): Promise<Dispatcher.ResponseData<TOpaque>>
 
 /** A faster version of `request`. */

package/node_modules/undici/types/utility.d.ts

@@ -1,7 +1,7 @@
 type AutocompletePrimitiveBaseType<T> =
-  T extends string ? string :
-    T extends number ? number :
-      T extends boolean ? boolean :
-        never
+  T extends string ? string
+    : T extends number ? number
+      : T extends boolean ? boolean
+        : never
 
 export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>)

package/node_modules/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/node_modules/zod/src/v4/classic/tests/array.test.ts

@@ -140,6 +140,33 @@ test("continue parsing despite array size error", () => {
   `);
 });
 
+test("an upper size bound fails before any element is parsed", () => {
+  let parsed = 0;
+  const el = z.string().refine(() => ++parsed);
+  let refined = 0;
+  const schema = z
+    .array(el)
+    .max(2, "too many")
+    .refine(() => ++refined);
+  expect(schema.safeParse([1, 2, 3]).error!.issues).toMatchObject([{ code: "too_big", path: [], message: "too many" }]);
+  expect(z.array(el).length(2).safeParse(["a", "b", "c"]).error!.issues).toMatchObject([
+    { code: "too_big", exact: true },
+  ]);
+  expect(z.object({ a: z.array(el).max(1) }).safeParse({ a: [1, 2] }).error!.issues).toMatchObject([
+    { code: "too_big", path: ["a"] },
+  ]);
+  expect([parsed, refined]).toEqual([0, 0]);
+
+  // a check that may rewrite the value ends the gate
+  expect(
+    z
+      .array(z.number())
+      .overwrite((a) => a.slice(0, 2))
+      .max(2)
+      .parse([1, 2, 3])
+  ).toEqual([1, 2]);
+});
+
 test("parse should fail given sparse array", () => {
   const schema = z.array(z.string()).nonempty().min(1).max(3);
   const result = schema.safeParse(new Array(3));