@openclaw/whatsapp 2026.8.1-beta.3 → 2026.8.2

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

@@ -1,4 +1,3 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TReadonly } from '../../types/_readonly.mjs';
 import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
@@ -12,6 +11,10 @@ import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
 import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
+/** Returns true if the type is a valid operand to Composite. */
+export type TCanComposite<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
+/** Returns true if the type is a valid operand to Composite. */
+export declare function CanComposite<Type extends TSchema>(type: Type): TCanComposite<Type>;
 type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
 type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
 type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
@@ -25,10 +28,10 @@ type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly
     IsOptional
 ] extends [false, true] ? TAddOptional<Property> : Property);
 type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
-type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
-    [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;
+type TCompositeProperties<Left extends TProperties, Right extends TProperties, Keys extends PropertyKey = keyof (Left & Right), Result extends TProperties = {
+    [Key in Keys]: TCompositePropertyKey<Left, Right, Key>;
 }> = Result;
-type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : TUnreachable)> = Result;
+type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : {})> = Result;
 export type TComposite<Left extends TSchema, Right extends TSchema, LeftProperties extends TProperties = TGetProperties<Left>, RightProperties extends TProperties = TGetProperties<Right>, Properties extends TProperties = TCompositeProperties<LeftProperties, RightProperties>, Result extends TSchema = TObject<Properties>> = Result;
 export declare function Composite<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TComposite<Left, Right>;
 export {};

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

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { IsReadonly } from '../../types/_readonly.mjs';
 import { IsOptional } from '../../types/_optional.mjs';
@@ -13,6 +12,10 @@ import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
 import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
+/** Returns true if the type is a valid operand to Composite. */
+export function CanComposite(type) {
+    return (IsObject(type) || IsTuple(type));
+}
 function IsReadonlyProperty(left, right) {
     return (IsReadonly(left) ? IsReadonly(right) ? true : false : false);
 }
@@ -32,36 +35,26 @@ function CompositeProperty(left, right) {
 }
 function CompositePropertyKey(left, right, key) {
     return (key in left
-        ? key in right
-            ? CompositeProperty(left[key], right[key])
-            : left[key]
-        : key in right
-            ? right[key]
-            : Never());
+        ? key in right ? CompositeProperty(left[key], right[key]) : left[key]
+        : key in right ? right[key] : Never());
 }
 function CompositeProperties(left, right) {
-    const keys = new Set([...Guard.Keys(right), ...Guard.Keys(left)]);
-    return [...keys].reduce((result, key) => {
+    const keys = new Set([...Guard.Keys(left), ...Guard.Keys(right)]);
+    const result = [...keys].reduce((result, key) => {
         return { ...result, [key]: CompositePropertyKey(left, right, key) };
     }, {});
+    return result;
 }
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - symmetric unreachable | internal
-//
-// Composite is called by Distribute which provisions the type as
-// either TObject ot TTuple. Fall-through unreachable.
-//
-// ------------------------------------------------------------------
 function GetProperties(type) {
     const result = (IsObject(type) ? type.properties :
         IsTuple(type) ? TupleElementsToProperties(type.items) :
-            Unreachable() // {}
-    );
+            {});
     return result;
 }
 export function Composite(left, right) {
     const leftProperties = GetProperties(left);
     const rightProperties = GetProperties(right);
     const properties = CompositeProperties(leftProperties, rightProperties);
-    return Object(properties);
+    const result = Object(properties);
+    return result;
 }

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

@@ -1,27 +1,11 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TTuple } from '../../types/tuple.mjs';
-import { type TComposite } from './composite.mjs';
 import { type TNarrow } from './narrow.mjs';
-import { type TEvaluateType } from './evaluate.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
-type TIsObjectLike<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
-type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
-type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
-    IsUnionOperand
-] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [true, true] ? TComposite<EvaluatedLeft, EvaluatedRight> : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [true, false] ? EvaluatedLeft : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [false, true] ? EvaluatedRight : TNarrow<EvaluatedLeft, EvaluatedRight>)> = Result;
-type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Type, Left>]> : Result extends [] ? [Type] : Result);
+import { type TEvaluateType } from './evaluate.mjs';
+type TShouldEvaluate<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, ShouldEvaluate extends boolean = TShouldEvaluate<EvaluatedLeft, EvaluatedRight>, Result extends TSchema = [ShouldEvaluate] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : TNarrow<EvaluatedLeft, EvaluatedRight>> = Result;
+type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Left, Type>]> : Result extends [] ? [Type] : Result);
 type TDistributeUnion<Types extends TSchema[], Distribution extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeUnion<Right, Distribution, [...Result, ...TDistribute<[Left], Distribution>]> : Result);
 export type TDistribute<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TUnion<infer UnionTypes extends TSchema[]> ? TDistribute<Right, TDistributeUnion<UnionTypes, Result>> : TDistribute<Right, TDistributeType<Left, Result>> : Result);
 export declare function Distribute<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TDistribute<Types>;

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

@@ -2,36 +2,24 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { IsObject } from '../../types/object.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
-import { Composite } from './composite.mjs';
 import { Narrow } from './narrow.mjs';
-import { EvaluateType } from './evaluate.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
-function IsObjectLike(type) {
-    return IsObject(type) || IsTuple(type);
-}
-function IsUnionOperand(left, right) {
-    const isUnionLeft = IsUnion(left);
-    const isUnionRight = IsUnion(right);
-    const result = isUnionLeft || isUnionRight;
+import { EvaluateType } from './evaluate.mjs';
+function ShouldEvaluate(left, right) {
+    const result = IsUnion(left) || IsUnion(right);
     return result;
 }
 function DistributeOperation(left, right) {
     const evaluatedLeft = EvaluateType(left);
     const evaluatedRight = EvaluateType(right);
-    const isUnionOperand = IsUnionOperand(evaluatedLeft, evaluatedRight);
-    const isObjectLeft = IsObjectLike(evaluatedLeft);
-    const IsObjectRight = IsObjectLike(evaluatedRight);
-    const result = (isUnionOperand ? EvaluateIntersect([evaluatedLeft, evaluatedRight]) :
-        isObjectLeft && IsObjectRight ? Composite(evaluatedLeft, evaluatedRight) :
-            isObjectLeft && !IsObjectRight ? evaluatedLeft :
-                !isObjectLeft && IsObjectRight ? evaluatedRight :
-                    Narrow(evaluatedLeft, evaluatedRight));
+    const shouldEvaluate = ShouldEvaluate(evaluatedLeft, evaluatedRight);
+    const result = shouldEvaluate
+        ? EvaluateIntersect([evaluatedLeft, evaluatedRight])
+        : Narrow(evaluatedLeft, evaluatedRight);
     return result;
 }
 function DistributeType(type, types, result = []) {
-    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
+    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(left, type)]), () => Guard.IsEqual(result.length, 0)
         ? [type]
         : result);
 }

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

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TDependent } from '../../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
@@ -10,11 +10,11 @@ import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
 import { type TExcludeOperation } from '../exclude/operation.mjs';
 import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersected extends TSchema = TEvaluateIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersected, Excluded]>> = Result;
 export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
 export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
-export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
-export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values], result?: TSchema[]): TEvaluateEnum<Values>;
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnion<Broadend>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
 export type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
 export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;

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

@@ -2,29 +2,31 @@
 import { Guard } from '../../../guard/index.mjs';
 import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
 import { Literal } from '../../types/literal.mjs';
-import { IsIntersect, Intersect } from '../../types/intersect.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
 import { ExcludeOperation } from '../exclude/operation.mjs';
 import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 export function EvaluateDependent(if_, then_, else_) {
-    const intersect = Intersect([if_, then_]);
+    const intersected = EvaluateIntersect([if_, then_]);
     const excluded = ExcludeOperation(else_, if_);
-    const result = EvaluateUnion([intersect, excluded]);
+    const result = EvaluateUnion([intersected, excluded]);
     return result;
 }
-export function EvaluateEnum(values) {
-    const result = values.map(value => Literal(value));
-    return EvaluateUnion(result);
+export function EvaluateEnum(values, result = []) {
+    return Guard.ShiftLeft(values, (left, right) => EvaluateEnum(right, [...result, Literal(left)]), () => EvaluateUnion(result));
 }
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const broadend = Broaden(distribution);
-    const result = EvaluateUnionFast(broadend);
+    const result = EvaluateUnion(broadend);
     return result;
 }
 export function EvaluateTemplateLiteral(pattern) {
@@ -38,12 +40,13 @@ export function EvaluateUnion(types) {
     return result;
 }
 export function EvaluateType(type) {
-    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+    const result = (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
         IsEnum(type) ? EvaluateEnum(type.enum) :
             IsIntersect(type) ? EvaluateIntersect(type.allOf) :
                 IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
                     IsUnion(type) ? EvaluateUnion(type.anyOf) :
                         type);
+    return result;
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

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

@@ -2,5 +2,5 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
 export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
-export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export declare function Flatten<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TFlatten<Types>;
 export {};

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

@@ -1,11 +1,10 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 function FlattenType(type) {
     const result = IsUnion(type) ? Flatten(type.anyOf) : [type];
     return result;
 }
-export function Flatten(types) {
-    return types.reduce((result, type) => {
-        return [...result, ...FlattenType(type)];
-    }, []);
+export function Flatten(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Flatten(right, [...result, ...FlattenType(left)]), () => result);
 }

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

@@ -1,5 +1,20 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
-import { type TCompare, type TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TCompare, type TCompareResult, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { type TComposite, type TCanComposite } from './composite.mjs';
+type TNarrowCompareRule<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof CompareResultLeftInside ? Left : Result extends typeof CompareResultRightInside ? Right : Result extends typeof CompareResultEqual ? Right : TNever);
+type TNarrowCompositeRule<Left extends TSchema, Right extends TSchema, CanCompositeLeft extends boolean = TCanComposite<Left>, CanCompositeRight extends boolean = TCanComposite<Right>> = ([
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, true] ? TComposite<Left, Right> : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, false] ? Left : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [false, true] ? Right : TNarrowCompareRule<Left, Right>);
+export type TNarrow<Left extends TSchema, Right extends TSchema> = (Left extends TNever ? TNever : Left extends TAny ? TAny : Left extends TUnknown ? Right : Right extends TNever ? TNever : Right extends TAny ? TAny : Right extends TUnknown ? Left : TNarrowCompositeRule<Left, Right>);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;
+export {};

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

@@ -1,11 +1,31 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Never } from '../../types/never.mjs';
-import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export function Narrow(left, right) {
+import { IsAny } from '../../types/any.mjs';
+import { Never, IsNever } from '../../types/never.mjs';
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Compare, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { Composite, CanComposite } from './composite.mjs';
+function NarrowCompareRule(left, right) {
     const result = Compare(left, right);
-    return (Guard.IsEqual(result, ResultLeftInside) ? left :
-        Guard.IsEqual(result, ResultRightInside) ? right :
-            Guard.IsEqual(result, ResultEqual) ? right :
+    return (Guard.IsEqual(result, CompareResultLeftInside) ? left :
+        Guard.IsEqual(result, CompareResultRightInside) ? right :
+            Guard.IsEqual(result, CompareResultEqual) ? right :
                 Never());
 }
+function NarrowCompositeRule(left, right) {
+    const canCompositeLeft = CanComposite(left);
+    const canCompositeRight = CanComposite(right);
+    return (canCompositeLeft && canCompositeRight ? Composite(left, right) :
+        canCompositeLeft && !canCompositeRight ? left :
+            !canCompositeLeft && canCompositeRight ? right :
+                NarrowCompareRule(left, right));
+}
+export function Narrow(left, right) {
+    return (IsNever(left) ? left :
+        IsAny(left) ? left :
+            IsUnknown(left) ? right :
+                IsNever(right) ? right :
+                    IsAny(right) ? right :
+                        IsUnknown(right) ? left :
+                            NarrowCompositeRule(left, right));
+}

package/node_modules/typebox/build/type/engine/exclude/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExcludeType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
     return result;
 }
-function ExcludeUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeType(head, right)];
-    }, []);
+function ExcludeUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExcludeUnion(tail, right, [...result, ...ExcludeType(head, right)]), () => result);
 }
 export function ExcludeOperation(left, right) {
     const evaluated = EvaluateType(left);

package/node_modules/typebox/build/type/engine/extract/operation.d.mts

@@ -4,7 +4,7 @@ import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TEvaluateType } from '../evaluate/evaluate.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
 type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
-type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+type TExtractUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
 export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
 export {};

package/node_modules/typebox/build/type/engine/extract/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExtractType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
     return result;
 }
-function ExtractUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractType(head, right)];
-    }, []);
+function ExtractUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExtractUnion(tail, right, [...result, ...ExtractType(head, right)]), () => result);
 }
 export function ExtractOperation(left, right) {
     const evaluated = EvaluateType(left);

package/node_modules/typebox/build/type/engine/priority/priority.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TCompare, type TCompareResult } from '../evaluate/compare.mjs';
-type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends 'right-inside' ? 1 : CompareResult extends 'disjoint' ? 1 : 0)> = Result;
+import { type TCompare, type TCompareResult, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
+type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends typeof CompareResultRightInside ? 1 : CompareResult extends typeof CompareResultDisjoint ? 1 : 0)> = Result;
 type TInsert<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TComparer<Type, Left> extends 1 ? TInsert<Type, Right, [...Result, Left]> : [...Result, Type, ...Types] : [...Result, Type]);
 type TSort<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TSort<Right, TInsert<Left, Result>> : Result);
 /**

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

@@ -1,12 +1,11 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Compare } from '../evaluate/compare.mjs';
+import { Compare, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
 function Comparer(left, right) {
     const compareResult = Compare(left, right);
-    const result = (Guard.IsEqual(compareResult, 'right-inside') ? 1 :
-        Guard.IsEqual(compareResult, 'disjoint') ? 1 :
+    return (Guard.IsEqual(compareResult, CompareResultRightInside) ? 1 :
+        Guard.IsEqual(compareResult, CompareResultDisjoint) ? 1 :
             0);
-    return result;
 }
 function Insert(type, types, result = []) {
     return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)

package/node_modules/typebox/build/type/script/mapping.d.mts

@@ -65,8 +65,8 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
     Target,
     Parameters
 ] extends ['Uppercase', [infer Type extends T.TSchema]] ? S.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
-type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (Input extends [infer Left, ...infer Right] ? Left extends [infer Item, infer _] ? TDelimitedDecode<Right, [...Result, Item]> : TDelimitedDecode<Right, [...Result, Left]> : Result);
-type TDelimited<Input extends [unknown, unknown]> = Input extends [infer Left extends unknown[], infer Right extends unknown[]] ? TDelimitedDecode<[...Left, ...Right]> : [];
+type TDelimitedDecode<Input extends [unknown, unknown][], Result extends unknown[] = []> = (Input extends [infer Left extends [unknown, unknown], ...infer Right extends [unknown, unknown][]] ? TDelimitedDecode<Right, [...Result, Left[1]]> : Result);
+type TDelimited<Input extends [unknown, unknown, unknown] | []> = (Input extends [infer Left extends unknown, infer Right extends [unknown, unknown][], infer _ extends unknown[]] ? [Left, ...TDelimitedDecode<Right>] : []);
 export type TGenericParameterExtendsEqualsMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema, '=', infer Equals extends T.TSchema] ? T.TParameter<Name, Extends, Equals> : never);
 export declare function GenericParameterExtendsEqualsMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TGenericParameterExtendsMapping<Input extends [unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema] ? T.TParameter<Name, Extends, Extends> : never);
@@ -77,12 +77,12 @@ export type TGenericParameterIdentifierMapping<Input extends string, Result exte
 export declare function GenericParameterIdentifierMapping(input: string): unknown;
 export type TGenericParameterMapping<Input extends unknown> = (Input);
 export declare function GenericParameterMapping(input: unknown): unknown;
-export type TGenericParameterListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function GenericParameterListMapping(input: [unknown, unknown]): unknown;
+export type TGenericParameterListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function GenericParameterListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TGenericParametersMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['<', infer Parameters extends T.TParameter[], '>'] ? Parameters : never);
 export declare function GenericParametersMapping(input: [unknown, unknown, unknown]): unknown;
-export type TGenericCallArgumentListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function GenericCallArgumentListMapping(input: [unknown, unknown]): unknown;
+export type TGenericCallArgumentListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function GenericCallArgumentListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TGenericCallArgumentsMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['<', infer Arguments extends T.TSchema[], '>'] ? Arguments : never);
 export declare function GenericCallArgumentsMapping(input: [unknown, unknown, unknown]): unknown;
 export type TGenericCallMapping<Input extends [unknown, unknown], Result = Input extends [infer Ref extends string, infer Arguments extends T.TSchema[]] ? TIntrinsicOrCall<Ref, Arguments> : never> = Result;
@@ -202,8 +202,8 @@ export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown,
 export declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
 export declare function PropertyDelimiterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function PropertyListMapping(input: [unknown, unknown]): unknown;
+export type TPropertyListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function PropertyListMapping(input: [unknown, unknown, unknown] | []): unknown;
 type TPropertiesReduce<PropertiesList extends T.TProperties[], Result extends [properties: T.TProperties, patternProperties: T.TProperties] = [{}, {}]> = (PropertiesList extends [infer Left extends T.TProperties, ...infer Right extends T.TProperties[]] ? (Left extends {
     [_ in T.TIntegerKey]: T.TSchema;
 } ? TPropertiesReduce<Right, [Result[0], Memory.TAssign<Result[1], Left>]> : Left extends {
@@ -219,18 +219,21 @@ export type T_Object_Mapping<Input extends unknown> = (Input extends [infer Prop
 export declare function _Object_Mapping(input: unknown): unknown;
 export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
 export declare function ElementNamedMapping(input: [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
-export declare function ElementReadonlyOptionalMapping(input: [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
-export declare function ElementReadonlyMapping(input: [unknown, unknown]): unknown;
-export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? S.TAddOptionalDeferred<Type> : never);
-export declare function ElementOptionalMapping(input: [unknown, unknown]): unknown;
-export type TElementBaseMapping<Input extends unknown> = (Input);
-export declare function ElementBaseMapping(input: unknown): unknown;
+export type TElementBaseMapping<Input extends unknown | [unknown, unknown, unknown]> = (Input extends [infer IsReadonly extends boolean, infer Type extends T.TSchema, infer IsOptional extends boolean] ? ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? S.TAddReadonlyDeferred<Type> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? S.TAddOptionalDeferred<Type> : Type) : Input);
+export declare function ElementBaseMapping(input: unknown | [unknown, unknown, unknown]): unknown;
 export type TElementMapping<Input extends [unknown, unknown] | [unknown]> = (Input extends ['...', infer Type extends T.TSchema] ? T.TRest<Type> : Input extends [infer Type extends T.TSchema] ? Type : never);
 export declare function ElementMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function ElementListMapping(input: [unknown, unknown]): unknown;
+export type TElementListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ElementListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type T_Tuple_Mapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never);
 export declare function _Tuple_Mapping(input: [unknown, unknown, unknown]): unknown;
 export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
@@ -245,8 +248,8 @@ export type TParameterBaseMapping<Input extends unknown> = (Input);
 export declare function ParameterBaseMapping(input: unknown): unknown;
 export type TParameterMapping<Input extends [unknown, unknown] | [unknown]> = (Input extends ['...', infer Type extends T.TSchema] ? T.TRest<Type> : Input extends [infer Type extends T.TSchema] ? Type : never);
 export declare function ParameterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TParameterListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function ParameterListMapping(input: [unknown, unknown]): unknown;
+export type TParameterListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ParameterListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type T_Function_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema] ? T.TFunction<ParameterList, ReturnType> : never);
 export declare function _Function_Mapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type T_Constructor_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never);
@@ -280,15 +283,15 @@ export type TWithPropertyMapping<Input extends [unknown, unknown, unknown]> = (I
     [_ in Key]: Value;
 } : never);
 export declare function WithPropertyMapping(input: [unknown, unknown, unknown]): unknown;
-export type TWithPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function WithPropertyListMapping(input: [unknown, unknown]): unknown;
+export type TWithPropertyListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function WithPropertyListMapping(input: [unknown, unknown, unknown] | []): unknown;
 type TWithObjectMappingReduce<PropertyList extends Record<PropertyKey, unknown>[], Result extends Record<PropertyKey, unknown> = {}> = (PropertyList extends [infer Left extends Record<PropertyKey, unknown>, ...infer Right extends Record<PropertyKey, unknown>[]] ? TWithObjectMappingReduce<Right, Memory.TAssign<Result, Left>> : {
     [Key in keyof Result]: Result[Key];
 });
 export type TWithObjectMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['{', infer PropertyList extends Record<PropertyKey, unknown>[], '}'] ? TWithObjectMappingReduce<PropertyList> : {});
 export declare function WithObjectMapping(input: [unknown, unknown, unknown]): unknown;
-export type TWithElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function WithElementListMapping(input: [unknown, unknown]): unknown;
+export type TWithElementListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function WithElementListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TWithArrayMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Elements extends unknown[], ']'] ? Elements : never);
 export declare function WithArrayMapping(input: [unknown, unknown, unknown]): unknown;
 export type TWithValueMapping<Input extends unknown> = (Input);
@@ -318,8 +321,8 @@ export type TPatternBodyMapping<Input extends unknown> = (Input);
 export declare function PatternBodyMapping(input: unknown): unknown;
 export type TPatternMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['^', infer Body extends T.TSchema[], '$'] ? Body : never);
 export declare function PatternMapping(input: [unknown, unknown, unknown]): unknown;
-export type TInterfaceDeclarationHeritageListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function InterfaceDeclarationHeritageListMapping(input: [unknown, unknown]): unknown;
+export type TInterfaceDeclarationHeritageListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function InterfaceDeclarationHeritageListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationHeritageMapping<Input extends [unknown, unknown] | []> = (Input extends ['extends', infer Heritage extends T.TSchema[]] ? Heritage : []);
 export declare function InterfaceDeclarationHeritageMapping(input: [unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Parameters extends T.TParameter[], infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
@@ -342,11 +345,11 @@ export type TExportKeywordMapping<Input extends [unknown] | []> = (null);
 export declare function ExportKeywordMapping(input: [unknown] | []): unknown;
 export type TModuleDeclarationDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
 export declare function ModuleDeclarationDelimiterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TModuleDeclarationListMapping<Input extends [unknown, unknown]> = (TPropertiesReduce<TDelimited<Input>>);
-export declare function ModuleDeclarationListMapping(input: [unknown, unknown]): unknown;
+export type TModuleDeclarationListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ModuleDeclarationListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TModuleDeclarationMapping<Input extends [unknown, unknown, unknown]> = (Input extends [null, infer ModuleDeclaration extends T.TProperties, null] ? ModuleDeclaration : never);
 export declare function ModuleDeclarationMapping(input: [unknown, unknown, unknown]): unknown;
-export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
+export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends T.TProperties[]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, TPropertiesReduce<ModuleDeclarationList>[0]>> : never);
 export declare function ModuleMapping(input: [unknown, unknown]): unknown;
 export type TScriptMapping<Input extends unknown> = (Input);
 export declare function ScriptMapping(input: unknown): unknown;