@code-yeongyu/senpi 2026.9.11 → 2026.9.12-3

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

@@ -2,25 +2,69 @@
 import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import * as Schema from '../types/index.mjs';
+export const DefaultBase = 'https://json-schema.org';
 // ------------------------------------------------------------------
-// DefaultBase
+// Find: FindDynamicAnchor
 // ------------------------------------------------------------------
-export const DefaultBase = new URL('https://json-schema.org');
+function FindDynamicAnchor(schema, name) {
+    if (Guard.IsObject(schema) && Schema.IsDynamicAnchor(schema) && Guard.IsEqual(schema.$dynamicAnchor, name)) {
+        return schema;
+    }
+    if (Guard.IsObject(schema)) {
+        for (const key of Guard.Keys(schema)) {
+            const result = FindDynamicAnchor(schema[key], name);
+            if (result)
+                return result;
+        }
+    }
+    // (no-coverage) - is it even possible to search for an anchor
+    // with embedded logical schema like allOf, anyOf, etc?
+    // if (Guard.IsArray(schema)) { // (no-coverage)
+    //   for (const item of schema) {
+    //     const result = FindDynamicAnchor(item, name)
+    //     if (result) return result
+    //   }
+    // }
+    return undefined;
+}
 // ------------------------------------------------------------------
-// Match: Id
+// Find: FindBase
+// ------------------------------------------------------------------
+function FindBase(schema, base, target) {
+    if (Guard.IsEqual(schema, target))
+        return base.href;
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
+    if (Guard.IsArray(schema)) {
+        for (const item of schema) {
+            const result = FindBase(item, nextBase, target);
+            if (!Guard.IsUndefined(result))
+                return result;
+        }
+    }
+    else if (Guard.IsObject(schema)) {
+        for (const key of Guard.Keys(schema)) {
+            const result = FindBase(schema[key], nextBase, target);
+            if (!Guard.IsUndefined(result))
+                return result;
+        }
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: MatchId
 // ------------------------------------------------------------------
 function MatchId(schema, base, ref) {
-    if (schema.$id === ref.hash)
+    // ref is a bare fragment naming this schema's $id directly
+    if (Guard.IsEqual(schema.$id, ref.hash))
         return schema;
-    const absoluteId = new URL(schema.$id, base.href);
     const absoluteRef = new URL(ref.href, base.href);
-    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
-        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
-    }
+    // ref shares this $id's document, so resolve the fragment within it
+    if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
+        return ref.hash.startsWith('#') ? MatchHash(schema, ref) : schema;
     return undefined;
 }
 // ------------------------------------------------------------------
-// Match: Anchor
+// Match: MatchAnchor
 // ------------------------------------------------------------------
 function MatchAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
@@ -28,23 +72,18 @@ function MatchAnchor(schema, base, ref) {
     return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
 // ------------------------------------------------------------------
-// Match: DynamicAnchor
+// Match: MatchDynamicAnchor
 // ------------------------------------------------------------------
 function MatchDynamicAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
-    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+    const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
+    return isMatch ? schema : undefined;
 }
 // ------------------------------------------------------------------
-// Match: Hash
-//
-// Resolves JSON Pointer fragments only. Plain anchor-style fragments
-// (no leading '/') are handled exclusively by MatchAnchor and
-// MatchDynamicAnchor to prevent accidentally resolving an anchor name
-// as a pointer into the schema tree.
-//
+// Match: MatchHash
 // ------------------------------------------------------------------
-function MatchHash(schema, _base, ref) {
+function MatchHash(schema, ref) {
     if (ref.href.endsWith('#'))
         return schema;
     if (!ref.hash.startsWith('#'))
@@ -52,10 +91,11 @@ function MatchHash(schema, _base, ref) {
     const fragment = decodeURIComponent(ref.hash.slice(1));
     if (!fragment.startsWith('/'))
         return undefined;
-    return Pointer.Get(schema, fragment);
+    const result = Pointer.Get(schema, fragment);
+    return result;
 }
 // ------------------------------------------------------------------
-// Match
+// Match: Match
 // ------------------------------------------------------------------
 function Match(schema, base, ref) {
     if (Schema.IsId(schema)) {
@@ -73,7 +113,7 @@ function Match(schema, base, ref) {
         if (!Guard.IsUndefined(result))
             return result;
     }
-    return MatchHash(schema, base, ref);
+    return MatchHash(schema, ref);
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -88,8 +128,6 @@ function FromArray(schema, base, ref) {
 // FromObject
 // ------------------------------------------------------------------
 function SkipProperty(key) {
-    // these are explicit data encoded in a schema, they should not
-    // be considered valid targets used for de-referencing.
     return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
 }
 function FromObject(schema, base, ref) {
@@ -104,9 +142,7 @@ function FromObject(schema, base, ref) {
 // FromValue
 // ------------------------------------------------------------------
 function FromValue(schema, base, ref) {
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema)
-        ? new URL(schema.$id, base.href)
-        : base;
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
     if (Schema.IsSchemaObject(schema)) {
         const result = Match(schema, nextBase, ref);
         if (!Guard.IsUndefined(result))
@@ -119,84 +155,173 @@ function FromValue(schema, base, ref) {
     return undefined;
 }
 // ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+export function Base(schema, base, target) {
+    return FindBase(schema, new URL(base || '.', DefaultBase), target);
+}
+// ------------------------------------------------------------------
+// Resource
+// ------------------------------------------------------------------
+export function Resource(context, schema, base, ref) {
+    const result = Ref(context, schema, base, ref, false);
+    return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
+}
+// ------------------------------------------------------------------
 // CanonicalHref
-//
-// Returns the URL's href with its fragment removed, as a string.
-// This is the canonical URI a document is identified and keyed by
-// in context.
 // ------------------------------------------------------------------
 function CanonicalHref(url) {
     return url.href.split('#')[0];
 }
 // ------------------------------------------------------------------
-// RefContext: Phase 1
-//
-// A ContextRef targets a simple key name in the context and is
-// used for fast resolution of inline referential TypeBox types.
+// Ref: RefRemote (Phase 1)
 // ------------------------------------------------------------------
 function RefContext(context, ref) {
     return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
 }
 // ------------------------------------------------------------------
-// RefLocal: Phase 2
-//
-// Resolves the ref's fragment within the current schema resource,
-// either as a JSON Pointer or a plain-name fragment ($anchor,
-// $dynamicAnchor), per the JSON Schema spec.
+// Ref: RefRemote (Phase 2)
 // ------------------------------------------------------------------
 function RefLocal(schema, base, ref) {
     return FromValue(schema, base, ref);
 }
 // ------------------------------------------------------------------
-// RefRemote: Phase 3
-//
-// Locates the schema resource identified by the ref's base URI, then
-// resolves the ref's fragment within that resource, either as a JSON
-// Pointer or a plain-name fragment, per the JSON Schema spec.
+// Ref: RefRemote (Phase 3)
 // ------------------------------------------------------------------
 function RefRemote(context, base, ref) {
-    const targetDocumentHref = CanonicalHref(ref);
-    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
+    const canonicalHref = CanonicalHref(ref);
+    if (Guard.IsEqual(canonicalHref, CanonicalHref(base)))
+        return undefined;
+    if (!Guard.HasPropertyKey(context, canonicalHref))
+        return undefined;
+    const remoteSchema = context[canonicalHref];
+    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, canonicalHref) : new URL(canonicalHref);
+    const result = Guard.IsEqual(ref.hash, '') ? remoteSchema : FromValue(remoteSchema, remoteBase, ref);
+    return result;
+}
+// ------------------------------------------------------------------
+// RetrievedResource: LegacyRetrievedResource
+//
+// Draft-4 style schemas (no $schema keyword) treat a nested $id as an
+// in-place base URI change rather than a new resource boundary. A
+// local ('#...') ref that lands somewhere with a different base than
+// the current reference base needs a frame so later anchor/pointer
+// resolution is computed against the right base.
+// ------------------------------------------------------------------
+function LegacyRetrievedResource(root, lexicalSchema, referenceBase, ref, schema) {
+    if (!ref.$ref.startsWith('#'))
+        return undefined;
+    if (Guard.HasPropertyKey(root, '$schema'))
+        return undefined;
+    const targetBase = Base(lexicalSchema, referenceBase, schema);
+    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, referenceBase))
         return undefined;
-    if (!Guard.HasPropertyKey(context, targetDocumentHref))
+    return { target: schema, base: targetBase, root: lexicalSchema };
+}
+// ------------------------------------------------------------------
+// RetrievedResource: RemoteRetrievedResource
+//
+// The ref's canonical URL names a document already loaded into
+// context. That document becomes the frame's root going forward.
+// ------------------------------------------------------------------
+function RemoteRetrievedResource(context, canonical, schema) {
+    const remoteRoot = context[canonical];
+    if (!Schema.IsSchemaObject(remoteRoot))
         return undefined;
-    const remoteSchema = context[targetDocumentHref];
-    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, DefaultBase.href) : new URL(targetDocumentHref);
-    return FromValue(remoteSchema, remoteBase, ref);
+    return { target: schema, base: canonical, root: remoteRoot };
+}
+// ------------------------------------------------------------------
+// RetrievedResource
+//
+// A genuinely remote document frame always wins over a same-document
+// legacy one: only one frame is ever entered per ref.
+// ------------------------------------------------------------------
+function FindRetrievedResource(stackframe, ref, schema, canonical, isRemote) {
+    const remote = isRemote ? RemoteRetrievedResource(stackframe.context, canonical, schema) : undefined;
+    if (!Guard.IsUndefined(remote))
+        return remote;
+    return LegacyRetrievedResource(stackframe.root, stackframe.lexicalSchema, stackframe.referenceBase, ref, schema);
+}
+// ------------------------------------------------------------------
+// ResolvedResource: FindResolvedResource
+//
+// The ref crossed into a different resource but landed on a schema
+// that doesn't itself carry that resource's $id (e.g. a pointer into
+// the middle of a remote document). The enclosing resource still
+// needs to be entered so lexical/base lookups behave as if traversal
+// had walked in from its top.
+// ------------------------------------------------------------------
+function FindResolvedResource(context, root, referenceBase, canonical, schema, ids) {
+    if (Schema.IsId(schema))
+        return undefined;
+    const resource = Resource(context, root, referenceBase, canonical);
+    if (!resource || ids.includes(resource))
+        return undefined;
+    return { target: schema, resource };
 }
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
-export function Ref(context, schema, ref) {
-    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
-    const initialRef = new URL(ref, initialBase.href);
-    return RefContext(context, ref) ?? RefLocal(schema, initialBase, initialRef) ?? RefRemote(context, initialBase, initialRef);
+export function Ref(remotes, schema, base, ref, applySchemaId = true) {
+    const initialBase = new URL(base || '.', DefaultBase);
+    const resolvedBase = applySchemaId && Schema.IsId(schema) ? new URL(schema.$id, initialBase) : initialBase;
+    const initialRef = new URL(ref, resolvedBase.href);
+    return RefContext(remotes, ref) ?? RefLocal(schema, resolvedBase, initialRef) ?? RefRemote(remotes, resolvedBase, initialRef);
 }
 // ------------------------------------------------------------------
 // DynamicRef
 // ------------------------------------------------------------------
-export function DynamicRef(context, root, base, dynamicRef, dynamicAnchors) {
-    // Resolve the static target using either the local base (for fragment‑only references)
-    // or the document root (for absolute URI references).
-    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
-        ? Ref(context, base, dynamicRef.$dynamicRef)
-        : Ref(context, root, dynamicRef.$dynamicRef);
-    if (Guard.IsUndefined(fragmentTarget))
+export function DynamicRef(context, root, base, schema, dynamicRef, dynamicAnchors) {
+    const initialBase = new URL(base || '.', DefaultBase);
+    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? schema : root;
+    const fragmentTarget = Ref(context, fragmentRoot, base, dynamicRef.$dynamicRef, false);
+    if (Guard.IsUndefined(fragmentTarget)) {
+        const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
+        if (!fragment.startsWith('#/') && fragment.startsWith('#')) {
+            const name = decodeURIComponent(fragment.slice(1));
+            const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? FindDynamicAnchor(root, name);
+            return anchorTarget;
+        }
         return undefined;
-    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
-    // If it does not, return the static target unchanged.
+    }
     if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
         return fragmentTarget;
-    // Extract the fragment portion of the reference. According to the test suite,
-    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
-    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
-    const fragment = new URL(dynamicRef.$dynamicRef, DefaultBase).hash;
+    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
     if (fragment.startsWith('#/'))
         return fragmentTarget;
-    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
-    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
-    // find() returns the outermost (first encountered) match, which is the correct
-    // lexical scope per the specification.
-    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
+    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
     return anchorTarget ?? fragmentTarget;
 }
+// ------------------------------------------------------------------
+// ResolveRef
+//
+// Resolves the schema a $ref points to, and describes whether that
+// crossing implies a "retrieved resource" frame or entering a
+// resource the target doesn't itself carry the $id for. The caller
+// decides whether and how to record these.
+// ------------------------------------------------------------------
+export function ResolveRef(stackframe, ref) {
+    const source = stackframe.inRetrievedFrame ? stackframe.lexicalSchema : stackframe.root;
+    const refRoot = ref.$ref.startsWith('#') ? stackframe.lexicalSchema : source;
+    const schema = Ref(stackframe.context, refRoot, stackframe.referenceBase, ref.$ref, false);
+    if (!schema || !Schema.IsSchemaObject(schema))
+        return { schema };
+    const canonical = new URL(ref.$ref, stackframe.referenceBase).href.split('#')[0];
+    const isRemote = !Guard.IsEqual(canonical, stackframe.resourceBase);
+    const retrievedResource = FindRetrievedResource(stackframe, ref, schema, canonical, isRemote);
+    const resolvedResource = isRemote ? FindResolvedResource(stackframe.context, stackframe.root, stackframe.referenceBase, canonical, schema, stackframe.ids) : undefined;
+    return { schema, retrievedResource, resolvedResource };
+}
+// ------------------------------------------------------------------
+// ResolveRecursiveRef
+// ------------------------------------------------------------------
+export function ResolveRecursiveRef(stackframe, recursiveRef) {
+    const refRoot = Schema.IsRecursiveAnchorTrue(stackframe.lexicalSchema) ? stackframe.recursiveAnchors[0] : stackframe.lexicalSchema;
+    return Ref(stackframe.context, refRoot, stackframe.lexicalBase, recursiveRef.$recursiveRef, false);
+}
+// ------------------------------------------------------------------
+// ResolveDynamicRef
+// ------------------------------------------------------------------
+export function ResolveDynamicRef(stackframe, dynamicRef) {
+    return DynamicRef(stackframe.context, stackframe.root, stackframe.lexicalBase, stackframe.lexicalSchema, dynamicRef, stackframe.dynamicAnchors);
+}

package/node_modules/typebox/build/schema/schema.d.mts

@@ -1,4 +1,5 @@
 export * from './engine/index.mjs';
+export * from './intern/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';

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

@@ -1,4 +1,5 @@
 export * from './engine/index.mjs';
+export * from './intern/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';

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

@@ -1,16 +1,6 @@
 import type { TProperties, TSchema } from '../../type/index.mjs';
 import type { TLocalizedValidationError } from '../../error/index.mjs';
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors<Context extends TProperties, Type extends TSchema>(context: Context, type: Type, value: unknown): TLocalizedValidationError[];

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

@@ -1,12 +1,7 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
-import { Errors as SchemaErrors, } from '../../schema/index.mjs';
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+import { Errors as SchemaErrors } from '../../schema/index.mjs';
+/** Returns an array of validation errors for the given value. */
 export function Errors(...args) {
     const [context, type, value] = Arguments.Match(args, {
         3: (context, type, value) => [context, type, value],

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

package/node_modules/typebox/readme.md

@@ -245,13 +245,16 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | contains | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | content | - | - | - | - | ✅ | ✅ | ✅ |
 | default | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| definitions | - | 1/2 | ✅ | ✅ | - | - | - |
+| defs | - | - | - | - | ✅ | ✅ | - |
 | dependencies | 17/18 | ✅ | ✅ | ✅ | - | - | - |
 | dependentRequired | - | - | - | - | ✅ | ✅ | ✅ |
 | dependentSchemas | - | - | - | - | ✅ | ✅ | ✅ |
-| dynamicRef | - | - | - | - | - | 40/44 | 21/27 |
-| enum | 14/16 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| dynamicRef | - | - | - | - | - | ✅ | ✅ |
+| enum | 16/18 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMaximum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMinimum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
+| format | ✅ | ✅ | ✅ | ✅ | ✅ | 114/133 | - |
 | if-then-else | - | - | - | ✅ | ✅ | ✅ | ✅ |
 | infinite-loop-detection | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | items | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -274,11 +277,12 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | properties | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | propertyNames | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | recursiveRef | - | - | - | - | ✅ | - | - |
-| ref | 22/27 | 37/45 | 67/70 | 75/78 | 79/81 | 77/79 | 78/79 |
+| ref | 23/27 | 38/45 | 69/70 | 77/78 | ✅ | ✅ | ✅ |
+| refRemote | 7/8 | 11/17 | ✅ | ✅ | ✅ | ✅ | ✅ |
 | required | 3/4 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | type | 73/80 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| unevaluatedItems | - | - | - | - | ✅ | ✅ | 70/71 |
-| unevaluatedProperties | - | - | - | - | ✅ | ✅ | 128/129 |
+| unevaluatedItems | - | - | - | - | ✅ | ✅ | ✅ |
+| unevaluatedProperties | - | - | - | - | ✅ | ✅ | ✅ |
 | uniqueItems | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ### Performance

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

@@ -147,6 +147,10 @@ added: v1.0.0
       WebSocket messages. Applied to uncompressed messages, compressed frame
       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.
+      **Default:** `buffer.kStringMaxLength`.
 * Returns: {Client}
 
 Instantiating a `Client` does not open a connection; the connection is

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

@@ -25,8 +25,9 @@ it is used only for HTTPS requests.
 proxied. Each entry may include a leading dot or `*.` wildcard (for example
 `.example.com`) to match subdomains, and an optional `:port` suffix to restrict
 the match to a specific port. A request bypasses the proxy when its host equals
-an entry or is a subdomain of one. Setting `no_proxy` to `*` bypasses the proxy
-for every request.
+an entry or is a subdomain of one. A trailing dot is ignored on both sides, so
+`example.com.` and `example.com` match each other. Setting `no_proxy` to `*`
+bypasses the proxy for every request.
 
 The uppercase variants `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` are also
 honored. When both the lowercase and uppercase forms of a variable are set, the

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

@@ -66,6 +66,9 @@ added: v6.5.0
       wait before re-establishing a dropped connection. The server may override
       this value with a `retry` field. **Default:** `3000`.
 
+EventSource-specific limits can be configured on the dispatcher using the
+`eventSource` option. See [`Client`][] for details.
+
 Creates a new `EventSource` and immediately begins connecting to `url`. The
 request is sent with the `Accept: text/event-stream` header, a cache mode of
 `no-store`, and an initiator type of `other`.
@@ -349,6 +352,7 @@ eventSource.onerror = () => {
 ```
 
 [WHATWG-conformant]: https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
+[`Client`]: Client.md#new-clienturl-options
 [`Dispatcher`]: Dispatcher.md#class-dispatcher
 [`addEventListener()`]: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
 [server-sent events]: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events

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

@@ -101,8 +101,8 @@ body yourself.
 
 * `opts` {Object} (optional)
   * `maxSize` {number} Maximum number of bytes to read and discard. Responses
-    whose `Content-Length` exceeds this value are aborted. **Default:**
-    `1_048_576` (1 MiB).
+    whose declared or received body size exceeds this value are aborted.
+    **Default:** `1_048_576` (1 MiB).
 
 Per-request override: set `dumpMaxSize` on the dispatch options to override
 the global `maxSize` for a specific request.
@@ -210,6 +210,9 @@ Automatically decompresses response bodies encoded with `gzip`, `x-gzip`,
     skipped. **Default:** `[204, 304]`.
   * `skipErrorResponses` {boolean} When `true`, responses with a status code
     >= 400 are not decompressed. **Default:** `true`.
+  * `maxSize` {number} Maximum decompressed response size in bytes. The request
+    fails with a `ResponseExceededMaxSizeError` if the decoded body exceeds
+    this limit. **Default:** `67108864` (64 MiB).
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}
 
@@ -221,7 +224,8 @@ import { Agent, interceptors } from 'undici'
 const agent = new Agent().compose(
   interceptors.decompress({
     skipStatusCodes: [204, 304],
-    skipErrorResponses: false // decompress error bodies too
+    skipErrorResponses: false, // decompress error bodies too
+    maxSize: 16 * 1024 * 1024 // limit decoded bodies to 16 MiB
   })
 )
 ```

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

@@ -60,6 +60,11 @@ added: v7.23.0
     a password embedded in `proxyUrl`. **Default:** the URL password, if any.
   * `connect` {Function} Custom connector used to open the socket to the proxy.
     **Default:** a connector built from `proxyTls`.
+  * `connectTimeout` {number} Maximum time in milliseconds for each proxy
+    connection, SOCKS5 negotiation, and target TLS negotiation stage. A value of
+    `0` disables these stage timeouts. `proxyTls.timeout` and
+    `requestTls.timeout` override it for their respective TLS stages.
+    **Default:** `5000`.
   * `proxyTls` {BuildOptions} TLS options for the connection to the proxy itself
     (SOCKS5 over TLS). When set, the proxy connection is established over TLS and
     `servername` defaults to the proxy host name.
@@ -69,7 +74,8 @@ added: v7.23.0
     host name.
 
 Throws an `InvalidArgumentError` if `proxyUrl` is missing or does not use the
-`socks5:` or `socks:` protocol.
+`socks5:` or `socks:` protocol, or if `connectTimeout`, `proxyTls.timeout`, or
+`requestTls.timeout` is not a finite, non-negative number.
 
 ```mjs
 import { Socks5ProxyAgent } from 'undici'

package/node_modules/undici/lib/cache/memory-cache-store.js

@@ -87,7 +87,7 @@ class MemoryCacheStore extends EventEmitter {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
    * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}
    */
   get (key) {
@@ -179,7 +179,7 @@ class MemoryCacheStore extends EventEmitter {
 
           // Perform eviction
           for (const [key, entries] of store.#entries) {
-            for (const entry of entries.splice(0, entries.length / 2)) {
+            for (const entry of entries.splice(0, Math.ceil(entries.length / 2))) {
               store.#size -= entry.size
               store.#count -= 1
             }

package/node_modules/undici/lib/core/symbols.js

@@ -5,6 +5,8 @@ module.exports = {
   kDestroy: Symbol('destroy'),
   kDispatch: Symbol('dispatch'),
   kUrl: Symbol('url'),
+  kRequestOrigin: Symbol('request origin'),
+  kOriginless: Symbol('originless'),
   kWriting: Symbol('writing'),
   kResuming: Symbol('resuming'),
   kQueue: Symbol('queue'),

package/node_modules/undici/lib/dispatcher/agent.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors')
-const { kBusy, kClients, kConnected, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
+const { kBusy, kClients, kConnected, kRunning, kPending, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
 const DispatcherBase = require('./dispatcher-base')
 const Pool = require('./pool')
 const Client = require('./client')
@@ -97,7 +97,12 @@ class Agent extends DispatcherBase {
           return
         }
 
-        if (dispatcher[kConnected] > 0 || dispatcher[kBusy]) {
+        // A GOAWAY detaches the HTTP/2 session before requeued requests are
+        // dispatched on a replacement connection. At that point the pool has
+        // no connected clients and is not busy, but it still has pending work.
+        // Closing it here lets the replacement Client finish those requests
+        // and then destroys that new connection with ClientDestroyedError.
+        if (dispatcher[kConnected] > 0 || dispatcher[kBusy] || dispatcher[kPending] > 0) {
           return
         }
 

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

@@ -13,7 +13,7 @@ const {
   kGetDispatcher
 } = require('./pool-base')
 const Pool = require('./pool')
-const { kUrl } = require('../core/symbols')
+const { kOriginless, kUrl } = require('../core/symbols')
 const util = require('../core/util')
 const kFactory = Symbol('factory')
 
@@ -49,14 +49,17 @@ function defaultFactory (origin, opts) {
 }
 
 class BalancedPool extends PoolBase {
-  constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) {
+  constructor (upstreams = [], { factory = defaultFactory, connect, tls, ...opts } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
 
-    super()
+    super(opts)
 
-    this[kOptions] = { ...util.deepClone(opts) }
+    this[kOriginless] = true
+    if (connect && typeof connect !== 'function') connect = { ...connect }
+    if (tls && typeof tls !== 'function') tls = { ...tls }
+    this[kOptions] = { ...util.deepClone(opts), connect, tls }
     this[kIndex] = -1
     this[kCurrentWeight] = 0