@openclaw/diffs 2026.8.1-beta.3 → 2026.8.1

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

@@ -45,12 +45,21 @@ import { BuildUnevaluatedItems, CheckUnevaluatedItems, ErrorUnevaluatedItems } f
 import { BuildUnevaluatedProperties, CheckUnevaluatedProperties, ErrorUnevaluatedProperties } from './unevaluatedProperties.mjs';
 import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueItems.mjs';
 // ----------------------------------------------------------------
-// HasTypeName
+// HasTypeName (Optimization)
+//
+// We only consider a schema as having a type name when the schema 
+// has a single type string, or when every element in the type 
+// array is the same. For a type array, we must treat multi-variant 
+// types as unions and therefore can NOT use an optimized forward 
+// type check.
+//
 // ----------------------------------------------------------------
 function HasTypeName(schema, typename) {
-    return Schema.IsType(schema) &&
-        (G.IsArray(schema.type) && schema.type.includes(typename) ||
-            G.IsEqual(schema.type, typename));
+    return (Schema.IsType(schema) &&
+        ((G.IsArray(schema.type) &&
+            G.IsGreaterThan(schema.type.length, 0) &&
+            G.Every(schema.type, 0, type => G.IsEqual(type, typename))) ||
+            G.IsEqual(schema.type, typename)));
 }
 // ----------------------------------------------------------------
 // HasObject

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

@@ -48,7 +48,7 @@ function BuildTypeNames(stack, context, typenames, value) {
     return E.ReduceOr(typenames.map(type => BuildTypeName(stack, context, type, value)));
 }
 function CheckTypeNames(stack, context, types, schema, value) {
-    return types.some(type => CheckTypeName(stack, context, type, schema, value));
+    return G.Some(types, type => CheckTypeName(stack, context, type, schema, value));
 }
 // ------------------------------------------------------------------
 // Type

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

@@ -1 +1,4 @@
-export * from './ref.mjs';
+import * as Schema from '../types/index.mjs';
+export declare const DefaultBase: URL;
+export declare function Ref(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
+export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;

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

@@ -1 +1,202 @@
-export * from './ref.mjs';
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// DefaultBase
+// ------------------------------------------------------------------
+export const DefaultBase = new URL('https://json-schema.org');
+// ------------------------------------------------------------------
+// Match: Id
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    if (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;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Anchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: DynamicAnchor
+// ------------------------------------------------------------------
+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;
+}
+// ------------------------------------------------------------------
+// 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, _base, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    if (!ref.hash.startsWith('#'))
+        return undefined;
+    const fragment = decodeURIComponent(ref.hash.slice(1));
+    if (!fragment.startsWith('/'))
+        return undefined;
+    return Pointer.Get(schema, fragment);
+}
+// ------------------------------------------------------------------
+// Match
+// ------------------------------------------------------------------
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsDynamicAnchor(schema)) {
+        const result = MatchDynamicAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// 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) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        if (SkipProperty(key))
+            return result;
+        const match = FromValue(schema[key], base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(schema, base, ref) {
+    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))
+            return result;
+    }
+    if (Guard.IsArray(schema))
+        return FromArray(schema, nextBase, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, nextBase, ref);
+    return 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.
+// ------------------------------------------------------------------
+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.
+// ------------------------------------------------------------------
+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.
+// ------------------------------------------------------------------
+function RefRemote(context, base, ref) {
+    const targetDocumentHref = CanonicalHref(ref);
+    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
+        return undefined;
+    if (!Guard.HasPropertyKey(context, targetDocumentHref))
+        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);
+}
+// ------------------------------------------------------------------
+// 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);
+}
+// ------------------------------------------------------------------
+// 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))
+        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;
+    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);
+    return anchorTarget ?? fragmentTarget;
+}

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

@@ -0,0 +1,5 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPropertyNames<Stack extends string[], Root extends XSchema, Schema extends XSchema, StaticKey extends unknown = XStaticSchema<Stack, Root, Schema>, Result extends Record<string, unknown> = [StaticKey] extends [PropertyKey] ? {
+    [Key in StaticKey]?: unknown;
+} : {}> = Result;

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

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

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

@@ -9,6 +9,7 @@ import type { XOneOf } from '../types/oneOf.mjs';
 import type { XPatternProperties } from '../types/patternProperties.mjs';
 import type { XPrefixItems } from '../types/prefixItems.mjs';
 import type { XProperties } from '../types/properties.mjs';
+import type { XPropertyNames } from '../types/propertyNames.mjs';
 import type { XRef } from '../types/ref.mjs';
 import type { XRequired } from '../types/required.mjs';
 import type { XSchema } from '../types/schema.mjs';
@@ -25,6 +26,7 @@ import type { XStaticOneOf } from './oneOf.mjs';
 import type { XStaticPatternProperties } from './patternProperties.mjs';
 import type { XStaticPrefixItems } from './prefixItems.mjs';
 import type { XStaticProperties } from './properties.mjs';
+import type { XStaticPropertyNames } from './propertyNames.mjs';
 import type { XStaticRef } from './ref.mjs';
 import type { XStaticRequired } from './required.mjs';
 import type { XStaticType } from './type.mjs';
@@ -41,6 +43,7 @@ type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
     Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
     Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
     Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
+    Schema extends XPropertyNames<infer Type extends XSchema> ? XStaticPropertyNames<Stack, Root, Type> : unknown,
     Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
     Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
     Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,

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

@@ -6,8 +6,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';

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

@@ -12,8 +12,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';

package/node_modules/typebox/build/system/memory/clone.mjs

@@ -13,24 +13,27 @@ function FromClassInstance(value) {
     return value; // atomic
 }
 // ------------------------------------------------------------------
-// TypeObject
+// SchemaObject
 //
-// Types have non-enumerable properties that MUST be preserved on Clone. 
-// The following is the optimal path for TypeBox types.
+// Schema objects have non-enumerable properties that MUST be preserved 
+// on Clone. The following is the optimal path these objects.
 // ------------------------------------------------------------------
-function IsTypeObject(value) {
+function IsSchemaObject(value) {
     return (Guard.HasPropertyKey(value, '~kind') ||
         Guard.HasPropertyKey(value, '~unsafe'));
 }
-function FromTypeObject(value) {
+function FromSchemaObject(value) {
     const result = {};
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    for (const key of Object.keys(descriptors)) {
+    for (const key of Guard.Keys(value)) {
         if (Guard.IsUnsafePropertyKey(key))
             continue; // (ignore: prototype-pollution)
-        const descriptor = descriptors[key];
-        if (Guard.HasPropertyKey(descriptor, 'value')) {
-            Object.defineProperty(result, key, { ...descriptor, value: FromValue(descriptor.value) });
+        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
+        descriptor.value = FromValue(descriptor.value);
+        if (Guard.IsEqual(descriptor.enumerable, true)) {
+            result[key] = descriptor.value;
+        }
+        else {
+            Object.defineProperty(result, key, descriptor);
         }
     }
     return result;
@@ -55,7 +58,7 @@ function FromPlainObject(value) {
 // ------------------------------------------------------------------
 function FromObject(value) {
     return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
-        IsTypeObject(value) ? FromTypeObject(value) :
+        IsSchemaObject(value) ? FromSchemaObject(value) :
             FromPlainObject(value));
 }
 // ------------------------------------------------------------------

package/node_modules/typebox/build/system/memory/discard.mjs

@@ -1,17 +1,18 @@
 // deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /** Discards multiple property keys from the given object value */
 export function Discard(value, propertyKeys) {
     Metrics.discard += 1;
     const result = {};
-    const descriptors = Object.getOwnPropertyDescriptors(Clone(value));
-    const keysToDiscard = new Set(propertyKeys);
-    for (const key of Object.keys(descriptors)) {
-        if (keysToDiscard.has(key))
+    for (const key of Guard.Keys(value)) {
+        if (propertyKeys.includes(key))
             continue;
-        Object.defineProperty(result, key, descriptors[key]);
+        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
+        descriptor.value = Clone(descriptor.value);
+        Object.defineProperty(result, key, descriptor);
     }
     return result;
 }

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

@@ -16,6 +16,15 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
+     * context. This setting can be used to bound generic calls to a fixed count, which can be useful if
+     * evaluating string-encoded types originating from untrusted sources. Setting this value to 0 will
+     * disallow generics entirely, ensuring type instantiation runs linear.
+     *
+     * @default 128
+     */
+    maxInstantiationCount: number;
     /**
      * Enables or disables the use of runtime code evaluation to accelerate validation. By default,
      * TypeBox checks for `unsafe-eval` support in the environment before attempting to evaluate

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

@@ -3,6 +3,7 @@ import { Guard } from '../../guard/index.mjs';
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
     enumerableKind: false,
@@ -13,6 +14,7 @@ const settings = {
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
     settings.enumerableKind = false;

package/node_modules/typebox/build/type/engine/call/distribute_arguments.d.mts

@@ -1,12 +1,17 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TDeferred } from '../../types/deferred.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TParameter } from '../../types/parameter.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
 type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Left['$ref']]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
 type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
 type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
-type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
+type TCanonicalArgument<Type extends TSchema> = (Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type);
+type TExpand<Argument extends TSchema, CanonicalArgument extends TSchema = TCanonicalArgument<Argument>> = (CanonicalArgument extends TUnion<infer Types extends TSchema[]> ? [...Types] : [CanonicalArgument]);
 type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
 type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
 type TDistribute<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);

package/node_modules/typebox/build/type/engine/call/distribute_arguments.mjs

@@ -2,7 +2,14 @@
 import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { IsDeferred } from '../../types/deferred.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsRef } from '../../types/ref.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
 function CollectDistributionNames(expression, result = []) {
     return (
     // Conditional
@@ -21,10 +28,16 @@ function BuildDistributionArray(parameters, names) {
 function ZipDistributionArray(arguments_, distributionArray, result = []) {
     return Guard.ShiftLeft(arguments_, (argumentLeft, argumentRight) => Guard.ShiftLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
 }
+function CanonicalArgument(type) {
+    return (IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
+        IsEnum(type) ? EvaluateEnum(type.enum) :
+            type);
+}
 function Expand(type) {
-    return (IsUnion(type)
-        ? [...type.anyOf]
-        : [type]);
+    const canonicalArgument = CanonicalArgument(type);
+    return (IsUnion(canonicalArgument)
+        ? [...canonicalArgument.anyOf]
+        : [canonicalArgument]);
 }
 function Append(current, type) {
     return current.reduce((result, left) => [...result, [...left, type]], []);

package/node_modules/typebox/build/type/engine/call/instantiate.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../../system/settings/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { CallConstruct } from '../../types/call.mjs';
 import { Ref } from '../../types/ref.mjs';
@@ -13,6 +14,26 @@ import { State } from '../instantiate.mjs';
 import { DistributeArguments } from './distribute_arguments.mjs';
 import { ResolveTarget } from './resolve_target.mjs';
 import { ResolveArgumentsContext } from './resolve_arguments.mjs';
+// ------------------------------------------------------------------
+// InstantiationGuard
+// ------------------------------------------------------------------
+let instantiationDepth = 0;
+let instantiationCount = 0;
+function InstantiationAssert() {
+    if (Guard.IsLessThan(instantiationCount, Settings.Get().maxInstantiationCount))
+        return;
+    throw Error('Type instantiation is excessively deep and possibly infinite');
+}
+function InstantiationIncrement() {
+    InstantiationAssert();
+    instantiationCount++;
+    instantiationDepth++;
+}
+function InstantiationDecrement() {
+    instantiationDepth--;
+    if (Guard.IsEqual(instantiationDepth, 0))
+        instantiationCount = 0;
+}
 function Peek(state) {
     const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
     return result;
@@ -22,12 +43,21 @@ function IsTailCall(state, name) {
     return result;
 }
 function CallDispatch(context, state, target, parameters, expression, arguments_) {
-    const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
-    const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
-    return InstantiateType(argumentsContext, State([], []), returnType);
+    InstantiationIncrement();
+    try {
+        const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+        const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
+        return InstantiateType(argumentsContext, State([], []), returnType);
+    }
+    finally {
+        InstantiationDecrement();
+    }
 }
 function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
-    return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);
+    return distributedArguments.reduce((result, arguments_) => {
+        const returnType = CallDispatch(context, state, target, parameters, expression, arguments_);
+        return [...result, returnType];
+    }, []);
 }
 function CallImmediate(context, state, target, parameters, expression, arguments_) {
     const distributedArguments = DistributeArguments(parameters, arguments_, expression);

package/node_modules/typebox/build/type/engine/evaluate/broaden.d.mts

@@ -2,13 +2,13 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TCompare, CompareResultLeftInside, CompareResultEqual, CompareResultDisjoint } from './compare.mjs';
 import { type TFlatten } from './flatten.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
-type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
-type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
-type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
-type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
+type TBroadenFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = [], All extends TSchema[] = Types> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof CompareResultLeftInside | typeof CompareResultEqual ? All : TCompare<Type, Left> extends typeof CompareResultDisjoint ? TBroadenFilter<Type, Right, [...Result, Left], All> : TBroadenFilter<Type, Right, Result, All> : [...Result, Type]);
+type TBroadenType<Type extends TSchema, Types extends TSchema[], Result extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>> = (Evaluated extends TAny ? [Evaluated] : Evaluated extends TUnknown ? [Evaluated] : Evaluated extends TNever ? TBroadenTypes<Types, Result> : Evaluated extends TObject ? TBroadenTypes<Types, [...Result, Evaluated]> : TBroadenTypes<Types, TBroadenFilter<Evaluated, Result>>);
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBroadenType<Left, Right, Result> : Result);
 export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>> = Flattened;
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;

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

@@ -3,37 +3,31 @@ import { Guard } from '../../../guard/index.mjs';
 import { IsAny } from '../../types/any.mjs';
 import { IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Compare, CompareResultLeftInside, CompareResultEqual, CompareResultDisjoint } from './compare.mjs';
 import { Flatten } from './flatten.mjs';
 import { EvaluateType } from './evaluate.mjs';
-function BroadFilter(type, types) {
-    return types.filter(left => {
-        return Compare(type, left) === ResultRightInside
-            ? false
-            : true;
-    });
-}
-function IsBroadestType(type, types) {
-    const result = types.some(left => {
-        const result = Compare(type, left);
-        return Guard.IsEqual(result, ResultLeftInside) || Guard.IsEqual(result, ResultEqual);
-    });
-    return Guard.IsEqual(result, false);
+function BroadenFilter(type, types, result = [], all = types) {
+    return Guard.ShiftLeft(types, (left, right) => {
+        const compare = Compare(type, left);
+        return ((Guard.IsEqual(compare, CompareResultLeftInside) || Guard.IsEqual(compare, CompareResultEqual))
+            ? all // Left in set. Return original All set.
+            : Guard.IsEqual(compare, CompareResultDisjoint)
+                ? BroadenFilter(type, right, [...result, left], all) // Left is disjoint, keep it
+                : BroadenFilter(type, right, result, all) // Left in Type, drop it
+        );
+    }, () => [...result, type]); // Type broadest in set
 }
-function BroadenType(type, types) {
+function BroadenType(type, types, result) {
     const evaluated = EvaluateType(type);
-    return (IsAny(evaluated) ? [evaluated] :
-        IsBroadestType(evaluated, types)
-            ? [...BroadFilter(evaluated, types), evaluated]
-            : types);
+    return (IsAny(evaluated) ? [evaluated] : // terminate (always the most broad)
+        IsUnknown(evaluated) ? [evaluated] : // terminate (always the most broad)
+            IsNever(evaluated) ? BroadenTypes(types, result) : // ignored: never is dropped
+                IsObject(evaluated) ? BroadenTypes(types, [...result, evaluated]) : // objects are always considered (too expensive to compare)
+                    BroadenTypes(types, BroadenFilter(evaluated, result)));
 }
-function BroadenTypes(types) {
-    return types.reduce((result, left) => {
-        return (IsObject(left) ? [...result, left] : // push
-            IsNever(left) ? result : // ignore
-                BroadenType(left, result) // broaden
-        );
-    }, []);
+function BroadenTypes(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => (BroadenType(left, right, result)), () => result);
 }
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export function Broaden(types) {