@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

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

@@ -2,69 +2,25 @@
 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';
 // ------------------------------------------------------------------
-// Find: FindDynamicAnchor
+// DefaultBase
 // ------------------------------------------------------------------
-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;
-}
+export const DefaultBase = new URL('https://json-schema.org');
 // ------------------------------------------------------------------
-// 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
+// Match: Id
 // ------------------------------------------------------------------
 function MatchId(schema, base, ref) {
-    // ref is a bare fragment naming this schema's $id directly
-    if (Guard.IsEqual(schema.$id, ref.hash))
+    if (schema.$id === ref.hash)
         return schema;
+    const absoluteId = new URL(schema.$id, base.href);
     const absoluteRef = new URL(ref.href, base.href);
-    // 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;
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
+    }
     return undefined;
 }
 // ------------------------------------------------------------------
-// Match: MatchAnchor
+// Match: Anchor
 // ------------------------------------------------------------------
 function MatchAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
@@ -72,18 +28,23 @@ function MatchAnchor(schema, base, ref) {
     return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
 // ------------------------------------------------------------------
-// Match: MatchDynamicAnchor
+// Match: DynamicAnchor
 // ------------------------------------------------------------------
 function MatchDynamicAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
-    const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
-    return isMatch ? schema : undefined;
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
 // ------------------------------------------------------------------
-// Match: MatchHash
+// 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.
+//
 // ------------------------------------------------------------------
-function MatchHash(schema, ref) {
+function MatchHash(schema, _base, ref) {
     if (ref.href.endsWith('#'))
         return schema;
     if (!ref.hash.startsWith('#'))
@@ -91,11 +52,10 @@ function MatchHash(schema, ref) {
     const fragment = decodeURIComponent(ref.hash.slice(1));
     if (!fragment.startsWith('/'))
         return undefined;
-    const result = Pointer.Get(schema, fragment);
-    return result;
+    return Pointer.Get(schema, fragment);
 }
 // ------------------------------------------------------------------
-// Match: Match
+// Match
 // ------------------------------------------------------------------
 function Match(schema, base, ref) {
     if (Schema.IsId(schema)) {
@@ -113,7 +73,7 @@ function Match(schema, base, ref) {
         if (!Guard.IsUndefined(result))
             return result;
     }
-    return MatchHash(schema, ref);
+    return MatchHash(schema, base, ref);
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -128,6 +88,8 @@ 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) {
@@ -142,7 +104,9 @@ 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))
@@ -155,173 +119,84 @@ 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];
 }
 // ------------------------------------------------------------------
-// Ref: RefRemote (Phase 1)
+// RefContext: Phase 1
+//
+// A ContextRef targets a simple key name in the context and is
+// used for fast resolution of inline referential TypeBox types.
 // ------------------------------------------------------------------
 function RefContext(context, ref) {
     return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
 }
 // ------------------------------------------------------------------
-// Ref: RefRemote (Phase 2)
+// 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.
 // ------------------------------------------------------------------
 function RefLocal(schema, base, ref) {
     return FromValue(schema, base, ref);
 }
 // ------------------------------------------------------------------
-// Ref: RefRemote (Phase 3)
-// ------------------------------------------------------------------
-function RefRemote(context, base, ref) {
-    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;
-    return { target: schema, base: targetBase, root: lexicalSchema };
-}
-// ------------------------------------------------------------------
-// RetrievedResource: RemoteRetrievedResource
+// RefRemote: Phase 3
 //
-// 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;
-    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);
-}
+// 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.
 // ------------------------------------------------------------------
-// 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))
+function RefRemote(context, base, ref) {
+    const targetDocumentHref = CanonicalHref(ref);
+    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
         return undefined;
-    const resource = Resource(context, root, referenceBase, canonical);
-    if (!resource || ids.includes(resource))
+    if (!Guard.HasPropertyKey(context, targetDocumentHref))
         return undefined;
-    return { target: schema, resource };
+    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);
 }
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
-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);
+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);
 }
 // ------------------------------------------------------------------
 // DynamicRef
 // ------------------------------------------------------------------
-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;
-        }
+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))
         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;
-    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
+    // 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;
     if (fragment.startsWith('#/'))
         return fragmentTarget;
-    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
+    // 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);
     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,5 +1,4 @@
 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,5 +1,4 @@
 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,6 +1,16 @@
 import type { TProperties, TSchema } from '../../type/index.mjs';
 import type { TLocalizedValidationError } from '../../error/index.mjs';
-/** Returns an array of validation errors for the given value. */
+/**
+ * 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.
+ */
 export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
-/** Returns an array of validation errors for the given value. */
+/**
+ * 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.
+ */
 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,7 +1,12 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
-import { Errors as SchemaErrors } from '../../schema/index.mjs';
-/** Returns an array of validation errors for the given value. */
+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.
+ */
 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.27",
+  "version": "1.3.18",
   "keywords": [
     "typescript",
     "jsonschema"

package/node_modules/typebox/readme.md

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

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

@@ -147,10 +147,6 @@ 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,9 +25,8 @@ 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. 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.
+an entry or is a subdomain of one. 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,9 +66,6 @@ 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`.
@@ -352,7 +349,6 @@ 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 declared or received body size exceeds this value are aborted.
-    **Default:** `1_048_576` (1 MiB).
+    whose `Content-Length` 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,9 +210,6 @@ 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}
 
@@ -224,8 +221,7 @@ import { Agent, interceptors } from 'undici'
 const agent = new Agent().compose(
   interceptors.decompress({
     skipStatusCodes: [204, 304],
-    skipErrorResponses: false, // decompress error bodies too
-    maxSize: 16 * 1024 * 1024 // limit decoded bodies to 16 MiB
+    skipErrorResponses: false // decompress error bodies too
   })
 )
 ```

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

@@ -60,11 +60,6 @@ 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.
@@ -74,8 +69,7 @@ added: v7.23.0
     host name.
 
 Throws an `InvalidArgumentError` if `proxyUrl` is missing or does not use the
-`socks5:` or `socks:` protocol, or if `connectTimeout`, `proxyTls.timeout`, or
-`requestTls.timeout` is not a finite, non-negative number.
+`socks5:` or `socks:` protocol.
 
 ```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} key
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
    * @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, Math.ceil(entries.length / 2))) {
+            for (const entry of entries.splice(0, entries.length / 2)) {
               store.#size -= entry.size
               store.#count -= 1
             }

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

@@ -5,8 +5,6 @@ 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, kPending, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
+const { kBusy, kClients, kConnected, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
 const DispatcherBase = require('./dispatcher-base')
 const Pool = require('./pool')
 const Client = require('./client')
@@ -97,12 +97,7 @@ class Agent extends DispatcherBase {
           return
         }
 
-        // 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) {
+        if (dispatcher[kConnected] > 0 || dispatcher[kBusy]) {
           return
         }
 

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

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